diff --git a/src/lib.rs b/src/lib.rs
index 77acae1f..5f2843a5 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -4,7 +4,11 @@
 // This module setup is necessary because the generated code contains "super::" calls for dependencies.
 #![cfg_attr(not(feature = "std"), no_std)]
 #![deny(warnings, trivial_casts, trivial_numeric_casts, unused_import_braces)]
-#![allow(clippy::large_enum_variant, clippy::derive_partial_eq_without_eq)]
+#![allow(
+    clippy::large_enum_variant,
+    clippy::derive_partial_eq_without_eq,
+    clippy::needless_borrows_for_generic_args
+)]
 #![allow(rustdoc::bare_urls)]
 #![forbid(unsafe_code)]
 
diff --git a/src/prost/cosmos.app.v1alpha1.serde.rs b/src/prost/cosmos.app.v1alpha1.serde.rs
index a9f35d02..95f7c7de 100644
--- a/src/prost/cosmos.app.v1alpha1.serde.rs
+++ b/src/prost/cosmos.app.v1alpha1.serde.rs
@@ -66,18 +66,18 @@ impl<'de> serde::Deserialize<'de> for MigrateFromInfo {
                 formatter.write_str("struct cosmos.app.v1alpha1.MigrateFromInfo")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MigrateFromInfo, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MigrateFromInfo, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut module__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Module => {
                             if module__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("module"));
                             }
-                            module__ = Some(map.next_value()?);
+                            module__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -178,32 +178,32 @@ impl<'de> serde::Deserialize<'de> for ModuleDescriptor {
                 formatter.write_str("struct cosmos.app.v1alpha1.ModuleDescriptor")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ModuleDescriptor, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ModuleDescriptor, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut go_import__ = None;
                 let mut use_package__ = None;
                 let mut can_migrate_from__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::GoImport => {
                             if go_import__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("goImport"));
                             }
-                            go_import__ = Some(map.next_value()?);
+                            go_import__ = Some(map_.next_value()?);
                         }
                         GeneratedField::UsePackage => {
                             if use_package__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("usePackage"));
                             }
-                            use_package__ = Some(map.next_value()?);
+                            use_package__ = Some(map_.next_value()?);
                         }
                         GeneratedField::CanMigrateFrom => {
                             if can_migrate_from__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("canMigrateFrom"));
                             }
-                            can_migrate_from__ = Some(map.next_value()?);
+                            can_migrate_from__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -294,26 +294,26 @@ impl<'de> serde::Deserialize<'de> for PackageReference {
                 formatter.write_str("struct cosmos.app.v1alpha1.PackageReference")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<PackageReference, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<PackageReference, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut name__ = None;
                 let mut revision__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Name => {
                             if name__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("name"));
                             }
-                            name__ = Some(map.next_value()?);
+                            name__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Revision => {
                             if revision__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("revision"));
                             }
                             revision__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
diff --git a/src/prost/cosmos.auth.module.v1.serde.rs b/src/prost/cosmos.auth.module.v1.serde.rs
index 1c3fc79e..72f892f8 100644
--- a/src/prost/cosmos.auth.module.v1.serde.rs
+++ b/src/prost/cosmos.auth.module.v1.serde.rs
@@ -86,32 +86,32 @@ impl<'de> serde::Deserialize<'de> for Module {
                 formatter.write_str("struct cosmos.auth.module.v1.Module")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Module, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Module, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut bech32_prefix__ = None;
                 let mut module_account_permissions__ = None;
                 let mut authority__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Bech32Prefix => {
                             if bech32_prefix__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("bech32Prefix"));
                             }
-                            bech32_prefix__ = Some(map.next_value()?);
+                            bech32_prefix__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ModuleAccountPermissions => {
                             if module_account_permissions__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("moduleAccountPermissions"));
                             }
-                            module_account_permissions__ = Some(map.next_value()?);
+                            module_account_permissions__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Authority => {
                             if authority__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("authority"));
                             }
-                            authority__ = Some(map.next_value()?);
+                            authority__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -202,25 +202,25 @@ impl<'de> serde::Deserialize<'de> for ModuleAccountPermission {
                 formatter.write_str("struct cosmos.auth.module.v1.ModuleAccountPermission")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ModuleAccountPermission, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ModuleAccountPermission, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut account__ = None;
                 let mut permissions__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Account => {
                             if account__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("account"));
                             }
-                            account__ = Some(map.next_value()?);
+                            account__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Permissions => {
                             if permissions__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("permissions"));
                             }
-                            permissions__ = Some(map.next_value()?);
+                            permissions__ = Some(map_.next_value()?);
                         }
                     }
                 }
diff --git a/src/prost/cosmos.auth.v1beta1.serde.rs b/src/prost/cosmos.auth.v1beta1.serde.rs
index 810635b8..2a8f69cb 100644
--- a/src/prost/cosmos.auth.v1beta1.serde.rs
+++ b/src/prost/cosmos.auth.v1beta1.serde.rs
@@ -11,6 +11,7 @@ impl serde::Serialize for AddressBytesToStringRequest {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.auth.v1beta1.AddressBytesToStringRequest", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("addressBytes", pbjson::private::base64::encode(&self.address_bytes).as_str())?;
         }
         struct_ser.end()
@@ -67,19 +68,19 @@ impl<'de> serde::Deserialize<'de> for AddressBytesToStringRequest {
                 formatter.write_str("struct cosmos.auth.v1beta1.AddressBytesToStringRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<AddressBytesToStringRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<AddressBytesToStringRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut address_bytes__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::AddressBytes => {
                             if address_bytes__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("addressBytes"));
                             }
                             address_bytes__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -161,18 +162,18 @@ impl<'de> serde::Deserialize<'de> for AddressBytesToStringResponse {
                 formatter.write_str("struct cosmos.auth.v1beta1.AddressBytesToStringResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<AddressBytesToStringResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<AddressBytesToStringResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut address_string__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::AddressString => {
                             if address_string__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("addressString"));
                             }
-                            address_string__ = Some(map.next_value()?);
+                            address_string__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -253,18 +254,18 @@ impl<'de> serde::Deserialize<'de> for AddressStringToBytesRequest {
                 formatter.write_str("struct cosmos.auth.v1beta1.AddressStringToBytesRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<AddressStringToBytesRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<AddressStringToBytesRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut address_string__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::AddressString => {
                             if address_string__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("addressString"));
                             }
-                            address_string__ = Some(map.next_value()?);
+                            address_string__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -289,6 +290,7 @@ impl serde::Serialize for AddressStringToBytesResponse {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.auth.v1beta1.AddressStringToBytesResponse", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("addressBytes", pbjson::private::base64::encode(&self.address_bytes).as_str())?;
         }
         struct_ser.end()
@@ -345,19 +347,19 @@ impl<'de> serde::Deserialize<'de> for AddressStringToBytesResponse {
                 formatter.write_str("struct cosmos.auth.v1beta1.AddressStringToBytesResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<AddressStringToBytesResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<AddressStringToBytesResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut address_bytes__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::AddressBytes => {
                             if address_bytes__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("addressBytes"));
                             }
                             address_bytes__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -398,9 +400,11 @@ impl serde::Serialize for BaseAccount {
             struct_ser.serialize_field("pubKey", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("accountNumber", ::alloc::string::ToString::to_string(&self.account_number).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?;
         }
         struct_ser.end()
@@ -467,7 +471,7 @@ impl<'de> serde::Deserialize<'de> for BaseAccount {
                 formatter.write_str("struct cosmos.auth.v1beta1.BaseAccount")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<BaseAccount, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<BaseAccount, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -475,26 +479,26 @@ impl<'de> serde::Deserialize<'de> for BaseAccount {
                 let mut pub_key__ = None;
                 let mut account_number__ = None;
                 let mut sequence__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Address => {
                             if address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("address"));
                             }
-                            address__ = Some(map.next_value()?);
+                            address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::PubKey => {
                             if pub_key__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pubKey"));
                             }
-                            pub_key__ = map.next_value()?;
+                            pub_key__ = map_.next_value()?;
                         }
                         GeneratedField::AccountNumber => {
                             if account_number__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("accountNumber"));
                             }
                             account_number__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Sequence => {
@@ -502,7 +506,7 @@ impl<'de> serde::Deserialize<'de> for BaseAccount {
                                 return Err(serde::de::Error::duplicate_field("sequence"));
                             }
                             sequence__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -575,12 +579,12 @@ impl<'de> serde::Deserialize<'de> for Bech32PrefixRequest {
                 formatter.write_str("struct cosmos.auth.v1beta1.Bech32PrefixRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Bech32PrefixRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Bech32PrefixRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(Bech32PrefixRequest {
                 })
@@ -658,18 +662,18 @@ impl<'de> serde::Deserialize<'de> for Bech32PrefixResponse {
                 formatter.write_str("struct cosmos.auth.v1beta1.Bech32PrefixResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Bech32PrefixResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Bech32PrefixResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut bech32_prefix__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Bech32Prefix => {
                             if bech32_prefix__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("bech32Prefix"));
                             }
-                            bech32_prefix__ = Some(map.next_value()?);
+                            bech32_prefix__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -758,25 +762,25 @@ impl<'de> serde::Deserialize<'de> for GenesisState {
                 formatter.write_str("struct cosmos.auth.v1beta1.GenesisState")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<GenesisState, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<GenesisState, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut params__ = None;
                 let mut accounts__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Params => {
                             if params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("params"));
                             }
-                            params__ = map.next_value()?;
+                            params__ = map_.next_value()?;
                         }
                         GeneratedField::Accounts => {
                             if accounts__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("accounts"));
                             }
-                            accounts__ = Some(map.next_value()?);
+                            accounts__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -876,32 +880,32 @@ impl<'de> serde::Deserialize<'de> for ModuleAccount {
                 formatter.write_str("struct cosmos.auth.v1beta1.ModuleAccount")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ModuleAccount, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ModuleAccount, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut base_account__ = None;
                 let mut name__ = None;
                 let mut permissions__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::BaseAccount => {
                             if base_account__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("baseAccount"));
                             }
-                            base_account__ = map.next_value()?;
+                            base_account__ = map_.next_value()?;
                         }
                         GeneratedField::Name => {
                             if name__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("name"));
                             }
-                            name__ = Some(map.next_value()?);
+                            name__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Permissions => {
                             if permissions__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("permissions"));
                             }
-                            permissions__ = Some(map.next_value()?);
+                            permissions__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -994,26 +998,26 @@ impl<'de> serde::Deserialize<'de> for ModuleCredential {
                 formatter.write_str("struct cosmos.auth.v1beta1.ModuleCredential")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ModuleCredential, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ModuleCredential, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut module_name__ = None;
                 let mut derivation_keys__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ModuleName => {
                             if module_name__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("moduleName"));
                             }
-                            module_name__ = Some(map.next_value()?);
+                            module_name__ = Some(map_.next_value()?);
                         }
                         GeneratedField::DerivationKeys => {
                             if derivation_keys__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("derivationKeys"));
                             }
                             derivation_keys__ = 
-                                Some(map.next_value::<::alloc::vec::Vec<::pbjson::private::BytesDeserialize<_>>>()?
+                                Some(map_.next_value::<::alloc::vec::Vec<::pbjson::private::BytesDeserialize<_>>>()?
                                     .into_iter().map(|x| x.0).collect())
                             ;
                         }
@@ -1105,25 +1109,25 @@ impl<'de> serde::Deserialize<'de> for MsgUpdateParams {
                 formatter.write_str("struct cosmos.auth.v1beta1.MsgUpdateParams")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgUpdateParams, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgUpdateParams, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut authority__ = None;
                 let mut params__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Authority => {
                             if authority__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("authority"));
                             }
-                            authority__ = Some(map.next_value()?);
+                            authority__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Params => {
                             if params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("params"));
                             }
-                            params__ = map.next_value()?;
+                            params__ = map_.next_value()?;
                         }
                     }
                 }
@@ -1193,12 +1197,12 @@ impl<'de> serde::Deserialize<'de> for MsgUpdateParamsResponse {
                 formatter.write_str("struct cosmos.auth.v1beta1.MsgUpdateParamsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgUpdateParamsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgUpdateParamsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgUpdateParamsResponse {
                 })
@@ -1232,18 +1236,23 @@ impl serde::Serialize for Params {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.auth.v1beta1.Params", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("maxMemoCharacters", ::alloc::string::ToString::to_string(&self.max_memo_characters).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("txSigLimit", ::alloc::string::ToString::to_string(&self.tx_sig_limit).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("txSizeCostPerByte", ::alloc::string::ToString::to_string(&self.tx_size_cost_per_byte).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("sigVerifyCostEd25519", ::alloc::string::ToString::to_string(&self.sig_verify_cost_ed25519).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("sigVerifyCostSecp256k1", ::alloc::string::ToString::to_string(&self.sig_verify_cost_secp256k1).as_str())?;
         }
         struct_ser.end()
@@ -1316,7 +1325,7 @@ impl<'de> serde::Deserialize<'de> for Params {
                 formatter.write_str("struct cosmos.auth.v1beta1.Params")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Params, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Params, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -1325,14 +1334,14 @@ impl<'de> serde::Deserialize<'de> for Params {
                 let mut tx_size_cost_per_byte__ = None;
                 let mut sig_verify_cost_ed25519__ = None;
                 let mut sig_verify_cost_secp256k1__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::MaxMemoCharacters => {
                             if max_memo_characters__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("maxMemoCharacters"));
                             }
                             max_memo_characters__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::TxSigLimit => {
@@ -1340,7 +1349,7 @@ impl<'de> serde::Deserialize<'de> for Params {
                                 return Err(serde::de::Error::duplicate_field("txSigLimit"));
                             }
                             tx_sig_limit__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::TxSizeCostPerByte => {
@@ -1348,7 +1357,7 @@ impl<'de> serde::Deserialize<'de> for Params {
                                 return Err(serde::de::Error::duplicate_field("txSizeCostPerByte"));
                             }
                             tx_size_cost_per_byte__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::SigVerifyCostEd25519 => {
@@ -1356,7 +1365,7 @@ impl<'de> serde::Deserialize<'de> for Params {
                                 return Err(serde::de::Error::duplicate_field("sigVerifyCostEd25519"));
                             }
                             sig_verify_cost_ed25519__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::SigVerifyCostSecp256k1 => {
@@ -1364,7 +1373,7 @@ impl<'de> serde::Deserialize<'de> for Params {
                                 return Err(serde::de::Error::duplicate_field("sigVerifyCostSecp256k1"));
                             }
                             sig_verify_cost_secp256k1__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -1397,9 +1406,11 @@ impl serde::Serialize for QueryAccountAddressByIdRequest {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.auth.v1beta1.QueryAccountAddressByIDRequest", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("id", ::alloc::string::ToString::to_string(&self.id).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("accountId", ::alloc::string::ToString::to_string(&self.account_id).as_str())?;
         }
         struct_ser.end()
@@ -1459,20 +1470,20 @@ impl<'de> serde::Deserialize<'de> for QueryAccountAddressByIdRequest {
                 formatter.write_str("struct cosmos.auth.v1beta1.QueryAccountAddressByIDRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryAccountAddressByIdRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryAccountAddressByIdRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut id__ = None;
                 let mut account_id__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Id => {
                             if id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("id"));
                             }
                             id__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::AccountId => {
@@ -1480,7 +1491,7 @@ impl<'de> serde::Deserialize<'de> for QueryAccountAddressByIdRequest {
                                 return Err(serde::de::Error::duplicate_field("accountId"));
                             }
                             account_id__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -1563,18 +1574,18 @@ impl<'de> serde::Deserialize<'de> for QueryAccountAddressByIdResponse {
                 formatter.write_str("struct cosmos.auth.v1beta1.QueryAccountAddressByIDResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryAccountAddressByIdResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryAccountAddressByIdResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut account_address__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::AccountAddress => {
                             if account_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("accountAddress"));
                             }
-                            account_address__ = Some(map.next_value()?);
+                            account_address__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1654,18 +1665,18 @@ impl<'de> serde::Deserialize<'de> for QueryAccountInfoRequest {
                 formatter.write_str("struct cosmos.auth.v1beta1.QueryAccountInfoRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryAccountInfoRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryAccountInfoRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut address__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Address => {
                             if address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("address"));
                             }
-                            address__ = Some(map.next_value()?);
+                            address__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1745,18 +1756,18 @@ impl<'de> serde::Deserialize<'de> for QueryAccountInfoResponse {
                 formatter.write_str("struct cosmos.auth.v1beta1.QueryAccountInfoResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryAccountInfoResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryAccountInfoResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut info__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Info => {
                             if info__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("info"));
                             }
-                            info__ = map.next_value()?;
+                            info__ = map_.next_value()?;
                         }
                     }
                 }
@@ -1836,18 +1847,18 @@ impl<'de> serde::Deserialize<'de> for QueryAccountRequest {
                 formatter.write_str("struct cosmos.auth.v1beta1.QueryAccountRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryAccountRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryAccountRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut address__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Address => {
                             if address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("address"));
                             }
-                            address__ = Some(map.next_value()?);
+                            address__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1927,18 +1938,18 @@ impl<'de> serde::Deserialize<'de> for QueryAccountResponse {
                 formatter.write_str("struct cosmos.auth.v1beta1.QueryAccountResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryAccountResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryAccountResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut account__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Account => {
                             if account__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("account"));
                             }
-                            account__ = map.next_value()?;
+                            account__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2018,18 +2029,18 @@ impl<'de> serde::Deserialize<'de> for QueryAccountsRequest {
                 formatter.write_str("struct cosmos.auth.v1beta1.QueryAccountsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryAccountsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryAccountsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2118,25 +2129,25 @@ impl<'de> serde::Deserialize<'de> for QueryAccountsResponse {
                 formatter.write_str("struct cosmos.auth.v1beta1.QueryAccountsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryAccountsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryAccountsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut accounts__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Accounts => {
                             if accounts__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("accounts"));
                             }
-                            accounts__ = Some(map.next_value()?);
+                            accounts__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2217,18 +2228,18 @@ impl<'de> serde::Deserialize<'de> for QueryModuleAccountByNameRequest {
                 formatter.write_str("struct cosmos.auth.v1beta1.QueryModuleAccountByNameRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryModuleAccountByNameRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryModuleAccountByNameRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut name__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Name => {
                             if name__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("name"));
                             }
-                            name__ = Some(map.next_value()?);
+                            name__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -2308,18 +2319,18 @@ impl<'de> serde::Deserialize<'de> for QueryModuleAccountByNameResponse {
                 formatter.write_str("struct cosmos.auth.v1beta1.QueryModuleAccountByNameResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryModuleAccountByNameResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryModuleAccountByNameResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut account__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Account => {
                             if account__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("account"));
                             }
-                            account__ = map.next_value()?;
+                            account__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2388,12 +2399,12 @@ impl<'de> serde::Deserialize<'de> for QueryModuleAccountsRequest {
                 formatter.write_str("struct cosmos.auth.v1beta1.QueryModuleAccountsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryModuleAccountsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryModuleAccountsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(QueryModuleAccountsRequest {
                 })
@@ -2470,18 +2481,18 @@ impl<'de> serde::Deserialize<'de> for QueryModuleAccountsResponse {
                 formatter.write_str("struct cosmos.auth.v1beta1.QueryModuleAccountsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryModuleAccountsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryModuleAccountsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut accounts__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Accounts => {
                             if accounts__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("accounts"));
                             }
-                            accounts__ = Some(map.next_value()?);
+                            accounts__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -2550,12 +2561,12 @@ impl<'de> serde::Deserialize<'de> for QueryParamsRequest {
                 formatter.write_str("struct cosmos.auth.v1beta1.QueryParamsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryParamsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryParamsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(QueryParamsRequest {
                 })
@@ -2632,18 +2643,18 @@ impl<'de> serde::Deserialize<'de> for QueryParamsResponse {
                 formatter.write_str("struct cosmos.auth.v1beta1.QueryParamsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryParamsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryParamsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut params__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Params => {
                             if params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("params"));
                             }
-                            params__ = map.next_value()?;
+                            params__ = map_.next_value()?;
                         }
                     }
                 }
diff --git a/src/prost/cosmos.bank.module.v1.serde.rs b/src/prost/cosmos.bank.module.v1.serde.rs
index e31ada9f..d9196d61 100644
--- a/src/prost/cosmos.bank.module.v1.serde.rs
+++ b/src/prost/cosmos.bank.module.v1.serde.rs
@@ -76,25 +76,25 @@ impl<'de> serde::Deserialize<'de> for Module {
                 formatter.write_str("struct cosmos.bank.module.v1.Module")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Module, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Module, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut blocked_module_accounts_override__ = None;
                 let mut authority__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::BlockedModuleAccountsOverride => {
                             if blocked_module_accounts_override__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("blockedModuleAccountsOverride"));
                             }
-                            blocked_module_accounts_override__ = Some(map.next_value()?);
+                            blocked_module_accounts_override__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Authority => {
                             if authority__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("authority"));
                             }
-                            authority__ = Some(map.next_value()?);
+                            authority__ = Some(map_.next_value()?);
                         }
                     }
                 }
diff --git a/src/prost/cosmos.bank.v1beta1.serde.rs b/src/prost/cosmos.bank.v1beta1.serde.rs
index 9b130395..6fc304d4 100644
--- a/src/prost/cosmos.bank.v1beta1.serde.rs
+++ b/src/prost/cosmos.bank.v1beta1.serde.rs
@@ -75,25 +75,25 @@ impl<'de> serde::Deserialize<'de> for Balance {
                 formatter.write_str("struct cosmos.bank.v1beta1.Balance")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Balance, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Balance, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut address__ = None;
                 let mut coins__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Address => {
                             if address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("address"));
                             }
-                            address__ = Some(map.next_value()?);
+                            address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Coins => {
                             if coins__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("coins"));
                             }
-                            coins__ = Some(map.next_value()?);
+                            coins__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -183,25 +183,25 @@ impl<'de> serde::Deserialize<'de> for DenomOwner {
                 formatter.write_str("struct cosmos.bank.v1beta1.DenomOwner")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<DenomOwner, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<DenomOwner, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut address__ = None;
                 let mut balance__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Address => {
                             if address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("address"));
                             }
-                            address__ = Some(map.next_value()?);
+                            address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Balance => {
                             if balance__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("balance"));
                             }
-                            balance__ = map.next_value()?;
+                            balance__ = map_.next_value()?;
                         }
                     }
                 }
@@ -300,34 +300,34 @@ impl<'de> serde::Deserialize<'de> for DenomUnit {
                 formatter.write_str("struct cosmos.bank.v1beta1.DenomUnit")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<DenomUnit, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<DenomUnit, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut denom__ = None;
                 let mut exponent__ = None;
                 let mut aliases__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Denom => {
                             if denom__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("denom"));
                             }
-                            denom__ = Some(map.next_value()?);
+                            denom__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Exponent => {
                             if exponent__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("exponent"));
                             }
                             exponent__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Aliases => {
                             if aliases__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("aliases"));
                             }
-                            aliases__ = Some(map.next_value()?);
+                            aliases__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -447,7 +447,7 @@ impl<'de> serde::Deserialize<'de> for GenesisState {
                 formatter.write_str("struct cosmos.bank.v1beta1.GenesisState")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<GenesisState, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<GenesisState, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -456,37 +456,37 @@ impl<'de> serde::Deserialize<'de> for GenesisState {
                 let mut supply__ = None;
                 let mut denom_metadata__ = None;
                 let mut send_enabled__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Params => {
                             if params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("params"));
                             }
-                            params__ = map.next_value()?;
+                            params__ = map_.next_value()?;
                         }
                         GeneratedField::Balances => {
                             if balances__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("balances"));
                             }
-                            balances__ = Some(map.next_value()?);
+                            balances__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Supply => {
                             if supply__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("supply"));
                             }
-                            supply__ = Some(map.next_value()?);
+                            supply__ = Some(map_.next_value()?);
                         }
                         GeneratedField::DenomMetadata => {
                             if denom_metadata__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("denomMetadata"));
                             }
-                            denom_metadata__ = Some(map.next_value()?);
+                            denom_metadata__ = Some(map_.next_value()?);
                         }
                         GeneratedField::SendEnabled => {
                             if send_enabled__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sendEnabled"));
                             }
-                            send_enabled__ = Some(map.next_value()?);
+                            send_enabled__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -579,25 +579,25 @@ impl<'de> serde::Deserialize<'de> for Input {
                 formatter.write_str("struct cosmos.bank.v1beta1.Input")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Input, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Input, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut address__ = None;
                 let mut coins__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Address => {
                             if address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("address"));
                             }
-                            address__ = Some(map.next_value()?);
+                            address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Coins => {
                             if coins__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("coins"));
                             }
-                            coins__ = Some(map.next_value()?);
+                            coins__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -743,7 +743,7 @@ impl<'de> serde::Deserialize<'de> for Metadata {
                 formatter.write_str("struct cosmos.bank.v1beta1.Metadata")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Metadata, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Metadata, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -755,55 +755,55 @@ impl<'de> serde::Deserialize<'de> for Metadata {
                 let mut symbol__ = None;
                 let mut uri__ = None;
                 let mut uri_hash__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Description => {
                             if description__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("description"));
                             }
-                            description__ = Some(map.next_value()?);
+                            description__ = Some(map_.next_value()?);
                         }
                         GeneratedField::DenomUnits => {
                             if denom_units__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("denomUnits"));
                             }
-                            denom_units__ = Some(map.next_value()?);
+                            denom_units__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Base => {
                             if base__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("base"));
                             }
-                            base__ = Some(map.next_value()?);
+                            base__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Display => {
                             if display__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("display"));
                             }
-                            display__ = Some(map.next_value()?);
+                            display__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Name => {
                             if name__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("name"));
                             }
-                            name__ = Some(map.next_value()?);
+                            name__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Symbol => {
                             if symbol__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("symbol"));
                             }
-                            symbol__ = Some(map.next_value()?);
+                            symbol__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Uri => {
                             if uri__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("uri"));
                             }
-                            uri__ = Some(map.next_value()?);
+                            uri__ = Some(map_.next_value()?);
                         }
                         GeneratedField::UriHash => {
                             if uri_hash__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("uriHash"));
                             }
-                            uri_hash__ = Some(map.next_value()?);
+                            uri_hash__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -899,25 +899,25 @@ impl<'de> serde::Deserialize<'de> for MsgMultiSend {
                 formatter.write_str("struct cosmos.bank.v1beta1.MsgMultiSend")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgMultiSend, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgMultiSend, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut inputs__ = None;
                 let mut outputs__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Inputs => {
                             if inputs__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("inputs"));
                             }
-                            inputs__ = Some(map.next_value()?);
+                            inputs__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Outputs => {
                             if outputs__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("outputs"));
                             }
-                            outputs__ = Some(map.next_value()?);
+                            outputs__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -987,12 +987,12 @@ impl<'de> serde::Deserialize<'de> for MsgMultiSendResponse {
                 formatter.write_str("struct cosmos.bank.v1beta1.MsgMultiSendResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgMultiSendResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgMultiSendResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgMultiSendResponse {
                 })
@@ -1089,32 +1089,32 @@ impl<'de> serde::Deserialize<'de> for MsgSend {
                 formatter.write_str("struct cosmos.bank.v1beta1.MsgSend")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgSend, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgSend, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut from_address__ = None;
                 let mut to_address__ = None;
                 let mut amount__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::FromAddress => {
                             if from_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("fromAddress"));
                             }
-                            from_address__ = Some(map.next_value()?);
+                            from_address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ToAddress => {
                             if to_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("toAddress"));
                             }
-                            to_address__ = Some(map.next_value()?);
+                            to_address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Amount => {
                             if amount__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("amount"));
                             }
-                            amount__ = Some(map.next_value()?);
+                            amount__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1185,12 +1185,12 @@ impl<'de> serde::Deserialize<'de> for MsgSendResponse {
                 formatter.write_str("struct cosmos.bank.v1beta1.MsgSendResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgSendResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgSendResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgSendResponse {
                 })
@@ -1287,32 +1287,32 @@ impl<'de> serde::Deserialize<'de> for MsgSetSendEnabled {
                 formatter.write_str("struct cosmos.bank.v1beta1.MsgSetSendEnabled")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgSetSendEnabled, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgSetSendEnabled, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut authority__ = None;
                 let mut send_enabled__ = None;
                 let mut use_default_for__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Authority => {
                             if authority__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("authority"));
                             }
-                            authority__ = Some(map.next_value()?);
+                            authority__ = Some(map_.next_value()?);
                         }
                         GeneratedField::SendEnabled => {
                             if send_enabled__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sendEnabled"));
                             }
-                            send_enabled__ = Some(map.next_value()?);
+                            send_enabled__ = Some(map_.next_value()?);
                         }
                         GeneratedField::UseDefaultFor => {
                             if use_default_for__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("useDefaultFor"));
                             }
-                            use_default_for__ = Some(map.next_value()?);
+                            use_default_for__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1383,12 +1383,12 @@ impl<'de> serde::Deserialize<'de> for MsgSetSendEnabledResponse {
                 formatter.write_str("struct cosmos.bank.v1beta1.MsgSetSendEnabledResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgSetSendEnabledResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgSetSendEnabledResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgSetSendEnabledResponse {
                 })
@@ -1474,25 +1474,25 @@ impl<'de> serde::Deserialize<'de> for MsgUpdateParams {
                 formatter.write_str("struct cosmos.bank.v1beta1.MsgUpdateParams")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgUpdateParams, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgUpdateParams, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut authority__ = None;
                 let mut params__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Authority => {
                             if authority__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("authority"));
                             }
-                            authority__ = Some(map.next_value()?);
+                            authority__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Params => {
                             if params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("params"));
                             }
-                            params__ = map.next_value()?;
+                            params__ = map_.next_value()?;
                         }
                     }
                 }
@@ -1562,12 +1562,12 @@ impl<'de> serde::Deserialize<'de> for MsgUpdateParamsResponse {
                 formatter.write_str("struct cosmos.bank.v1beta1.MsgUpdateParamsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgUpdateParamsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgUpdateParamsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgUpdateParamsResponse {
                 })
@@ -1653,25 +1653,25 @@ impl<'de> serde::Deserialize<'de> for Output {
                 formatter.write_str("struct cosmos.bank.v1beta1.Output")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Output, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Output, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut address__ = None;
                 let mut coins__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Address => {
                             if address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("address"));
                             }
-                            address__ = Some(map.next_value()?);
+                            address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Coins => {
                             if coins__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("coins"));
                             }
-                            coins__ = Some(map.next_value()?);
+                            coins__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1763,25 +1763,25 @@ impl<'de> serde::Deserialize<'de> for Params {
                 formatter.write_str("struct cosmos.bank.v1beta1.Params")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Params, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Params, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut send_enabled__ = None;
                 let mut default_send_enabled__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::SendEnabled => {
                             if send_enabled__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sendEnabled"));
                             }
-                            send_enabled__ = Some(map.next_value()?);
+                            send_enabled__ = Some(map_.next_value()?);
                         }
                         GeneratedField::DefaultSendEnabled => {
                             if default_send_enabled__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("defaultSendEnabled"));
                             }
-                            default_send_enabled__ = Some(map.next_value()?);
+                            default_send_enabled__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1871,25 +1871,25 @@ impl<'de> serde::Deserialize<'de> for QueryAllBalancesRequest {
                 formatter.write_str("struct cosmos.bank.v1beta1.QueryAllBalancesRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryAllBalancesRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryAllBalancesRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut address__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Address => {
                             if address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("address"));
                             }
-                            address__ = Some(map.next_value()?);
+                            address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -1979,25 +1979,25 @@ impl<'de> serde::Deserialize<'de> for QueryAllBalancesResponse {
                 formatter.write_str("struct cosmos.bank.v1beta1.QueryAllBalancesResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryAllBalancesResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryAllBalancesResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut balances__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Balances => {
                             if balances__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("balances"));
                             }
-                            balances__ = Some(map.next_value()?);
+                            balances__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2087,25 +2087,25 @@ impl<'de> serde::Deserialize<'de> for QueryBalanceRequest {
                 formatter.write_str("struct cosmos.bank.v1beta1.QueryBalanceRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryBalanceRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryBalanceRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut address__ = None;
                 let mut denom__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Address => {
                             if address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("address"));
                             }
-                            address__ = Some(map.next_value()?);
+                            address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Denom => {
                             if denom__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("denom"));
                             }
-                            denom__ = Some(map.next_value()?);
+                            denom__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -2186,18 +2186,18 @@ impl<'de> serde::Deserialize<'de> for QueryBalanceResponse {
                 formatter.write_str("struct cosmos.bank.v1beta1.QueryBalanceResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryBalanceResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryBalanceResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut balance__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Balance => {
                             if balance__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("balance"));
                             }
-                            balance__ = map.next_value()?;
+                            balance__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2277,18 +2277,18 @@ impl<'de> serde::Deserialize<'de> for QueryDenomMetadataRequest {
                 formatter.write_str("struct cosmos.bank.v1beta1.QueryDenomMetadataRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryDenomMetadataRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryDenomMetadataRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut denom__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Denom => {
                             if denom__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("denom"));
                             }
-                            denom__ = Some(map.next_value()?);
+                            denom__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -2368,18 +2368,18 @@ impl<'de> serde::Deserialize<'de> for QueryDenomMetadataResponse {
                 formatter.write_str("struct cosmos.bank.v1beta1.QueryDenomMetadataResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryDenomMetadataResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryDenomMetadataResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut metadata__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Metadata => {
                             if metadata__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("metadata"));
                             }
-                            metadata__ = map.next_value()?;
+                            metadata__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2468,25 +2468,25 @@ impl<'de> serde::Deserialize<'de> for QueryDenomOwnersRequest {
                 formatter.write_str("struct cosmos.bank.v1beta1.QueryDenomOwnersRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryDenomOwnersRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryDenomOwnersRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut denom__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Denom => {
                             if denom__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("denom"));
                             }
-                            denom__ = Some(map.next_value()?);
+                            denom__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2577,25 +2577,25 @@ impl<'de> serde::Deserialize<'de> for QueryDenomOwnersResponse {
                 formatter.write_str("struct cosmos.bank.v1beta1.QueryDenomOwnersResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryDenomOwnersResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryDenomOwnersResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut denom_owners__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::DenomOwners => {
                             if denom_owners__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("denomOwners"));
                             }
-                            denom_owners__ = Some(map.next_value()?);
+                            denom_owners__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2676,18 +2676,18 @@ impl<'de> serde::Deserialize<'de> for QueryDenomsMetadataRequest {
                 formatter.write_str("struct cosmos.bank.v1beta1.QueryDenomsMetadataRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryDenomsMetadataRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryDenomsMetadataRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2776,25 +2776,25 @@ impl<'de> serde::Deserialize<'de> for QueryDenomsMetadataResponse {
                 formatter.write_str("struct cosmos.bank.v1beta1.QueryDenomsMetadataResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryDenomsMetadataResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryDenomsMetadataResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut metadatas__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Metadatas => {
                             if metadatas__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("metadatas"));
                             }
-                            metadatas__ = Some(map.next_value()?);
+                            metadatas__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2864,12 +2864,12 @@ impl<'de> serde::Deserialize<'de> for QueryParamsRequest {
                 formatter.write_str("struct cosmos.bank.v1beta1.QueryParamsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryParamsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryParamsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(QueryParamsRequest {
                 })
@@ -2946,18 +2946,18 @@ impl<'de> serde::Deserialize<'de> for QueryParamsResponse {
                 formatter.write_str("struct cosmos.bank.v1beta1.QueryParamsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryParamsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryParamsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut params__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Params => {
                             if params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("params"));
                             }
-                            params__ = map.next_value()?;
+                            params__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3046,25 +3046,25 @@ impl<'de> serde::Deserialize<'de> for QuerySendEnabledRequest {
                 formatter.write_str("struct cosmos.bank.v1beta1.QuerySendEnabledRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QuerySendEnabledRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QuerySendEnabledRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut denoms__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Denoms => {
                             if denoms__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("denoms"));
                             }
-                            denoms__ = Some(map.next_value()?);
+                            denoms__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3155,25 +3155,25 @@ impl<'de> serde::Deserialize<'de> for QuerySendEnabledResponse {
                 formatter.write_str("struct cosmos.bank.v1beta1.QuerySendEnabledResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QuerySendEnabledResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QuerySendEnabledResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut send_enabled__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::SendEnabled => {
                             if send_enabled__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sendEnabled"));
                             }
-                            send_enabled__ = Some(map.next_value()?);
+                            send_enabled__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3263,25 +3263,25 @@ impl<'de> serde::Deserialize<'de> for QuerySpendableBalanceByDenomRequest {
                 formatter.write_str("struct cosmos.bank.v1beta1.QuerySpendableBalanceByDenomRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QuerySpendableBalanceByDenomRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QuerySpendableBalanceByDenomRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut address__ = None;
                 let mut denom__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Address => {
                             if address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("address"));
                             }
-                            address__ = Some(map.next_value()?);
+                            address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Denom => {
                             if denom__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("denom"));
                             }
-                            denom__ = Some(map.next_value()?);
+                            denom__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -3362,18 +3362,18 @@ impl<'de> serde::Deserialize<'de> for QuerySpendableBalanceByDenomResponse {
                 formatter.write_str("struct cosmos.bank.v1beta1.QuerySpendableBalanceByDenomResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QuerySpendableBalanceByDenomResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QuerySpendableBalanceByDenomResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut balance__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Balance => {
                             if balance__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("balance"));
                             }
-                            balance__ = map.next_value()?;
+                            balance__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3462,25 +3462,25 @@ impl<'de> serde::Deserialize<'de> for QuerySpendableBalancesRequest {
                 formatter.write_str("struct cosmos.bank.v1beta1.QuerySpendableBalancesRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QuerySpendableBalancesRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QuerySpendableBalancesRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut address__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Address => {
                             if address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("address"));
                             }
-                            address__ = Some(map.next_value()?);
+                            address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3570,25 +3570,25 @@ impl<'de> serde::Deserialize<'de> for QuerySpendableBalancesResponse {
                 formatter.write_str("struct cosmos.bank.v1beta1.QuerySpendableBalancesResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QuerySpendableBalancesResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QuerySpendableBalancesResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut balances__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Balances => {
                             if balances__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("balances"));
                             }
-                            balances__ = Some(map.next_value()?);
+                            balances__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3669,18 +3669,18 @@ impl<'de> serde::Deserialize<'de> for QuerySupplyOfRequest {
                 formatter.write_str("struct cosmos.bank.v1beta1.QuerySupplyOfRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QuerySupplyOfRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QuerySupplyOfRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut denom__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Denom => {
                             if denom__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("denom"));
                             }
-                            denom__ = Some(map.next_value()?);
+                            denom__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -3760,18 +3760,18 @@ impl<'de> serde::Deserialize<'de> for QuerySupplyOfResponse {
                 formatter.write_str("struct cosmos.bank.v1beta1.QuerySupplyOfResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QuerySupplyOfResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QuerySupplyOfResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut amount__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Amount => {
                             if amount__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("amount"));
                             }
-                            amount__ = map.next_value()?;
+                            amount__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3851,18 +3851,18 @@ impl<'de> serde::Deserialize<'de> for QueryTotalSupplyRequest {
                 formatter.write_str("struct cosmos.bank.v1beta1.QueryTotalSupplyRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryTotalSupplyRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryTotalSupplyRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3951,25 +3951,25 @@ impl<'de> serde::Deserialize<'de> for QueryTotalSupplyResponse {
                 formatter.write_str("struct cosmos.bank.v1beta1.QueryTotalSupplyResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryTotalSupplyResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryTotalSupplyResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut supply__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Supply => {
                             if supply__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("supply"));
                             }
-                            supply__ = Some(map.next_value()?);
+                            supply__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -4061,25 +4061,25 @@ impl<'de> serde::Deserialize<'de> for SendAuthorization {
                 formatter.write_str("struct cosmos.bank.v1beta1.SendAuthorization")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<SendAuthorization, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<SendAuthorization, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut spend_limit__ = None;
                 let mut allow_list__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::SpendLimit => {
                             if spend_limit__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("spendLimit"));
                             }
-                            spend_limit__ = Some(map.next_value()?);
+                            spend_limit__ = Some(map_.next_value()?);
                         }
                         GeneratedField::AllowList => {
                             if allow_list__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("allowList"));
                             }
-                            allow_list__ = Some(map.next_value()?);
+                            allow_list__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -4169,25 +4169,25 @@ impl<'de> serde::Deserialize<'de> for SendEnabled {
                 formatter.write_str("struct cosmos.bank.v1beta1.SendEnabled")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<SendEnabled, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<SendEnabled, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut denom__ = None;
                 let mut enabled__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Denom => {
                             if denom__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("denom"));
                             }
-                            denom__ = Some(map.next_value()?);
+                            denom__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Enabled => {
                             if enabled__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("enabled"));
                             }
-                            enabled__ = Some(map.next_value()?);
+                            enabled__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -4268,18 +4268,18 @@ impl<'de> serde::Deserialize<'de> for Supply {
                 formatter.write_str("struct cosmos.bank.v1beta1.Supply")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Supply, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Supply, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut total__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Total => {
                             if total__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("total"));
                             }
-                            total__ = Some(map.next_value()?);
+                            total__ = Some(map_.next_value()?);
                         }
                     }
                 }
diff --git a/src/prost/cosmos.base.kv.v1beta1.serde.rs b/src/prost/cosmos.base.kv.v1beta1.serde.rs
index c0e3f4dd..3e2ed8b5 100644
--- a/src/prost/cosmos.base.kv.v1beta1.serde.rs
+++ b/src/prost/cosmos.base.kv.v1beta1.serde.rs
@@ -14,9 +14,11 @@ impl serde::Serialize for Pair {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.base.kv.v1beta1.Pair", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("key", pbjson::private::base64::encode(&self.key).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
         }
         struct_ser.end()
@@ -75,20 +77,20 @@ impl<'de> serde::Deserialize<'de> for Pair {
                 formatter.write_str("struct cosmos.base.kv.v1beta1.Pair")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Pair, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Pair, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut key__ = None;
                 let mut value__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Key => {
                             if key__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("key"));
                             }
                             key__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Value => {
@@ -96,7 +98,7 @@ impl<'de> serde::Deserialize<'de> for Pair {
                                 return Err(serde::de::Error::duplicate_field("value"));
                             }
                             value__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -178,18 +180,18 @@ impl<'de> serde::Deserialize<'de> for Pairs {
                 formatter.write_str("struct cosmos.base.kv.v1beta1.Pairs")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Pairs, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Pairs, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut pairs__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Pairs => {
                             if pairs__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pairs"));
                             }
-                            pairs__ = Some(map.next_value()?);
+                            pairs__ = Some(map_.next_value()?);
                         }
                     }
                 }
diff --git a/src/prost/cosmos.base.node.v1beta1.serde.rs b/src/prost/cosmos.base.node.v1beta1.serde.rs
index dd84a00c..24a688cd 100644
--- a/src/prost/cosmos.base.node.v1beta1.serde.rs
+++ b/src/prost/cosmos.base.node.v1beta1.serde.rs
@@ -55,12 +55,12 @@ impl<'de> serde::Deserialize<'de> for ConfigRequest {
                 formatter.write_str("struct cosmos.base.node.v1beta1.ConfigRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ConfigRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ConfigRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(ConfigRequest {
                 })
@@ -138,18 +138,18 @@ impl<'de> serde::Deserialize<'de> for ConfigResponse {
                 formatter.write_str("struct cosmos.base.node.v1beta1.ConfigResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ConfigResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ConfigResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut minimum_gas_price__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::MinimumGasPrice => {
                             if minimum_gas_price__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("minimumGasPrice"));
                             }
-                            minimum_gas_price__ = Some(map.next_value()?);
+                            minimum_gas_price__ = Some(map_.next_value()?);
                         }
                     }
                 }
diff --git a/src/prost/cosmos.base.query.v1beta1.serde.rs b/src/prost/cosmos.base.query.v1beta1.serde.rs
index f76fdfdb..b58155f7 100644
--- a/src/prost/cosmos.base.query.v1beta1.serde.rs
+++ b/src/prost/cosmos.base.query.v1beta1.serde.rs
@@ -23,12 +23,15 @@ impl serde::Serialize for PageRequest {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.base.query.v1beta1.PageRequest", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("key", pbjson::private::base64::encode(&self.key).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("offset", ::alloc::string::ToString::to_string(&self.offset).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("limit", ::alloc::string::ToString::to_string(&self.limit).as_str())?;
         }
         if true {
@@ -103,7 +106,7 @@ impl<'de> serde::Deserialize<'de> for PageRequest {
                 formatter.write_str("struct cosmos.base.query.v1beta1.PageRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<PageRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<PageRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -112,14 +115,14 @@ impl<'de> serde::Deserialize<'de> for PageRequest {
                 let mut limit__ = None;
                 let mut count_total__ = None;
                 let mut reverse__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Key => {
                             if key__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("key"));
                             }
                             key__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Offset => {
@@ -127,7 +130,7 @@ impl<'de> serde::Deserialize<'de> for PageRequest {
                                 return Err(serde::de::Error::duplicate_field("offset"));
                             }
                             offset__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Limit => {
@@ -135,20 +138,20 @@ impl<'de> serde::Deserialize<'de> for PageRequest {
                                 return Err(serde::de::Error::duplicate_field("limit"));
                             }
                             limit__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::CountTotal => {
                             if count_total__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("countTotal"));
                             }
-                            count_total__ = Some(map.next_value()?);
+                            count_total__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Reverse => {
                             if reverse__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("reverse"));
                             }
-                            reverse__ = Some(map.next_value()?);
+                            reverse__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -180,9 +183,11 @@ impl serde::Serialize for PageResponse {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.base.query.v1beta1.PageResponse", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("nextKey", pbjson::private::base64::encode(&self.next_key).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("total", ::alloc::string::ToString::to_string(&self.total).as_str())?;
         }
         struct_ser.end()
@@ -242,20 +247,20 @@ impl<'de> serde::Deserialize<'de> for PageResponse {
                 formatter.write_str("struct cosmos.base.query.v1beta1.PageResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<PageResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<PageResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut next_key__ = None;
                 let mut total__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::NextKey => {
                             if next_key__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("nextKey"));
                             }
                             next_key__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Total => {
@@ -263,7 +268,7 @@ impl<'de> serde::Deserialize<'de> for PageResponse {
                                 return Err(serde::de::Error::duplicate_field("total"));
                             }
                             total__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
diff --git a/src/prost/cosmos.base.reflection.v1beta1.serde.rs b/src/prost/cosmos.base.reflection.v1beta1.serde.rs
index 8e5e0a93..731bbdf0 100644
--- a/src/prost/cosmos.base.reflection.v1beta1.serde.rs
+++ b/src/prost/cosmos.base.reflection.v1beta1.serde.rs
@@ -55,12 +55,12 @@ impl<'de> serde::Deserialize<'de> for ListAllInterfacesRequest {
                 formatter.write_str("struct cosmos.base.reflection.v1beta1.ListAllInterfacesRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ListAllInterfacesRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ListAllInterfacesRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(ListAllInterfacesRequest {
                 })
@@ -138,18 +138,18 @@ impl<'de> serde::Deserialize<'de> for ListAllInterfacesResponse {
                 formatter.write_str("struct cosmos.base.reflection.v1beta1.ListAllInterfacesResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ListAllInterfacesResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ListAllInterfacesResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut interface_names__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::InterfaceNames => {
                             if interface_names__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("interfaceNames"));
                             }
-                            interface_names__ = Some(map.next_value()?);
+                            interface_names__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -230,18 +230,18 @@ impl<'de> serde::Deserialize<'de> for ListImplementationsRequest {
                 formatter.write_str("struct cosmos.base.reflection.v1beta1.ListImplementationsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ListImplementationsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ListImplementationsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut interface_name__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::InterfaceName => {
                             if interface_name__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("interfaceName"));
                             }
-                            interface_name__ = Some(map.next_value()?);
+                            interface_name__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -322,18 +322,18 @@ impl<'de> serde::Deserialize<'de> for ListImplementationsResponse {
                 formatter.write_str("struct cosmos.base.reflection.v1beta1.ListImplementationsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ListImplementationsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ListImplementationsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut implementation_message_names__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ImplementationMessageNames => {
                             if implementation_message_names__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("implementationMessageNames"));
                             }
-                            implementation_message_names__ = Some(map.next_value()?);
+                            implementation_message_names__ = Some(map_.next_value()?);
                         }
                     }
                 }
diff --git a/src/prost/cosmos.base.reflection.v2alpha1.serde.rs b/src/prost/cosmos.base.reflection.v2alpha1.serde.rs
index ae40c496..9103b97c 100644
--- a/src/prost/cosmos.base.reflection.v2alpha1.serde.rs
+++ b/src/prost/cosmos.base.reflection.v2alpha1.serde.rs
@@ -112,7 +112,7 @@ impl<'de> serde::Deserialize<'de> for AppDescriptor {
                 formatter.write_str("struct cosmos.base.reflection.v2alpha1.AppDescriptor")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<AppDescriptor, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<AppDescriptor, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -122,43 +122,43 @@ impl<'de> serde::Deserialize<'de> for AppDescriptor {
                 let mut configuration__ = None;
                 let mut query_services__ = None;
                 let mut tx__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Authn => {
                             if authn__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("authn"));
                             }
-                            authn__ = map.next_value()?;
+                            authn__ = map_.next_value()?;
                         }
                         GeneratedField::Chain => {
                             if chain__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("chain"));
                             }
-                            chain__ = map.next_value()?;
+                            chain__ = map_.next_value()?;
                         }
                         GeneratedField::Codec => {
                             if codec__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("codec"));
                             }
-                            codec__ = map.next_value()?;
+                            codec__ = map_.next_value()?;
                         }
                         GeneratedField::Configuration => {
                             if configuration__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("configuration"));
                             }
-                            configuration__ = map.next_value()?;
+                            configuration__ = map_.next_value()?;
                         }
                         GeneratedField::QueryServices => {
                             if query_services__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("queryServices"));
                             }
-                            query_services__ = map.next_value()?;
+                            query_services__ = map_.next_value()?;
                         }
                         GeneratedField::Tx => {
                             if tx__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("tx"));
                             }
-                            tx__ = map.next_value()?;
+                            tx__ = map_.next_value()?;
                         }
                     }
                 }
@@ -244,18 +244,18 @@ impl<'de> serde::Deserialize<'de> for AuthnDescriptor {
                 formatter.write_str("struct cosmos.base.reflection.v2alpha1.AuthnDescriptor")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<AuthnDescriptor, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<AuthnDescriptor, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut sign_modes__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::SignModes => {
                             if sign_modes__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signModes"));
                             }
-                            sign_modes__ = Some(map.next_value()?);
+                            sign_modes__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -335,18 +335,18 @@ impl<'de> serde::Deserialize<'de> for ChainDescriptor {
                 formatter.write_str("struct cosmos.base.reflection.v2alpha1.ChainDescriptor")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ChainDescriptor, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ChainDescriptor, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut id__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Id => {
                             if id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("id"));
                             }
-                            id__ = Some(map.next_value()?);
+                            id__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -426,18 +426,18 @@ impl<'de> serde::Deserialize<'de> for CodecDescriptor {
                 formatter.write_str("struct cosmos.base.reflection.v2alpha1.CodecDescriptor")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<CodecDescriptor, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<CodecDescriptor, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut interfaces__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Interfaces => {
                             if interfaces__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("interfaces"));
                             }
-                            interfaces__ = Some(map.next_value()?);
+                            interfaces__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -518,18 +518,18 @@ impl<'de> serde::Deserialize<'de> for ConfigurationDescriptor {
                 formatter.write_str("struct cosmos.base.reflection.v2alpha1.ConfigurationDescriptor")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ConfigurationDescriptor, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ConfigurationDescriptor, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut bech32_account_address_prefix__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Bech32AccountAddressPrefix => {
                             if bech32_account_address_prefix__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("bech32AccountAddressPrefix"));
                             }
-                            bech32_account_address_prefix__ = Some(map.next_value()?);
+                            bech32_account_address_prefix__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -598,12 +598,12 @@ impl<'de> serde::Deserialize<'de> for GetAuthnDescriptorRequest {
                 formatter.write_str("struct cosmos.base.reflection.v2alpha1.GetAuthnDescriptorRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<GetAuthnDescriptorRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<GetAuthnDescriptorRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(GetAuthnDescriptorRequest {
                 })
@@ -680,18 +680,18 @@ impl<'de> serde::Deserialize<'de> for GetAuthnDescriptorResponse {
                 formatter.write_str("struct cosmos.base.reflection.v2alpha1.GetAuthnDescriptorResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<GetAuthnDescriptorResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<GetAuthnDescriptorResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut authn__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Authn => {
                             if authn__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("authn"));
                             }
-                            authn__ = map.next_value()?;
+                            authn__ = map_.next_value()?;
                         }
                     }
                 }
@@ -760,12 +760,12 @@ impl<'de> serde::Deserialize<'de> for GetChainDescriptorRequest {
                 formatter.write_str("struct cosmos.base.reflection.v2alpha1.GetChainDescriptorRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<GetChainDescriptorRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<GetChainDescriptorRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(GetChainDescriptorRequest {
                 })
@@ -842,18 +842,18 @@ impl<'de> serde::Deserialize<'de> for GetChainDescriptorResponse {
                 formatter.write_str("struct cosmos.base.reflection.v2alpha1.GetChainDescriptorResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<GetChainDescriptorResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<GetChainDescriptorResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut chain__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Chain => {
                             if chain__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("chain"));
                             }
-                            chain__ = map.next_value()?;
+                            chain__ = map_.next_value()?;
                         }
                     }
                 }
@@ -922,12 +922,12 @@ impl<'de> serde::Deserialize<'de> for GetCodecDescriptorRequest {
                 formatter.write_str("struct cosmos.base.reflection.v2alpha1.GetCodecDescriptorRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<GetCodecDescriptorRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<GetCodecDescriptorRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(GetCodecDescriptorRequest {
                 })
@@ -1004,18 +1004,18 @@ impl<'de> serde::Deserialize<'de> for GetCodecDescriptorResponse {
                 formatter.write_str("struct cosmos.base.reflection.v2alpha1.GetCodecDescriptorResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<GetCodecDescriptorResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<GetCodecDescriptorResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut codec__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Codec => {
                             if codec__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("codec"));
                             }
-                            codec__ = map.next_value()?;
+                            codec__ = map_.next_value()?;
                         }
                     }
                 }
@@ -1084,12 +1084,12 @@ impl<'de> serde::Deserialize<'de> for GetConfigurationDescriptorRequest {
                 formatter.write_str("struct cosmos.base.reflection.v2alpha1.GetConfigurationDescriptorRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<GetConfigurationDescriptorRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<GetConfigurationDescriptorRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(GetConfigurationDescriptorRequest {
                 })
@@ -1166,18 +1166,18 @@ impl<'de> serde::Deserialize<'de> for GetConfigurationDescriptorResponse {
                 formatter.write_str("struct cosmos.base.reflection.v2alpha1.GetConfigurationDescriptorResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<GetConfigurationDescriptorResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<GetConfigurationDescriptorResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut config__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Config => {
                             if config__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("config"));
                             }
-                            config__ = map.next_value()?;
+                            config__ = map_.next_value()?;
                         }
                     }
                 }
@@ -1246,12 +1246,12 @@ impl<'de> serde::Deserialize<'de> for GetQueryServicesDescriptorRequest {
                 formatter.write_str("struct cosmos.base.reflection.v2alpha1.GetQueryServicesDescriptorRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<GetQueryServicesDescriptorRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<GetQueryServicesDescriptorRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(GetQueryServicesDescriptorRequest {
                 })
@@ -1328,18 +1328,18 @@ impl<'de> serde::Deserialize<'de> for GetQueryServicesDescriptorResponse {
                 formatter.write_str("struct cosmos.base.reflection.v2alpha1.GetQueryServicesDescriptorResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<GetQueryServicesDescriptorResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<GetQueryServicesDescriptorResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut queries__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Queries => {
                             if queries__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("queries"));
                             }
-                            queries__ = map.next_value()?;
+                            queries__ = map_.next_value()?;
                         }
                     }
                 }
@@ -1408,12 +1408,12 @@ impl<'de> serde::Deserialize<'de> for GetTxDescriptorRequest {
                 formatter.write_str("struct cosmos.base.reflection.v2alpha1.GetTxDescriptorRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<GetTxDescriptorRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<GetTxDescriptorRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(GetTxDescriptorRequest {
                 })
@@ -1490,18 +1490,18 @@ impl<'de> serde::Deserialize<'de> for GetTxDescriptorResponse {
                 formatter.write_str("struct cosmos.base.reflection.v2alpha1.GetTxDescriptorResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<GetTxDescriptorResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<GetTxDescriptorResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut tx__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Tx => {
                             if tx__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("tx"));
                             }
-                            tx__ = map.next_value()?;
+                            tx__ = map_.next_value()?;
                         }
                     }
                 }
@@ -1591,25 +1591,25 @@ impl<'de> serde::Deserialize<'de> for InterfaceAcceptingMessageDescriptor {
                 formatter.write_str("struct cosmos.base.reflection.v2alpha1.InterfaceAcceptingMessageDescriptor")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<InterfaceAcceptingMessageDescriptor, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<InterfaceAcceptingMessageDescriptor, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut fullname__ = None;
                 let mut field_descriptor_names__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Fullname => {
                             if fullname__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("fullname"));
                             }
-                            fullname__ = Some(map.next_value()?);
+                            fullname__ = Some(map_.next_value()?);
                         }
                         GeneratedField::FieldDescriptorNames => {
                             if field_descriptor_names__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("fieldDescriptorNames"));
                             }
-                            field_descriptor_names__ = Some(map.next_value()?);
+                            field_descriptor_names__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1710,32 +1710,32 @@ impl<'de> serde::Deserialize<'de> for InterfaceDescriptor {
                 formatter.write_str("struct cosmos.base.reflection.v2alpha1.InterfaceDescriptor")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<InterfaceDescriptor, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<InterfaceDescriptor, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut fullname__ = None;
                 let mut interface_accepting_messages__ = None;
                 let mut interface_implementers__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Fullname => {
                             if fullname__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("fullname"));
                             }
-                            fullname__ = Some(map.next_value()?);
+                            fullname__ = Some(map_.next_value()?);
                         }
                         GeneratedField::InterfaceAcceptingMessages => {
                             if interface_accepting_messages__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("interfaceAcceptingMessages"));
                             }
-                            interface_accepting_messages__ = Some(map.next_value()?);
+                            interface_accepting_messages__ = Some(map_.next_value()?);
                         }
                         GeneratedField::InterfaceImplementers => {
                             if interface_implementers__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("interfaceImplementers"));
                             }
-                            interface_implementers__ = Some(map.next_value()?);
+                            interface_implementers__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1827,25 +1827,25 @@ impl<'de> serde::Deserialize<'de> for InterfaceImplementerDescriptor {
                 formatter.write_str("struct cosmos.base.reflection.v2alpha1.InterfaceImplementerDescriptor")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<InterfaceImplementerDescriptor, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<InterfaceImplementerDescriptor, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut fullname__ = None;
                 let mut type_url__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Fullname => {
                             if fullname__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("fullname"));
                             }
-                            fullname__ = Some(map.next_value()?);
+                            fullname__ = Some(map_.next_value()?);
                         }
                         GeneratedField::TypeUrl => {
                             if type_url__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("typeUrl"));
                             }
-                            type_url__ = Some(map.next_value()?);
+                            type_url__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1927,18 +1927,18 @@ impl<'de> serde::Deserialize<'de> for MsgDescriptor {
                 formatter.write_str("struct cosmos.base.reflection.v2alpha1.MsgDescriptor")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgDescriptor, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgDescriptor, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut msg_type_url__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::MsgTypeUrl => {
                             if msg_type_url__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("msgTypeUrl"));
                             }
-                            msg_type_url__ = Some(map.next_value()?);
+                            msg_type_url__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -2028,25 +2028,25 @@ impl<'de> serde::Deserialize<'de> for QueryMethodDescriptor {
                 formatter.write_str("struct cosmos.base.reflection.v2alpha1.QueryMethodDescriptor")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryMethodDescriptor, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryMethodDescriptor, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut name__ = None;
                 let mut full_query_path__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Name => {
                             if name__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("name"));
                             }
-                            name__ = Some(map.next_value()?);
+                            name__ = Some(map_.next_value()?);
                         }
                         GeneratedField::FullQueryPath => {
                             if full_query_path__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("fullQueryPath"));
                             }
-                            full_query_path__ = Some(map.next_value()?);
+                            full_query_path__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -2146,32 +2146,32 @@ impl<'de> serde::Deserialize<'de> for QueryServiceDescriptor {
                 formatter.write_str("struct cosmos.base.reflection.v2alpha1.QueryServiceDescriptor")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryServiceDescriptor, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryServiceDescriptor, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut fullname__ = None;
                 let mut is_module__ = None;
                 let mut methods__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Fullname => {
                             if fullname__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("fullname"));
                             }
-                            fullname__ = Some(map.next_value()?);
+                            fullname__ = Some(map_.next_value()?);
                         }
                         GeneratedField::IsModule => {
                             if is_module__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("isModule"));
                             }
-                            is_module__ = Some(map.next_value()?);
+                            is_module__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Methods => {
                             if methods__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("methods"));
                             }
-                            methods__ = Some(map.next_value()?);
+                            methods__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -2254,18 +2254,18 @@ impl<'de> serde::Deserialize<'de> for QueryServicesDescriptor {
                 formatter.write_str("struct cosmos.base.reflection.v2alpha1.QueryServicesDescriptor")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryServicesDescriptor, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryServicesDescriptor, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut query_services__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::QueryServices => {
                             if query_services__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("queryServices"));
                             }
-                            query_services__ = Some(map.next_value()?);
+                            query_services__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -2364,34 +2364,34 @@ impl<'de> serde::Deserialize<'de> for SigningModeDescriptor {
                 formatter.write_str("struct cosmos.base.reflection.v2alpha1.SigningModeDescriptor")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<SigningModeDescriptor, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<SigningModeDescriptor, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut name__ = None;
                 let mut number__ = None;
                 let mut authn_info_provider_method_fullname__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Name => {
                             if name__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("name"));
                             }
-                            name__ = Some(map.next_value()?);
+                            name__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Number => {
                             if number__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("number"));
                             }
                             number__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::AuthnInfoProviderMethodFullname => {
                             if authn_info_provider_method_fullname__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("authnInfoProviderMethodFullname"));
                             }
-                            authn_info_provider_method_fullname__ = Some(map.next_value()?);
+                            authn_info_provider_method_fullname__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -2482,25 +2482,25 @@ impl<'de> serde::Deserialize<'de> for TxDescriptor {
                 formatter.write_str("struct cosmos.base.reflection.v2alpha1.TxDescriptor")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<TxDescriptor, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<TxDescriptor, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut fullname__ = None;
                 let mut msgs__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Fullname => {
                             if fullname__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("fullname"));
                             }
-                            fullname__ = Some(map.next_value()?);
+                            fullname__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Msgs => {
                             if msgs__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("msgs"));
                             }
-                            msgs__ = Some(map.next_value()?);
+                            msgs__ = Some(map_.next_value()?);
                         }
                     }
                 }
diff --git a/src/prost/cosmos.base.snapshots.v1beta1.serde.rs b/src/prost/cosmos.base.snapshots.v1beta1.serde.rs
index a92ff6a9..f28fcfed 100644
--- a/src/prost/cosmos.base.snapshots.v1beta1.serde.rs
+++ b/src/prost/cosmos.base.snapshots.v1beta1.serde.rs
@@ -67,19 +67,19 @@ impl<'de> serde::Deserialize<'de> for Metadata {
                 formatter.write_str("struct cosmos.base.snapshots.v1beta1.Metadata")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Metadata, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Metadata, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut chunk_hashes__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ChunkHashes => {
                             if chunk_hashes__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("chunkHashes"));
                             }
                             chunk_hashes__ = 
-                                Some(map.next_value::<::alloc::vec::Vec<::pbjson::private::BytesDeserialize<_>>>()?
+                                Some(map_.next_value::<::alloc::vec::Vec<::pbjson::private::BytesDeserialize<_>>>()?
                                     .into_iter().map(|x| x.0).collect())
                             ;
                         }
@@ -118,6 +118,7 @@ impl serde::Serialize for Snapshot {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.base.snapshots.v1beta1.Snapshot", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("height", ::alloc::string::ToString::to_string(&self.height).as_str())?;
         }
         if true {
@@ -127,6 +128,7 @@ impl serde::Serialize for Snapshot {
             struct_ser.serialize_field("chunks", &self.chunks)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("hash", pbjson::private::base64::encode(&self.hash).as_str())?;
         }
         if let Some(v) = self.metadata.as_ref() {
@@ -197,7 +199,7 @@ impl<'de> serde::Deserialize<'de> for Snapshot {
                 formatter.write_str("struct cosmos.base.snapshots.v1beta1.Snapshot")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Snapshot, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Snapshot, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -206,14 +208,14 @@ impl<'de> serde::Deserialize<'de> for Snapshot {
                 let mut chunks__ = None;
                 let mut hash__ = None;
                 let mut metadata__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Height => {
                             if height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("height"));
                             }
                             height__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Format => {
@@ -221,7 +223,7 @@ impl<'de> serde::Deserialize<'de> for Snapshot {
                                 return Err(serde::de::Error::duplicate_field("format"));
                             }
                             format__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Chunks => {
@@ -229,7 +231,7 @@ impl<'de> serde::Deserialize<'de> for Snapshot {
                                 return Err(serde::de::Error::duplicate_field("chunks"));
                             }
                             chunks__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Hash => {
@@ -237,14 +239,14 @@ impl<'de> serde::Deserialize<'de> for Snapshot {
                                 return Err(serde::de::Error::duplicate_field("hash"));
                             }
                             hash__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Metadata => {
                             if metadata__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("metadata"));
                             }
-                            metadata__ = map.next_value()?;
+                            metadata__ = map_.next_value()?;
                         }
                     }
                 }
@@ -337,26 +339,26 @@ impl<'de> serde::Deserialize<'de> for SnapshotExtensionMeta {
                 formatter.write_str("struct cosmos.base.snapshots.v1beta1.SnapshotExtensionMeta")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<SnapshotExtensionMeta, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<SnapshotExtensionMeta, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut name__ = None;
                 let mut format__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Name => {
                             if name__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("name"));
                             }
-                            name__ = Some(map.next_value()?);
+                            name__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Format => {
                             if format__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("format"));
                             }
                             format__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -383,6 +385,7 @@ impl serde::Serialize for SnapshotExtensionPayload {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.base.snapshots.v1beta1.SnapshotExtensionPayload", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("payload", pbjson::private::base64::encode(&self.payload).as_str())?;
         }
         struct_ser.end()
@@ -438,19 +441,19 @@ impl<'de> serde::Deserialize<'de> for SnapshotExtensionPayload {
                 formatter.write_str("struct cosmos.base.snapshots.v1beta1.SnapshotExtensionPayload")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<SnapshotExtensionPayload, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<SnapshotExtensionPayload, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut payload__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Payload => {
                             if payload__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("payload"));
                             }
                             payload__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -485,12 +488,15 @@ impl serde::Serialize for SnapshotIavlItem {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.base.snapshots.v1beta1.SnapshotIAVLItem", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("key", pbjson::private::base64::encode(&self.key).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("version", ::alloc::string::ToString::to_string(&self.version).as_str())?;
         }
         if true {
@@ -558,7 +564,7 @@ impl<'de> serde::Deserialize<'de> for SnapshotIavlItem {
                 formatter.write_str("struct cosmos.base.snapshots.v1beta1.SnapshotIAVLItem")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<SnapshotIavlItem, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<SnapshotIavlItem, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -566,14 +572,14 @@ impl<'de> serde::Deserialize<'de> for SnapshotIavlItem {
                 let mut value__ = None;
                 let mut version__ = None;
                 let mut height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Key => {
                             if key__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("key"));
                             }
                             key__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Value => {
@@ -581,7 +587,7 @@ impl<'de> serde::Deserialize<'de> for SnapshotIavlItem {
                                 return Err(serde::de::Error::duplicate_field("value"));
                             }
                             value__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Version => {
@@ -589,7 +595,7 @@ impl<'de> serde::Deserialize<'de> for SnapshotIavlItem {
                                 return Err(serde::de::Error::duplicate_field("version"));
                             }
                             version__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Height => {
@@ -597,7 +603,7 @@ impl<'de> serde::Deserialize<'de> for SnapshotIavlItem {
                                 return Err(serde::de::Error::duplicate_field("height"));
                             }
                             height__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -716,53 +722,53 @@ impl<'de> serde::Deserialize<'de> for SnapshotItem {
                 formatter.write_str("struct cosmos.base.snapshots.v1beta1.SnapshotItem")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<SnapshotItem, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<SnapshotItem, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut item__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Store => {
                             if item__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("store"));
                             }
-                            item__ = map.next_value::<::core::option::Option<_>>()?.map(snapshot_item::Item::Store)
+                            item__ = map_.next_value::<::core::option::Option<_>>()?.map(snapshot_item::Item::Store)
 ;
                         }
                         GeneratedField::Iavl => {
                             if item__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("iavl"));
                             }
-                            item__ = map.next_value::<::core::option::Option<_>>()?.map(snapshot_item::Item::Iavl)
+                            item__ = map_.next_value::<::core::option::Option<_>>()?.map(snapshot_item::Item::Iavl)
 ;
                         }
                         GeneratedField::Extension => {
                             if item__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("extension"));
                             }
-                            item__ = map.next_value::<::core::option::Option<_>>()?.map(snapshot_item::Item::Extension)
+                            item__ = map_.next_value::<::core::option::Option<_>>()?.map(snapshot_item::Item::Extension)
 ;
                         }
                         GeneratedField::ExtensionPayload => {
                             if item__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("extensionPayload"));
                             }
-                            item__ = map.next_value::<::core::option::Option<_>>()?.map(snapshot_item::Item::ExtensionPayload)
+                            item__ = map_.next_value::<::core::option::Option<_>>()?.map(snapshot_item::Item::ExtensionPayload)
 ;
                         }
                         GeneratedField::Kv => {
                             if item__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("kv"));
                             }
-                            item__ = map.next_value::<::core::option::Option<_>>()?.map(snapshot_item::Item::Kv)
+                            item__ = map_.next_value::<::core::option::Option<_>>()?.map(snapshot_item::Item::Kv)
 ;
                         }
                         GeneratedField::Schema => {
                             if item__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("schema"));
                             }
-                            item__ = map.next_value::<::core::option::Option<_>>()?.map(snapshot_item::Item::Schema)
+                            item__ = map_.next_value::<::core::option::Option<_>>()?.map(snapshot_item::Item::Schema)
 ;
                         }
                     }
@@ -791,9 +797,11 @@ impl serde::Serialize for SnapshotKvItem {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.base.snapshots.v1beta1.SnapshotKVItem", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("key", pbjson::private::base64::encode(&self.key).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
         }
         struct_ser.end()
@@ -852,20 +860,20 @@ impl<'de> serde::Deserialize<'de> for SnapshotKvItem {
                 formatter.write_str("struct cosmos.base.snapshots.v1beta1.SnapshotKVItem")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<SnapshotKvItem, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<SnapshotKvItem, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut key__ = None;
                 let mut value__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Key => {
                             if key__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("key"));
                             }
                             key__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Value => {
@@ -873,7 +881,7 @@ impl<'de> serde::Deserialize<'de> for SnapshotKvItem {
                                 return Err(serde::de::Error::duplicate_field("value"));
                             }
                             value__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -955,19 +963,19 @@ impl<'de> serde::Deserialize<'de> for SnapshotSchema {
                 formatter.write_str("struct cosmos.base.snapshots.v1beta1.SnapshotSchema")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<SnapshotSchema, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<SnapshotSchema, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut keys__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Keys => {
                             if keys__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("keys"));
                             }
                             keys__ = 
-                                Some(map.next_value::<::alloc::vec::Vec<::pbjson::private::BytesDeserialize<_>>>()?
+                                Some(map_.next_value::<::alloc::vec::Vec<::pbjson::private::BytesDeserialize<_>>>()?
                                     .into_iter().map(|x| x.0).collect())
                             ;
                         }
@@ -1049,18 +1057,18 @@ impl<'de> serde::Deserialize<'de> for SnapshotStoreItem {
                 formatter.write_str("struct cosmos.base.snapshots.v1beta1.SnapshotStoreItem")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<SnapshotStoreItem, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<SnapshotStoreItem, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut name__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Name => {
                             if name__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("name"));
                             }
-                            name__ = Some(map.next_value()?);
+                            name__ = Some(map_.next_value()?);
                         }
                     }
                 }
diff --git a/src/prost/cosmos.base.store.v1beta1.serde.rs b/src/prost/cosmos.base.store.v1beta1.serde.rs
index 2bc33f54..2916d33c 100644
--- a/src/prost/cosmos.base.store.v1beta1.serde.rs
+++ b/src/prost/cosmos.base.store.v1beta1.serde.rs
@@ -117,7 +117,7 @@ impl<'de> serde::Deserialize<'de> for BlockMetadata {
                 formatter.write_str("struct cosmos.base.store.v1beta1.BlockMetadata")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<BlockMetadata, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<BlockMetadata, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -127,43 +127,43 @@ impl<'de> serde::Deserialize<'de> for BlockMetadata {
                 let mut request_end_block__ = None;
                 let mut response_end_block__ = None;
                 let mut response_commit__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::RequestBeginBlock => {
                             if request_begin_block__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("requestBeginBlock"));
                             }
-                            request_begin_block__ = map.next_value()?;
+                            request_begin_block__ = map_.next_value()?;
                         }
                         GeneratedField::ResponseBeginBlock => {
                             if response_begin_block__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("responseBeginBlock"));
                             }
-                            response_begin_block__ = map.next_value()?;
+                            response_begin_block__ = map_.next_value()?;
                         }
                         GeneratedField::DeliverTxs => {
                             if deliver_txs__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("deliverTxs"));
                             }
-                            deliver_txs__ = Some(map.next_value()?);
+                            deliver_txs__ = Some(map_.next_value()?);
                         }
                         GeneratedField::RequestEndBlock => {
                             if request_end_block__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("requestEndBlock"));
                             }
-                            request_end_block__ = map.next_value()?;
+                            request_end_block__ = map_.next_value()?;
                         }
                         GeneratedField::ResponseEndBlock => {
                             if response_end_block__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("responseEndBlock"));
                             }
-                            response_end_block__ = map.next_value()?;
+                            response_end_block__ = map_.next_value()?;
                         }
                         GeneratedField::ResponseCommit => {
                             if response_commit__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("responseCommit"));
                             }
-                            response_commit__ = map.next_value()?;
+                            response_commit__ = map_.next_value()?;
                         }
                     }
                 }
@@ -257,25 +257,25 @@ impl<'de> serde::Deserialize<'de> for block_metadata::DeliverTx {
                 formatter.write_str("struct cosmos.base.store.v1beta1.BlockMetadata.DeliverTx")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<block_metadata::DeliverTx, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<block_metadata::DeliverTx, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut request__ = None;
                 let mut response__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Request => {
                             if request__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("request"));
                             }
-                            request__ = map.next_value()?;
+                            request__ = map_.next_value()?;
                         }
                         GeneratedField::Response => {
                             if response__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("response"));
                             }
-                            response__ = map.next_value()?;
+                            response__ = map_.next_value()?;
                         }
                     }
                 }
@@ -304,9 +304,11 @@ impl serde::Serialize for CommitId {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.base.store.v1beta1.CommitID", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("version", ::alloc::string::ToString::to_string(&self.version).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("hash", pbjson::private::base64::encode(&self.hash).as_str())?;
         }
         struct_ser.end()
@@ -365,20 +367,20 @@ impl<'de> serde::Deserialize<'de> for CommitId {
                 formatter.write_str("struct cosmos.base.store.v1beta1.CommitID")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<CommitId, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<CommitId, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut version__ = None;
                 let mut hash__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Version => {
                             if version__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("version"));
                             }
                             version__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Hash => {
@@ -386,7 +388,7 @@ impl<'de> serde::Deserialize<'de> for CommitId {
                                 return Err(serde::de::Error::duplicate_field("hash"));
                             }
                             hash__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -419,6 +421,7 @@ impl serde::Serialize for CommitInfo {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.base.store.v1beta1.CommitInfo", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("version", ::alloc::string::ToString::to_string(&self.version).as_str())?;
         }
         if true {
@@ -487,34 +490,34 @@ impl<'de> serde::Deserialize<'de> for CommitInfo {
                 formatter.write_str("struct cosmos.base.store.v1beta1.CommitInfo")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<CommitInfo, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<CommitInfo, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut version__ = None;
                 let mut store_infos__ = None;
                 let mut timestamp__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Version => {
                             if version__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("version"));
                             }
                             version__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::StoreInfos => {
                             if store_infos__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("storeInfos"));
                             }
-                            store_infos__ = Some(map.next_value()?);
+                            store_infos__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Timestamp => {
                             if timestamp__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("timestamp"));
                             }
-                            timestamp__ = map.next_value()?;
+                            timestamp__ = map_.next_value()?;
                         }
                     }
                 }
@@ -606,25 +609,25 @@ impl<'de> serde::Deserialize<'de> for StoreInfo {
                 formatter.write_str("struct cosmos.base.store.v1beta1.StoreInfo")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<StoreInfo, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<StoreInfo, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut name__ = None;
                 let mut commit_id__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Name => {
                             if name__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("name"));
                             }
-                            name__ = Some(map.next_value()?);
+                            name__ = Some(map_.next_value()?);
                         }
                         GeneratedField::CommitId => {
                             if commit_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("commitId"));
                             }
-                            commit_id__ = map.next_value()?;
+                            commit_id__ = map_.next_value()?;
                         }
                     }
                 }
@@ -665,9 +668,11 @@ impl serde::Serialize for StoreKvPair {
             struct_ser.serialize_field("delete", &self.delete)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("key", pbjson::private::base64::encode(&self.key).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
         }
         struct_ser.end()
@@ -733,7 +738,7 @@ impl<'de> serde::Deserialize<'de> for StoreKvPair {
                 formatter.write_str("struct cosmos.base.store.v1beta1.StoreKVPair")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<StoreKvPair, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<StoreKvPair, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -741,26 +746,26 @@ impl<'de> serde::Deserialize<'de> for StoreKvPair {
                 let mut delete__ = None;
                 let mut key__ = None;
                 let mut value__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::StoreKey => {
                             if store_key__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("storeKey"));
                             }
-                            store_key__ = Some(map.next_value()?);
+                            store_key__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Delete => {
                             if delete__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("delete"));
                             }
-                            delete__ = Some(map.next_value()?);
+                            delete__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Key => {
                             if key__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("key"));
                             }
                             key__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Value => {
@@ -768,7 +773,7 @@ impl<'de> serde::Deserialize<'de> for StoreKvPair {
                                 return Err(serde::de::Error::duplicate_field("value"));
                             }
                             value__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
diff --git a/src/prost/cosmos.base.v1beta1.serde.rs b/src/prost/cosmos.base.v1beta1.serde.rs
index 84e7cc70..91566588 100644
--- a/src/prost/cosmos.base.v1beta1.serde.rs
+++ b/src/prost/cosmos.base.v1beta1.serde.rs
@@ -75,25 +75,25 @@ impl<'de> serde::Deserialize<'de> for Coin {
                 formatter.write_str("struct cosmos.base.v1beta1.Coin")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Coin, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Coin, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut denom__ = None;
                 let mut amount__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Denom => {
                             if denom__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("denom"));
                             }
-                            denom__ = Some(map.next_value()?);
+                            denom__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Amount => {
                             if amount__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("amount"));
                             }
-                            amount__ = Some(map.next_value()?);
+                            amount__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -183,25 +183,25 @@ impl<'de> serde::Deserialize<'de> for DecCoin {
                 formatter.write_str("struct cosmos.base.v1beta1.DecCoin")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<DecCoin, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<DecCoin, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut denom__ = None;
                 let mut amount__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Denom => {
                             if denom__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("denom"));
                             }
-                            denom__ = Some(map.next_value()?);
+                            denom__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Amount => {
                             if amount__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("amount"));
                             }
-                            amount__ = Some(map.next_value()?);
+                            amount__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -282,18 +282,18 @@ impl<'de> serde::Deserialize<'de> for DecProto {
                 formatter.write_str("struct cosmos.base.v1beta1.DecProto")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<DecProto, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<DecProto, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut dec__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Dec => {
                             if dec__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("dec"));
                             }
-                            dec__ = Some(map.next_value()?);
+                            dec__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -373,18 +373,18 @@ impl<'de> serde::Deserialize<'de> for IntProto {
                 formatter.write_str("struct cosmos.base.v1beta1.IntProto")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<IntProto, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<IntProto, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut int__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Int => {
                             if int__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("int"));
                             }
-                            int__ = Some(map.next_value()?);
+                            int__ = Some(map_.next_value()?);
                         }
                     }
                 }
diff --git a/src/prost/cosmos.crypto.ed25519.serde.rs b/src/prost/cosmos.crypto.ed25519.serde.rs
index 47ffcbe0..5d4a3dc7 100644
--- a/src/prost/cosmos.crypto.ed25519.serde.rs
+++ b/src/prost/cosmos.crypto.ed25519.serde.rs
@@ -11,6 +11,7 @@ impl serde::Serialize for PrivKey {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.crypto.ed25519.PrivKey", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("key", pbjson::private::base64::encode(&self.key).as_str())?;
         }
         struct_ser.end()
@@ -66,19 +67,19 @@ impl<'de> serde::Deserialize<'de> for PrivKey {
                 formatter.write_str("struct cosmos.crypto.ed25519.PrivKey")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<PrivKey, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<PrivKey, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut key__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Key => {
                             if key__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("key"));
                             }
                             key__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -104,6 +105,7 @@ impl serde::Serialize for PubKey {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.crypto.ed25519.PubKey", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("key", pbjson::private::base64::encode(&self.key).as_str())?;
         }
         struct_ser.end()
@@ -159,19 +161,19 @@ impl<'de> serde::Deserialize<'de> for PubKey {
                 formatter.write_str("struct cosmos.crypto.ed25519.PubKey")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<PubKey, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<PubKey, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut key__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Key => {
                             if key__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("key"));
                             }
                             key__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
diff --git a/src/prost/cosmos.crypto.hd.v1.serde.rs b/src/prost/cosmos.crypto.hd.v1.serde.rs
index 4789d36c..1e466886 100644
--- a/src/prost/cosmos.crypto.hd.v1.serde.rs
+++ b/src/prost/cosmos.crypto.hd.v1.serde.rs
@@ -104,7 +104,7 @@ impl<'de> serde::Deserialize<'de> for Bip44Params {
                 formatter.write_str("struct cosmos.crypto.hd.v1.BIP44Params")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Bip44Params, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Bip44Params, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -113,14 +113,14 @@ impl<'de> serde::Deserialize<'de> for Bip44Params {
                 let mut account__ = None;
                 let mut change__ = None;
                 let mut address_index__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Purpose => {
                             if purpose__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("purpose"));
                             }
                             purpose__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::CoinType => {
@@ -128,7 +128,7 @@ impl<'de> serde::Deserialize<'de> for Bip44Params {
                                 return Err(serde::de::Error::duplicate_field("coinType"));
                             }
                             coin_type__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Account => {
@@ -136,21 +136,21 @@ impl<'de> serde::Deserialize<'de> for Bip44Params {
                                 return Err(serde::de::Error::duplicate_field("account"));
                             }
                             account__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Change => {
                             if change__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("change"));
                             }
-                            change__ = Some(map.next_value()?);
+                            change__ = Some(map_.next_value()?);
                         }
                         GeneratedField::AddressIndex => {
                             if address_index__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("addressIndex"));
                             }
                             address_index__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
diff --git a/src/prost/cosmos.crypto.keyring.v1.serde.rs b/src/prost/cosmos.crypto.keyring.v1.serde.rs
index 7c16ab34..1141663a 100644
--- a/src/prost/cosmos.crypto.keyring.v1.serde.rs
+++ b/src/prost/cosmos.crypto.keyring.v1.serde.rs
@@ -107,53 +107,53 @@ impl<'de> serde::Deserialize<'de> for Record {
                 formatter.write_str("struct cosmos.crypto.keyring.v1.Record")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Record, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Record, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut name__ = None;
                 let mut pub_key__ = None;
                 let mut item__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Name => {
                             if name__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("name"));
                             }
-                            name__ = Some(map.next_value()?);
+                            name__ = Some(map_.next_value()?);
                         }
                         GeneratedField::PubKey => {
                             if pub_key__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pubKey"));
                             }
-                            pub_key__ = map.next_value()?;
+                            pub_key__ = map_.next_value()?;
                         }
                         GeneratedField::Local => {
                             if item__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("local"));
                             }
-                            item__ = map.next_value::<::core::option::Option<_>>()?.map(record::Item::Local)
+                            item__ = map_.next_value::<::core::option::Option<_>>()?.map(record::Item::Local)
 ;
                         }
                         GeneratedField::Ledger => {
                             if item__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("ledger"));
                             }
-                            item__ = map.next_value::<::core::option::Option<_>>()?.map(record::Item::Ledger)
+                            item__ = map_.next_value::<::core::option::Option<_>>()?.map(record::Item::Ledger)
 ;
                         }
                         GeneratedField::Multi => {
                             if item__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("multi"));
                             }
-                            item__ = map.next_value::<::core::option::Option<_>>()?.map(record::Item::Multi)
+                            item__ = map_.next_value::<::core::option::Option<_>>()?.map(record::Item::Multi)
 ;
                         }
                         GeneratedField::Offline => {
                             if item__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("offline"));
                             }
-                            item__ = map.next_value::<::core::option::Option<_>>()?.map(record::Item::Offline)
+                            item__ = map_.next_value::<::core::option::Option<_>>()?.map(record::Item::Offline)
 ;
                         }
                     }
@@ -236,18 +236,18 @@ impl<'de> serde::Deserialize<'de> for record::Ledger {
                 formatter.write_str("struct cosmos.crypto.keyring.v1.Record.Ledger")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<record::Ledger, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<record::Ledger, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut path__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Path => {
                             if path__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("path"));
                             }
-                            path__ = map.next_value()?;
+                            path__ = map_.next_value()?;
                         }
                     }
                 }
@@ -328,18 +328,18 @@ impl<'de> serde::Deserialize<'de> for record::Local {
                 formatter.write_str("struct cosmos.crypto.keyring.v1.Record.Local")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<record::Local, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<record::Local, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut priv_key__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PrivKey => {
                             if priv_key__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("privKey"));
                             }
-                            priv_key__ = map.next_value()?;
+                            priv_key__ = map_.next_value()?;
                         }
                     }
                 }
@@ -408,12 +408,12 @@ impl<'de> serde::Deserialize<'de> for record::Multi {
                 formatter.write_str("struct cosmos.crypto.keyring.v1.Record.Multi")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<record::Multi, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<record::Multi, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(record::Multi {
                 })
@@ -479,12 +479,12 @@ impl<'de> serde::Deserialize<'de> for record::Offline {
                 formatter.write_str("struct cosmos.crypto.keyring.v1.Record.Offline")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<record::Offline, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<record::Offline, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(record::Offline {
                 })
diff --git a/src/prost/cosmos.crypto.multisig.serde.rs b/src/prost/cosmos.crypto.multisig.serde.rs
index c12a7061..f535b553 100644
--- a/src/prost/cosmos.crypto.multisig.serde.rs
+++ b/src/prost/cosmos.crypto.multisig.serde.rs
@@ -76,27 +76,27 @@ impl<'de> serde::Deserialize<'de> for LegacyAminoPubKey {
                 formatter.write_str("struct cosmos.crypto.multisig.LegacyAminoPubKey")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<LegacyAminoPubKey, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<LegacyAminoPubKey, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut threshold__ = None;
                 let mut public_keys__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Threshold => {
                             if threshold__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("threshold"));
                             }
                             threshold__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::PublicKeys => {
                             if public_keys__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("publicKeys"));
                             }
-                            public_keys__ = Some(map.next_value()?);
+                            public_keys__ = Some(map_.next_value()?);
                         }
                     }
                 }
diff --git a/src/prost/cosmos.crypto.multisig.v1beta1.serde.rs b/src/prost/cosmos.crypto.multisig.v1beta1.serde.rs
index 3277ba0f..3a12dfe6 100644
--- a/src/prost/cosmos.crypto.multisig.v1beta1.serde.rs
+++ b/src/prost/cosmos.crypto.multisig.v1beta1.serde.rs
@@ -17,6 +17,7 @@ impl serde::Serialize for CompactBitArray {
             struct_ser.serialize_field("extraBitsStored", &self.extra_bits_stored)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("elems", pbjson::private::base64::encode(&self.elems).as_str())?;
         }
         struct_ser.end()
@@ -76,20 +77,20 @@ impl<'de> serde::Deserialize<'de> for CompactBitArray {
                 formatter.write_str("struct cosmos.crypto.multisig.v1beta1.CompactBitArray")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<CompactBitArray, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<CompactBitArray, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut extra_bits_stored__ = None;
                 let mut elems__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ExtraBitsStored => {
                             if extra_bits_stored__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("extraBitsStored"));
                             }
                             extra_bits_stored__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Elems => {
@@ -97,7 +98,7 @@ impl<'de> serde::Deserialize<'de> for CompactBitArray {
                                 return Err(serde::de::Error::duplicate_field("elems"));
                             }
                             elems__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -179,19 +180,19 @@ impl<'de> serde::Deserialize<'de> for MultiSignature {
                 formatter.write_str("struct cosmos.crypto.multisig.v1beta1.MultiSignature")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MultiSignature, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MultiSignature, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut signatures__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Signatures => {
                             if signatures__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signatures"));
                             }
                             signatures__ = 
-                                Some(map.next_value::<::alloc::vec::Vec<::pbjson::private::BytesDeserialize<_>>>()?
+                                Some(map_.next_value::<::alloc::vec::Vec<::pbjson::private::BytesDeserialize<_>>>()?
                                     .into_iter().map(|x| x.0).collect())
                             ;
                         }
diff --git a/src/prost/cosmos.crypto.secp256k1.serde.rs b/src/prost/cosmos.crypto.secp256k1.serde.rs
index 93ed7dec..aaea5af5 100644
--- a/src/prost/cosmos.crypto.secp256k1.serde.rs
+++ b/src/prost/cosmos.crypto.secp256k1.serde.rs
@@ -11,6 +11,7 @@ impl serde::Serialize for PrivKey {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.crypto.secp256k1.PrivKey", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("key", pbjson::private::base64::encode(&self.key).as_str())?;
         }
         struct_ser.end()
@@ -66,19 +67,19 @@ impl<'de> serde::Deserialize<'de> for PrivKey {
                 formatter.write_str("struct cosmos.crypto.secp256k1.PrivKey")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<PrivKey, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<PrivKey, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut key__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Key => {
                             if key__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("key"));
                             }
                             key__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -104,6 +105,7 @@ impl serde::Serialize for PubKey {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.crypto.secp256k1.PubKey", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("key", pbjson::private::base64::encode(&self.key).as_str())?;
         }
         struct_ser.end()
@@ -159,19 +161,19 @@ impl<'de> serde::Deserialize<'de> for PubKey {
                 formatter.write_str("struct cosmos.crypto.secp256k1.PubKey")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<PubKey, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<PubKey, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut key__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Key => {
                             if key__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("key"));
                             }
                             key__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
diff --git a/src/prost/cosmos.crypto.secp256r1.serde.rs b/src/prost/cosmos.crypto.secp256r1.serde.rs
index 78159b52..f1cca10b 100644
--- a/src/prost/cosmos.crypto.secp256r1.serde.rs
+++ b/src/prost/cosmos.crypto.secp256r1.serde.rs
@@ -11,6 +11,7 @@ impl serde::Serialize for PrivKey {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.crypto.secp256r1.PrivKey", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("secret", pbjson::private::base64::encode(&self.secret).as_str())?;
         }
         struct_ser.end()
@@ -66,19 +67,19 @@ impl<'de> serde::Deserialize<'de> for PrivKey {
                 formatter.write_str("struct cosmos.crypto.secp256r1.PrivKey")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<PrivKey, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<PrivKey, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut secret__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Secret => {
                             if secret__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("secret"));
                             }
                             secret__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -104,6 +105,7 @@ impl serde::Serialize for PubKey {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.crypto.secp256r1.PubKey", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("key", pbjson::private::base64::encode(&self.key).as_str())?;
         }
         struct_ser.end()
@@ -159,19 +161,19 @@ impl<'de> serde::Deserialize<'de> for PubKey {
                 formatter.write_str("struct cosmos.crypto.secp256r1.PubKey")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<PubKey, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<PubKey, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut key__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Key => {
                             if key__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("key"));
                             }
                             key__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
diff --git a/src/prost/cosmos.gov.module.v1.serde.rs b/src/prost/cosmos.gov.module.v1.serde.rs
index 21f5de59..88377721 100644
--- a/src/prost/cosmos.gov.module.v1.serde.rs
+++ b/src/prost/cosmos.gov.module.v1.serde.rs
@@ -14,6 +14,7 @@ impl serde::Serialize for Module {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.module.v1.Module", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("maxMetadataLen", ::alloc::string::ToString::to_string(&self.max_metadata_len).as_str())?;
         }
         if true {
@@ -76,27 +77,27 @@ impl<'de> serde::Deserialize<'de> for Module {
                 formatter.write_str("struct cosmos.gov.module.v1.Module")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Module, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Module, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut max_metadata_len__ = None;
                 let mut authority__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::MaxMetadataLen => {
                             if max_metadata_len__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("maxMetadataLen"));
                             }
                             max_metadata_len__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Authority => {
                             if authority__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("authority"));
                             }
-                            authority__ = Some(map.next_value()?);
+                            authority__ = Some(map_.next_value()?);
                         }
                     }
                 }
diff --git a/src/prost/cosmos.gov.v1.serde.rs b/src/prost/cosmos.gov.v1.serde.rs
index 0c06a74b..82932543 100644
--- a/src/prost/cosmos.gov.v1.serde.rs
+++ b/src/prost/cosmos.gov.v1.serde.rs
@@ -17,6 +17,7 @@ impl serde::Serialize for Deposit {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.v1.Deposit", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proposalId", ::alloc::string::ToString::to_string(&self.proposal_id).as_str())?;
         }
         if true {
@@ -85,34 +86,34 @@ impl<'de> serde::Deserialize<'de> for Deposit {
                 formatter.write_str("struct cosmos.gov.v1.Deposit")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Deposit, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Deposit, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut proposal_id__ = None;
                 let mut depositor__ = None;
                 let mut amount__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ProposalId => {
                             if proposal_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposalId"));
                             }
                             proposal_id__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Depositor => {
                             if depositor__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("depositor"));
                             }
-                            depositor__ = Some(map.next_value()?);
+                            depositor__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Amount => {
                             if amount__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("amount"));
                             }
-                            amount__ = Some(map.next_value()?);
+                            amount__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -205,25 +206,25 @@ impl<'de> serde::Deserialize<'de> for DepositParams {
                 formatter.write_str("struct cosmos.gov.v1.DepositParams")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<DepositParams, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<DepositParams, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut min_deposit__ = None;
                 let mut max_deposit_period__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::MinDeposit => {
                             if min_deposit__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("minDeposit"));
                             }
-                            min_deposit__ = Some(map.next_value()?);
+                            min_deposit__ = Some(map_.next_value()?);
                         }
                         GeneratedField::MaxDepositPeriod => {
                             if max_deposit_period__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("maxDepositPeriod"));
                             }
-                            max_deposit_period__ = map.next_value()?;
+                            max_deposit_period__ = map_.next_value()?;
                         }
                     }
                 }
@@ -270,6 +271,7 @@ impl serde::Serialize for GenesisState {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.v1.GenesisState", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("startingProposalId", ::alloc::string::ToString::to_string(&self.starting_proposal_id).as_str())?;
         }
         if true {
@@ -371,7 +373,7 @@ impl<'de> serde::Deserialize<'de> for GenesisState {
                 formatter.write_str("struct cosmos.gov.v1.GenesisState")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<GenesisState, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<GenesisState, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -383,57 +385,57 @@ impl<'de> serde::Deserialize<'de> for GenesisState {
                 let mut voting_params__ = None;
                 let mut tally_params__ = None;
                 let mut params__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::StartingProposalId => {
                             if starting_proposal_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("startingProposalId"));
                             }
                             starting_proposal_id__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Deposits => {
                             if deposits__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("deposits"));
                             }
-                            deposits__ = Some(map.next_value()?);
+                            deposits__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Votes => {
                             if votes__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("votes"));
                             }
-                            votes__ = Some(map.next_value()?);
+                            votes__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Proposals => {
                             if proposals__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposals"));
                             }
-                            proposals__ = Some(map.next_value()?);
+                            proposals__ = Some(map_.next_value()?);
                         }
                         GeneratedField::DepositParams => {
                             if deposit_params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("depositParams"));
                             }
-                            deposit_params__ = map.next_value()?;
+                            deposit_params__ = map_.next_value()?;
                         }
                         GeneratedField::VotingParams => {
                             if voting_params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("votingParams"));
                             }
-                            voting_params__ = map.next_value()?;
+                            voting_params__ = map_.next_value()?;
                         }
                         GeneratedField::TallyParams => {
                             if tally_params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("tallyParams"));
                             }
-                            tally_params__ = map.next_value()?;
+                            tally_params__ = map_.next_value()?;
                         }
                         GeneratedField::Params => {
                             if params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("params"));
                             }
-                            params__ = map.next_value()?;
+                            params__ = map_.next_value()?;
                         }
                     }
                 }
@@ -471,6 +473,7 @@ impl serde::Serialize for MsgDeposit {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.v1.MsgDeposit", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proposalId", ::alloc::string::ToString::to_string(&self.proposal_id).as_str())?;
         }
         if true {
@@ -539,34 +542,34 @@ impl<'de> serde::Deserialize<'de> for MsgDeposit {
                 formatter.write_str("struct cosmos.gov.v1.MsgDeposit")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgDeposit, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgDeposit, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut proposal_id__ = None;
                 let mut depositor__ = None;
                 let mut amount__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ProposalId => {
                             if proposal_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposalId"));
                             }
                             proposal_id__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Depositor => {
                             if depositor__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("depositor"));
                             }
-                            depositor__ = Some(map.next_value()?);
+                            depositor__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Amount => {
                             if amount__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("amount"));
                             }
-                            amount__ = Some(map.next_value()?);
+                            amount__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -637,12 +640,12 @@ impl<'de> serde::Deserialize<'de> for MsgDepositResponse {
                 formatter.write_str("struct cosmos.gov.v1.MsgDepositResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgDepositResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgDepositResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgDepositResponse {
                 })
@@ -728,25 +731,25 @@ impl<'de> serde::Deserialize<'de> for MsgExecLegacyContent {
                 formatter.write_str("struct cosmos.gov.v1.MsgExecLegacyContent")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgExecLegacyContent, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgExecLegacyContent, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut content__ = None;
                 let mut authority__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Content => {
                             if content__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("content"));
                             }
-                            content__ = map.next_value()?;
+                            content__ = map_.next_value()?;
                         }
                         GeneratedField::Authority => {
                             if authority__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("authority"));
                             }
-                            authority__ = Some(map.next_value()?);
+                            authority__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -816,12 +819,12 @@ impl<'de> serde::Deserialize<'de> for MsgExecLegacyContentResponse {
                 formatter.write_str("struct cosmos.gov.v1.MsgExecLegacyContentResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgExecLegacyContentResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgExecLegacyContentResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgExecLegacyContentResponse {
                 })
@@ -944,7 +947,7 @@ impl<'de> serde::Deserialize<'de> for MsgSubmitProposal {
                 formatter.write_str("struct cosmos.gov.v1.MsgSubmitProposal")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgSubmitProposal, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgSubmitProposal, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -954,43 +957,43 @@ impl<'de> serde::Deserialize<'de> for MsgSubmitProposal {
                 let mut metadata__ = None;
                 let mut title__ = None;
                 let mut summary__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Messages => {
                             if messages__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("messages"));
                             }
-                            messages__ = Some(map.next_value()?);
+                            messages__ = Some(map_.next_value()?);
                         }
                         GeneratedField::InitialDeposit => {
                             if initial_deposit__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("initialDeposit"));
                             }
-                            initial_deposit__ = Some(map.next_value()?);
+                            initial_deposit__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Proposer => {
                             if proposer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposer"));
                             }
-                            proposer__ = Some(map.next_value()?);
+                            proposer__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Metadata => {
                             if metadata__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("metadata"));
                             }
-                            metadata__ = Some(map.next_value()?);
+                            metadata__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Title => {
                             if title__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("title"));
                             }
-                            title__ = Some(map.next_value()?);
+                            title__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Summary => {
                             if summary__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("summary"));
                             }
-                            summary__ = Some(map.next_value()?);
+                            summary__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1020,6 +1023,7 @@ impl serde::Serialize for MsgSubmitProposalResponse {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.v1.MsgSubmitProposalResponse", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proposalId", ::alloc::string::ToString::to_string(&self.proposal_id).as_str())?;
         }
         struct_ser.end()
@@ -1076,19 +1080,19 @@ impl<'de> serde::Deserialize<'de> for MsgSubmitProposalResponse {
                 formatter.write_str("struct cosmos.gov.v1.MsgSubmitProposalResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgSubmitProposalResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgSubmitProposalResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut proposal_id__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ProposalId => {
                             if proposal_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposalId"));
                             }
                             proposal_id__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -1178,25 +1182,25 @@ impl<'de> serde::Deserialize<'de> for MsgUpdateParams {
                 formatter.write_str("struct cosmos.gov.v1.MsgUpdateParams")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgUpdateParams, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgUpdateParams, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut authority__ = None;
                 let mut params__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Authority => {
                             if authority__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("authority"));
                             }
-                            authority__ = Some(map.next_value()?);
+                            authority__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Params => {
                             if params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("params"));
                             }
-                            params__ = map.next_value()?;
+                            params__ = map_.next_value()?;
                         }
                     }
                 }
@@ -1266,12 +1270,12 @@ impl<'de> serde::Deserialize<'de> for MsgUpdateParamsResponse {
                 formatter.write_str("struct cosmos.gov.v1.MsgUpdateParamsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgUpdateParamsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgUpdateParamsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgUpdateParamsResponse {
                 })
@@ -1302,14 +1306,15 @@ impl serde::Serialize for MsgVote {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.v1.MsgVote", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proposalId", ::alloc::string::ToString::to_string(&self.proposal_id).as_str())?;
         }
         if true {
             struct_ser.serialize_field("voter", &self.voter)?;
         }
         if true {
-            let v = VoteOption::from_i32(self.option)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.option)))?;
+            let v = VoteOption::try_from(self.option)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.option)))?;
             struct_ser.serialize_field("option", &v)?;
         }
         if true {
@@ -1378,7 +1383,7 @@ impl<'de> serde::Deserialize<'de> for MsgVote {
                 formatter.write_str("struct cosmos.gov.v1.MsgVote")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgVote, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgVote, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -1386,33 +1391,33 @@ impl<'de> serde::Deserialize<'de> for MsgVote {
                 let mut voter__ = None;
                 let mut option__ = None;
                 let mut metadata__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ProposalId => {
                             if proposal_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposalId"));
                             }
                             proposal_id__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Voter => {
                             if voter__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("voter"));
                             }
-                            voter__ = Some(map.next_value()?);
+                            voter__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Option => {
                             if option__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("option"));
                             }
-                            option__ = Some(map.next_value::<VoteOption>()? as i32);
+                            option__ = Some(map_.next_value::<VoteOption>()? as i32);
                         }
                         GeneratedField::Metadata => {
                             if metadata__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("metadata"));
                             }
-                            metadata__ = Some(map.next_value()?);
+                            metadata__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1484,12 +1489,12 @@ impl<'de> serde::Deserialize<'de> for MsgVoteResponse {
                 formatter.write_str("struct cosmos.gov.v1.MsgVoteResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgVoteResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgVoteResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgVoteResponse {
                 })
@@ -1520,6 +1525,7 @@ impl serde::Serialize for MsgVoteWeighted {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.v1.MsgVoteWeighted", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proposalId", ::alloc::string::ToString::to_string(&self.proposal_id).as_str())?;
         }
         if true {
@@ -1594,7 +1600,7 @@ impl<'de> serde::Deserialize<'de> for MsgVoteWeighted {
                 formatter.write_str("struct cosmos.gov.v1.MsgVoteWeighted")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgVoteWeighted, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgVoteWeighted, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -1602,33 +1608,33 @@ impl<'de> serde::Deserialize<'de> for MsgVoteWeighted {
                 let mut voter__ = None;
                 let mut options__ = None;
                 let mut metadata__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ProposalId => {
                             if proposal_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposalId"));
                             }
                             proposal_id__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Voter => {
                             if voter__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("voter"));
                             }
-                            voter__ = Some(map.next_value()?);
+                            voter__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Options => {
                             if options__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("options"));
                             }
-                            options__ = Some(map.next_value()?);
+                            options__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Metadata => {
                             if metadata__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("metadata"));
                             }
-                            metadata__ = Some(map.next_value()?);
+                            metadata__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1700,12 +1706,12 @@ impl<'de> serde::Deserialize<'de> for MsgVoteWeightedResponse {
                 formatter.write_str("struct cosmos.gov.v1.MsgVoteWeightedResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgVoteWeightedResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgVoteWeightedResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgVoteWeightedResponse {
                 })
@@ -1871,7 +1877,7 @@ impl<'de> serde::Deserialize<'de> for Params {
                 formatter.write_str("struct cosmos.gov.v1.Params")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Params, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Params, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -1885,67 +1891,67 @@ impl<'de> serde::Deserialize<'de> for Params {
                 let mut burn_vote_quorum__ = None;
                 let mut burn_proposal_deposit_prevote__ = None;
                 let mut burn_vote_veto__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::MinDeposit => {
                             if min_deposit__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("minDeposit"));
                             }
-                            min_deposit__ = Some(map.next_value()?);
+                            min_deposit__ = Some(map_.next_value()?);
                         }
                         GeneratedField::MaxDepositPeriod => {
                             if max_deposit_period__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("maxDepositPeriod"));
                             }
-                            max_deposit_period__ = map.next_value()?;
+                            max_deposit_period__ = map_.next_value()?;
                         }
                         GeneratedField::VotingPeriod => {
                             if voting_period__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("votingPeriod"));
                             }
-                            voting_period__ = map.next_value()?;
+                            voting_period__ = map_.next_value()?;
                         }
                         GeneratedField::Quorum => {
                             if quorum__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("quorum"));
                             }
-                            quorum__ = Some(map.next_value()?);
+                            quorum__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Threshold => {
                             if threshold__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("threshold"));
                             }
-                            threshold__ = Some(map.next_value()?);
+                            threshold__ = Some(map_.next_value()?);
                         }
                         GeneratedField::VetoThreshold => {
                             if veto_threshold__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("vetoThreshold"));
                             }
-                            veto_threshold__ = Some(map.next_value()?);
+                            veto_threshold__ = Some(map_.next_value()?);
                         }
                         GeneratedField::MinInitialDepositRatio => {
                             if min_initial_deposit_ratio__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("minInitialDepositRatio"));
                             }
-                            min_initial_deposit_ratio__ = Some(map.next_value()?);
+                            min_initial_deposit_ratio__ = Some(map_.next_value()?);
                         }
                         GeneratedField::BurnVoteQuorum => {
                             if burn_vote_quorum__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("burnVoteQuorum"));
                             }
-                            burn_vote_quorum__ = Some(map.next_value()?);
+                            burn_vote_quorum__ = Some(map_.next_value()?);
                         }
                         GeneratedField::BurnProposalDepositPrevote => {
                             if burn_proposal_deposit_prevote__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("burnProposalDepositPrevote"));
                             }
-                            burn_proposal_deposit_prevote__ = Some(map.next_value()?);
+                            burn_proposal_deposit_prevote__ = Some(map_.next_value()?);
                         }
                         GeneratedField::BurnVoteVeto => {
                             if burn_vote_veto__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("burnVoteVeto"));
                             }
-                            burn_vote_veto__ = Some(map.next_value()?);
+                            burn_vote_veto__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -2015,14 +2021,15 @@ impl serde::Serialize for Proposal {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.v1.Proposal", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("id", ::alloc::string::ToString::to_string(&self.id).as_str())?;
         }
         if true {
             struct_ser.serialize_field("messages", &self.messages)?;
         }
         if true {
-            let v = ProposalStatus::from_i32(self.status)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.status)))?;
+            let v = ProposalStatus::try_from(self.status)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.status)))?;
             struct_ser.serialize_field("status", &v)?;
         }
         if let Some(v) = self.final_tally_result.as_ref() {
@@ -2150,7 +2157,7 @@ impl<'de> serde::Deserialize<'de> for Proposal {
                 formatter.write_str("struct cosmos.gov.v1.Proposal")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Proposal, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Proposal, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -2167,87 +2174,87 @@ impl<'de> serde::Deserialize<'de> for Proposal {
                 let mut title__ = None;
                 let mut summary__ = None;
                 let mut proposer__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Id => {
                             if id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("id"));
                             }
                             id__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Messages => {
                             if messages__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("messages"));
                             }
-                            messages__ = Some(map.next_value()?);
+                            messages__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Status => {
                             if status__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("status"));
                             }
-                            status__ = Some(map.next_value::<ProposalStatus>()? as i32);
+                            status__ = Some(map_.next_value::<ProposalStatus>()? as i32);
                         }
                         GeneratedField::FinalTallyResult => {
                             if final_tally_result__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("finalTallyResult"));
                             }
-                            final_tally_result__ = map.next_value()?;
+                            final_tally_result__ = map_.next_value()?;
                         }
                         GeneratedField::SubmitTime => {
                             if submit_time__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("submitTime"));
                             }
-                            submit_time__ = map.next_value()?;
+                            submit_time__ = map_.next_value()?;
                         }
                         GeneratedField::DepositEndTime => {
                             if deposit_end_time__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("depositEndTime"));
                             }
-                            deposit_end_time__ = map.next_value()?;
+                            deposit_end_time__ = map_.next_value()?;
                         }
                         GeneratedField::TotalDeposit => {
                             if total_deposit__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("totalDeposit"));
                             }
-                            total_deposit__ = Some(map.next_value()?);
+                            total_deposit__ = Some(map_.next_value()?);
                         }
                         GeneratedField::VotingStartTime => {
                             if voting_start_time__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("votingStartTime"));
                             }
-                            voting_start_time__ = map.next_value()?;
+                            voting_start_time__ = map_.next_value()?;
                         }
                         GeneratedField::VotingEndTime => {
                             if voting_end_time__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("votingEndTime"));
                             }
-                            voting_end_time__ = map.next_value()?;
+                            voting_end_time__ = map_.next_value()?;
                         }
                         GeneratedField::Metadata => {
                             if metadata__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("metadata"));
                             }
-                            metadata__ = Some(map.next_value()?);
+                            metadata__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Title => {
                             if title__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("title"));
                             }
-                            title__ = Some(map.next_value()?);
+                            title__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Summary => {
                             if summary__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("summary"));
                             }
-                            summary__ = Some(map.next_value()?);
+                            summary__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Proposer => {
                             if proposer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposer"));
                             }
-                            proposer__ = Some(map.next_value()?);
+                            proposer__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -2316,10 +2323,9 @@ impl<'de> serde::Deserialize<'de> for ProposalStatus {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(ProposalStatus::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -2329,10 +2335,9 @@ impl<'de> serde::Deserialize<'de> for ProposalStatus {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(ProposalStatus::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
@@ -2372,6 +2377,7 @@ impl serde::Serialize for QueryDepositRequest {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.v1.QueryDepositRequest", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proposalId", ::alloc::string::ToString::to_string(&self.proposal_id).as_str())?;
         }
         if true {
@@ -2434,27 +2440,27 @@ impl<'de> serde::Deserialize<'de> for QueryDepositRequest {
                 formatter.write_str("struct cosmos.gov.v1.QueryDepositRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryDepositRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryDepositRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut proposal_id__ = None;
                 let mut depositor__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ProposalId => {
                             if proposal_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposalId"));
                             }
                             proposal_id__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Depositor => {
                             if depositor__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("depositor"));
                             }
-                            depositor__ = Some(map.next_value()?);
+                            depositor__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -2535,18 +2541,18 @@ impl<'de> serde::Deserialize<'de> for QueryDepositResponse {
                 formatter.write_str("struct cosmos.gov.v1.QueryDepositResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryDepositResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryDepositResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut deposit__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Deposit => {
                             if deposit__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("deposit"));
                             }
-                            deposit__ = map.next_value()?;
+                            deposit__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2574,6 +2580,7 @@ impl serde::Serialize for QueryDepositsRequest {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.v1.QueryDepositsRequest", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proposalId", ::alloc::string::ToString::to_string(&self.proposal_id).as_str())?;
         }
         if let Some(v) = self.pagination.as_ref() {
@@ -2636,27 +2643,27 @@ impl<'de> serde::Deserialize<'de> for QueryDepositsRequest {
                 formatter.write_str("struct cosmos.gov.v1.QueryDepositsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryDepositsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryDepositsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut proposal_id__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ProposalId => {
                             if proposal_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposalId"));
                             }
                             proposal_id__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2746,25 +2753,25 @@ impl<'de> serde::Deserialize<'de> for QueryDepositsResponse {
                 formatter.write_str("struct cosmos.gov.v1.QueryDepositsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryDepositsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryDepositsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut deposits__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Deposits => {
                             if deposits__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("deposits"));
                             }
-                            deposits__ = Some(map.next_value()?);
+                            deposits__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2846,18 +2853,18 @@ impl<'de> serde::Deserialize<'de> for QueryParamsRequest {
                 formatter.write_str("struct cosmos.gov.v1.QueryParamsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryParamsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryParamsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut params_type__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ParamsType => {
                             if params_type__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("paramsType"));
                             }
-                            params_type__ = Some(map.next_value()?);
+                            params_type__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -2967,7 +2974,7 @@ impl<'de> serde::Deserialize<'de> for QueryParamsResponse {
                 formatter.write_str("struct cosmos.gov.v1.QueryParamsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryParamsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryParamsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -2975,31 +2982,31 @@ impl<'de> serde::Deserialize<'de> for QueryParamsResponse {
                 let mut deposit_params__ = None;
                 let mut tally_params__ = None;
                 let mut params__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::VotingParams => {
                             if voting_params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("votingParams"));
                             }
-                            voting_params__ = map.next_value()?;
+                            voting_params__ = map_.next_value()?;
                         }
                         GeneratedField::DepositParams => {
                             if deposit_params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("depositParams"));
                             }
-                            deposit_params__ = map.next_value()?;
+                            deposit_params__ = map_.next_value()?;
                         }
                         GeneratedField::TallyParams => {
                             if tally_params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("tallyParams"));
                             }
-                            tally_params__ = map.next_value()?;
+                            tally_params__ = map_.next_value()?;
                         }
                         GeneratedField::Params => {
                             if params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("params"));
                             }
-                            params__ = map.next_value()?;
+                            params__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3027,6 +3034,7 @@ impl serde::Serialize for QueryProposalRequest {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.v1.QueryProposalRequest", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proposalId", ::alloc::string::ToString::to_string(&self.proposal_id).as_str())?;
         }
         struct_ser.end()
@@ -3083,19 +3091,19 @@ impl<'de> serde::Deserialize<'de> for QueryProposalRequest {
                 formatter.write_str("struct cosmos.gov.v1.QueryProposalRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryProposalRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryProposalRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut proposal_id__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ProposalId => {
                             if proposal_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposalId"));
                             }
                             proposal_id__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -3176,18 +3184,18 @@ impl<'de> serde::Deserialize<'de> for QueryProposalResponse {
                 formatter.write_str("struct cosmos.gov.v1.QueryProposalResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryProposalResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryProposalResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut proposal__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Proposal => {
                             if proposal__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposal"));
                             }
-                            proposal__ = map.next_value()?;
+                            proposal__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3221,8 +3229,8 @@ impl serde::Serialize for QueryProposalsRequest {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.v1.QueryProposalsRequest", len)?;
         if true {
-            let v = ProposalStatus::from_i32(self.proposal_status)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.proposal_status)))?;
+            let v = ProposalStatus::try_from(self.proposal_status)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.proposal_status)))?;
             struct_ser.serialize_field("proposalStatus", &v)?;
         }
         if true {
@@ -3297,7 +3305,7 @@ impl<'de> serde::Deserialize<'de> for QueryProposalsRequest {
                 formatter.write_str("struct cosmos.gov.v1.QueryProposalsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryProposalsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryProposalsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -3305,31 +3313,31 @@ impl<'de> serde::Deserialize<'de> for QueryProposalsRequest {
                 let mut voter__ = None;
                 let mut depositor__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ProposalStatus => {
                             if proposal_status__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposalStatus"));
                             }
-                            proposal_status__ = Some(map.next_value::<ProposalStatus>()? as i32);
+                            proposal_status__ = Some(map_.next_value::<ProposalStatus>()? as i32);
                         }
                         GeneratedField::Voter => {
                             if voter__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("voter"));
                             }
-                            voter__ = Some(map.next_value()?);
+                            voter__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Depositor => {
                             if depositor__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("depositor"));
                             }
-                            depositor__ = Some(map.next_value()?);
+                            depositor__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3421,25 +3429,25 @@ impl<'de> serde::Deserialize<'de> for QueryProposalsResponse {
                 formatter.write_str("struct cosmos.gov.v1.QueryProposalsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryProposalsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryProposalsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut proposals__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Proposals => {
                             if proposals__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposals"));
                             }
-                            proposals__ = Some(map.next_value()?);
+                            proposals__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3465,6 +3473,7 @@ impl serde::Serialize for QueryTallyResultRequest {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.v1.QueryTallyResultRequest", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proposalId", ::alloc::string::ToString::to_string(&self.proposal_id).as_str())?;
         }
         struct_ser.end()
@@ -3521,19 +3530,19 @@ impl<'de> serde::Deserialize<'de> for QueryTallyResultRequest {
                 formatter.write_str("struct cosmos.gov.v1.QueryTallyResultRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryTallyResultRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryTallyResultRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut proposal_id__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ProposalId => {
                             if proposal_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposalId"));
                             }
                             proposal_id__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -3614,18 +3623,18 @@ impl<'de> serde::Deserialize<'de> for QueryTallyResultResponse {
                 formatter.write_str("struct cosmos.gov.v1.QueryTallyResultResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryTallyResultResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryTallyResultResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut tally__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Tally => {
                             if tally__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("tally"));
                             }
-                            tally__ = map.next_value()?;
+                            tally__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3653,6 +3662,7 @@ impl serde::Serialize for QueryVoteRequest {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.v1.QueryVoteRequest", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proposalId", ::alloc::string::ToString::to_string(&self.proposal_id).as_str())?;
         }
         if true {
@@ -3715,27 +3725,27 @@ impl<'de> serde::Deserialize<'de> for QueryVoteRequest {
                 formatter.write_str("struct cosmos.gov.v1.QueryVoteRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryVoteRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryVoteRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut proposal_id__ = None;
                 let mut voter__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ProposalId => {
                             if proposal_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposalId"));
                             }
                             proposal_id__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Voter => {
                             if voter__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("voter"));
                             }
-                            voter__ = Some(map.next_value()?);
+                            voter__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -3816,18 +3826,18 @@ impl<'de> serde::Deserialize<'de> for QueryVoteResponse {
                 formatter.write_str("struct cosmos.gov.v1.QueryVoteResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryVoteResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryVoteResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut vote__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Vote => {
                             if vote__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("vote"));
                             }
-                            vote__ = map.next_value()?;
+                            vote__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3855,6 +3865,7 @@ impl serde::Serialize for QueryVotesRequest {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.v1.QueryVotesRequest", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proposalId", ::alloc::string::ToString::to_string(&self.proposal_id).as_str())?;
         }
         if let Some(v) = self.pagination.as_ref() {
@@ -3917,27 +3928,27 @@ impl<'de> serde::Deserialize<'de> for QueryVotesRequest {
                 formatter.write_str("struct cosmos.gov.v1.QueryVotesRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryVotesRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryVotesRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut proposal_id__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ProposalId => {
                             if proposal_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposalId"));
                             }
                             proposal_id__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -4027,25 +4038,25 @@ impl<'de> serde::Deserialize<'de> for QueryVotesResponse {
                 formatter.write_str("struct cosmos.gov.v1.QueryVotesResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryVotesResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryVotesResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut votes__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Votes => {
                             if votes__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("votes"));
                             }
-                            votes__ = Some(map.next_value()?);
+                            votes__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -4145,32 +4156,32 @@ impl<'de> serde::Deserialize<'de> for TallyParams {
                 formatter.write_str("struct cosmos.gov.v1.TallyParams")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<TallyParams, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<TallyParams, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut quorum__ = None;
                 let mut threshold__ = None;
                 let mut veto_threshold__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Quorum => {
                             if quorum__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("quorum"));
                             }
-                            quorum__ = Some(map.next_value()?);
+                            quorum__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Threshold => {
                             if threshold__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("threshold"));
                             }
-                            threshold__ = Some(map.next_value()?);
+                            threshold__ = Some(map_.next_value()?);
                         }
                         GeneratedField::VetoThreshold => {
                             if veto_threshold__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("vetoThreshold"));
                             }
-                            veto_threshold__ = Some(map.next_value()?);
+                            veto_threshold__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -4283,7 +4294,7 @@ impl<'de> serde::Deserialize<'de> for TallyResult {
                 formatter.write_str("struct cosmos.gov.v1.TallyResult")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<TallyResult, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<TallyResult, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -4291,31 +4302,31 @@ impl<'de> serde::Deserialize<'de> for TallyResult {
                 let mut abstain_count__ = None;
                 let mut no_count__ = None;
                 let mut no_with_veto_count__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::YesCount => {
                             if yes_count__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("yesCount"));
                             }
-                            yes_count__ = Some(map.next_value()?);
+                            yes_count__ = Some(map_.next_value()?);
                         }
                         GeneratedField::AbstainCount => {
                             if abstain_count__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("abstainCount"));
                             }
-                            abstain_count__ = Some(map.next_value()?);
+                            abstain_count__ = Some(map_.next_value()?);
                         }
                         GeneratedField::NoCount => {
                             if no_count__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("noCount"));
                             }
-                            no_count__ = Some(map.next_value()?);
+                            no_count__ = Some(map_.next_value()?);
                         }
                         GeneratedField::NoWithVetoCount => {
                             if no_with_veto_count__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("noWithVetoCount"));
                             }
-                            no_with_veto_count__ = Some(map.next_value()?);
+                            no_with_veto_count__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -4352,6 +4363,7 @@ impl serde::Serialize for Vote {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.v1.Vote", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proposalId", ::alloc::string::ToString::to_string(&self.proposal_id).as_str())?;
         }
         if true {
@@ -4426,7 +4438,7 @@ impl<'de> serde::Deserialize<'de> for Vote {
                 formatter.write_str("struct cosmos.gov.v1.Vote")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Vote, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Vote, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -4434,33 +4446,33 @@ impl<'de> serde::Deserialize<'de> for Vote {
                 let mut voter__ = None;
                 let mut options__ = None;
                 let mut metadata__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ProposalId => {
                             if proposal_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposalId"));
                             }
                             proposal_id__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Voter => {
                             if voter__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("voter"));
                             }
-                            voter__ = Some(map.next_value()?);
+                            voter__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Options => {
                             if options__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("options"));
                             }
-                            options__ = Some(map.next_value()?);
+                            options__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Metadata => {
                             if metadata__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("metadata"));
                             }
-                            metadata__ = Some(map.next_value()?);
+                            metadata__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -4518,10 +4530,9 @@ impl<'de> serde::Deserialize<'de> for VoteOption {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(VoteOption::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -4531,10 +4542,9 @@ impl<'de> serde::Deserialize<'de> for VoteOption {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(VoteOption::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
@@ -4626,18 +4636,18 @@ impl<'de> serde::Deserialize<'de> for VotingParams {
                 formatter.write_str("struct cosmos.gov.v1.VotingParams")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<VotingParams, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<VotingParams, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut voting_period__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::VotingPeriod => {
                             if voting_period__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("votingPeriod"));
                             }
-                            voting_period__ = map.next_value()?;
+                            voting_period__ = map_.next_value()?;
                         }
                     }
                 }
@@ -4665,8 +4675,8 @@ impl serde::Serialize for WeightedVoteOption {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.v1.WeightedVoteOption", len)?;
         if true {
-            let v = VoteOption::from_i32(self.option)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.option)))?;
+            let v = VoteOption::try_from(self.option)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.option)))?;
             struct_ser.serialize_field("option", &v)?;
         }
         if true {
@@ -4728,25 +4738,25 @@ impl<'de> serde::Deserialize<'de> for WeightedVoteOption {
                 formatter.write_str("struct cosmos.gov.v1.WeightedVoteOption")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<WeightedVoteOption, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<WeightedVoteOption, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut option__ = None;
                 let mut weight__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Option => {
                             if option__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("option"));
                             }
-                            option__ = Some(map.next_value::<VoteOption>()? as i32);
+                            option__ = Some(map_.next_value::<VoteOption>()? as i32);
                         }
                         GeneratedField::Weight => {
                             if weight__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("weight"));
                             }
-                            weight__ = Some(map.next_value()?);
+                            weight__ = Some(map_.next_value()?);
                         }
                     }
                 }
diff --git a/src/prost/cosmos.gov.v1beta1.serde.rs b/src/prost/cosmos.gov.v1beta1.serde.rs
index 5ed64cf5..1e738333 100644
--- a/src/prost/cosmos.gov.v1beta1.serde.rs
+++ b/src/prost/cosmos.gov.v1beta1.serde.rs
@@ -17,6 +17,7 @@ impl serde::Serialize for Deposit {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.v1beta1.Deposit", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proposalId", ::alloc::string::ToString::to_string(&self.proposal_id).as_str())?;
         }
         if true {
@@ -85,34 +86,34 @@ impl<'de> serde::Deserialize<'de> for Deposit {
                 formatter.write_str("struct cosmos.gov.v1beta1.Deposit")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Deposit, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Deposit, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut proposal_id__ = None;
                 let mut depositor__ = None;
                 let mut amount__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ProposalId => {
                             if proposal_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposalId"));
                             }
                             proposal_id__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Depositor => {
                             if depositor__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("depositor"));
                             }
-                            depositor__ = Some(map.next_value()?);
+                            depositor__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Amount => {
                             if amount__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("amount"));
                             }
-                            amount__ = Some(map.next_value()?);
+                            amount__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -205,25 +206,25 @@ impl<'de> serde::Deserialize<'de> for DepositParams {
                 formatter.write_str("struct cosmos.gov.v1beta1.DepositParams")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<DepositParams, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<DepositParams, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut min_deposit__ = None;
                 let mut max_deposit_period__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::MinDeposit => {
                             if min_deposit__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("minDeposit"));
                             }
-                            min_deposit__ = Some(map.next_value()?);
+                            min_deposit__ = Some(map_.next_value()?);
                         }
                         GeneratedField::MaxDepositPeriod => {
                             if max_deposit_period__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("maxDepositPeriod"));
                             }
-                            max_deposit_period__ = map.next_value()?;
+                            max_deposit_period__ = map_.next_value()?;
                         }
                     }
                 }
@@ -267,6 +268,7 @@ impl serde::Serialize for GenesisState {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.v1beta1.GenesisState", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("startingProposalId", ::alloc::string::ToString::to_string(&self.starting_proposal_id).as_str())?;
         }
         if true {
@@ -362,7 +364,7 @@ impl<'de> serde::Deserialize<'de> for GenesisState {
                 formatter.write_str("struct cosmos.gov.v1beta1.GenesisState")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<GenesisState, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<GenesisState, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -373,51 +375,51 @@ impl<'de> serde::Deserialize<'de> for GenesisState {
                 let mut deposit_params__ = None;
                 let mut voting_params__ = None;
                 let mut tally_params__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::StartingProposalId => {
                             if starting_proposal_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("startingProposalId"));
                             }
                             starting_proposal_id__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Deposits => {
                             if deposits__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("deposits"));
                             }
-                            deposits__ = Some(map.next_value()?);
+                            deposits__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Votes => {
                             if votes__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("votes"));
                             }
-                            votes__ = Some(map.next_value()?);
+                            votes__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Proposals => {
                             if proposals__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposals"));
                             }
-                            proposals__ = Some(map.next_value()?);
+                            proposals__ = Some(map_.next_value()?);
                         }
                         GeneratedField::DepositParams => {
                             if deposit_params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("depositParams"));
                             }
-                            deposit_params__ = map.next_value()?;
+                            deposit_params__ = map_.next_value()?;
                         }
                         GeneratedField::VotingParams => {
                             if voting_params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("votingParams"));
                             }
-                            voting_params__ = map.next_value()?;
+                            voting_params__ = map_.next_value()?;
                         }
                         GeneratedField::TallyParams => {
                             if tally_params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("tallyParams"));
                             }
-                            tally_params__ = map.next_value()?;
+                            tally_params__ = map_.next_value()?;
                         }
                     }
                 }
@@ -454,6 +456,7 @@ impl serde::Serialize for MsgDeposit {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.v1beta1.MsgDeposit", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proposalId", ::alloc::string::ToString::to_string(&self.proposal_id).as_str())?;
         }
         if true {
@@ -522,34 +525,34 @@ impl<'de> serde::Deserialize<'de> for MsgDeposit {
                 formatter.write_str("struct cosmos.gov.v1beta1.MsgDeposit")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgDeposit, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgDeposit, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut proposal_id__ = None;
                 let mut depositor__ = None;
                 let mut amount__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ProposalId => {
                             if proposal_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposalId"));
                             }
                             proposal_id__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Depositor => {
                             if depositor__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("depositor"));
                             }
-                            depositor__ = Some(map.next_value()?);
+                            depositor__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Amount => {
                             if amount__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("amount"));
                             }
-                            amount__ = Some(map.next_value()?);
+                            amount__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -620,12 +623,12 @@ impl<'de> serde::Deserialize<'de> for MsgDepositResponse {
                 formatter.write_str("struct cosmos.gov.v1beta1.MsgDepositResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgDepositResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgDepositResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgDepositResponse {
                 })
@@ -721,32 +724,32 @@ impl<'de> serde::Deserialize<'de> for MsgSubmitProposal {
                 formatter.write_str("struct cosmos.gov.v1beta1.MsgSubmitProposal")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgSubmitProposal, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgSubmitProposal, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut content__ = None;
                 let mut initial_deposit__ = None;
                 let mut proposer__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Content => {
                             if content__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("content"));
                             }
-                            content__ = map.next_value()?;
+                            content__ = map_.next_value()?;
                         }
                         GeneratedField::InitialDeposit => {
                             if initial_deposit__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("initialDeposit"));
                             }
-                            initial_deposit__ = Some(map.next_value()?);
+                            initial_deposit__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Proposer => {
                             if proposer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposer"));
                             }
-                            proposer__ = Some(map.next_value()?);
+                            proposer__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -773,6 +776,7 @@ impl serde::Serialize for MsgSubmitProposalResponse {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.v1beta1.MsgSubmitProposalResponse", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proposalId", ::alloc::string::ToString::to_string(&self.proposal_id).as_str())?;
         }
         struct_ser.end()
@@ -829,19 +833,19 @@ impl<'de> serde::Deserialize<'de> for MsgSubmitProposalResponse {
                 formatter.write_str("struct cosmos.gov.v1beta1.MsgSubmitProposalResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgSubmitProposalResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgSubmitProposalResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut proposal_id__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ProposalId => {
                             if proposal_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposalId"));
                             }
                             proposal_id__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -873,14 +877,15 @@ impl serde::Serialize for MsgVote {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.v1beta1.MsgVote", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proposalId", ::alloc::string::ToString::to_string(&self.proposal_id).as_str())?;
         }
         if true {
             struct_ser.serialize_field("voter", &self.voter)?;
         }
         if true {
-            let v = VoteOption::from_i32(self.option)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.option)))?;
+            let v = VoteOption::try_from(self.option)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.option)))?;
             struct_ser.serialize_field("option", &v)?;
         }
         struct_ser.end()
@@ -943,34 +948,34 @@ impl<'de> serde::Deserialize<'de> for MsgVote {
                 formatter.write_str("struct cosmos.gov.v1beta1.MsgVote")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgVote, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgVote, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut proposal_id__ = None;
                 let mut voter__ = None;
                 let mut option__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ProposalId => {
                             if proposal_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposalId"));
                             }
                             proposal_id__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Voter => {
                             if voter__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("voter"));
                             }
-                            voter__ = Some(map.next_value()?);
+                            voter__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Option => {
                             if option__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("option"));
                             }
-                            option__ = Some(map.next_value::<VoteOption>()? as i32);
+                            option__ = Some(map_.next_value::<VoteOption>()? as i32);
                         }
                     }
                 }
@@ -1041,12 +1046,12 @@ impl<'de> serde::Deserialize<'de> for MsgVoteResponse {
                 formatter.write_str("struct cosmos.gov.v1beta1.MsgVoteResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgVoteResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgVoteResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgVoteResponse {
                 })
@@ -1074,6 +1079,7 @@ impl serde::Serialize for MsgVoteWeighted {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.v1beta1.MsgVoteWeighted", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proposalId", ::alloc::string::ToString::to_string(&self.proposal_id).as_str())?;
         }
         if true {
@@ -1142,34 +1148,34 @@ impl<'de> serde::Deserialize<'de> for MsgVoteWeighted {
                 formatter.write_str("struct cosmos.gov.v1beta1.MsgVoteWeighted")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgVoteWeighted, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgVoteWeighted, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut proposal_id__ = None;
                 let mut voter__ = None;
                 let mut options__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ProposalId => {
                             if proposal_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposalId"));
                             }
                             proposal_id__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Voter => {
                             if voter__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("voter"));
                             }
-                            voter__ = Some(map.next_value()?);
+                            voter__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Options => {
                             if options__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("options"));
                             }
-                            options__ = Some(map.next_value()?);
+                            options__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1240,12 +1246,12 @@ impl<'de> serde::Deserialize<'de> for MsgVoteWeightedResponse {
                 formatter.write_str("struct cosmos.gov.v1beta1.MsgVoteWeightedResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgVoteWeightedResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgVoteWeightedResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgVoteWeightedResponse {
                 })
@@ -1291,14 +1297,15 @@ impl serde::Serialize for Proposal {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.v1beta1.Proposal", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proposalId", ::alloc::string::ToString::to_string(&self.proposal_id).as_str())?;
         }
         if let Some(v) = self.content.as_ref() {
             struct_ser.serialize_field("content", v)?;
         }
         if true {
-            let v = ProposalStatus::from_i32(self.status)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.status)))?;
+            let v = ProposalStatus::try_from(self.status)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.status)))?;
             struct_ser.serialize_field("status", &v)?;
         }
         if let Some(v) = self.final_tally_result.as_ref() {
@@ -1403,7 +1410,7 @@ impl<'de> serde::Deserialize<'de> for Proposal {
                 formatter.write_str("struct cosmos.gov.v1beta1.Proposal")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Proposal, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Proposal, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -1416,63 +1423,63 @@ impl<'de> serde::Deserialize<'de> for Proposal {
                 let mut total_deposit__ = None;
                 let mut voting_start_time__ = None;
                 let mut voting_end_time__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ProposalId => {
                             if proposal_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposalId"));
                             }
                             proposal_id__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Content => {
                             if content__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("content"));
                             }
-                            content__ = map.next_value()?;
+                            content__ = map_.next_value()?;
                         }
                         GeneratedField::Status => {
                             if status__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("status"));
                             }
-                            status__ = Some(map.next_value::<ProposalStatus>()? as i32);
+                            status__ = Some(map_.next_value::<ProposalStatus>()? as i32);
                         }
                         GeneratedField::FinalTallyResult => {
                             if final_tally_result__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("finalTallyResult"));
                             }
-                            final_tally_result__ = map.next_value()?;
+                            final_tally_result__ = map_.next_value()?;
                         }
                         GeneratedField::SubmitTime => {
                             if submit_time__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("submitTime"));
                             }
-                            submit_time__ = map.next_value()?;
+                            submit_time__ = map_.next_value()?;
                         }
                         GeneratedField::DepositEndTime => {
                             if deposit_end_time__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("depositEndTime"));
                             }
-                            deposit_end_time__ = map.next_value()?;
+                            deposit_end_time__ = map_.next_value()?;
                         }
                         GeneratedField::TotalDeposit => {
                             if total_deposit__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("totalDeposit"));
                             }
-                            total_deposit__ = Some(map.next_value()?);
+                            total_deposit__ = Some(map_.next_value()?);
                         }
                         GeneratedField::VotingStartTime => {
                             if voting_start_time__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("votingStartTime"));
                             }
-                            voting_start_time__ = map.next_value()?;
+                            voting_start_time__ = map_.next_value()?;
                         }
                         GeneratedField::VotingEndTime => {
                             if voting_end_time__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("votingEndTime"));
                             }
-                            voting_end_time__ = map.next_value()?;
+                            voting_end_time__ = map_.next_value()?;
                         }
                     }
                 }
@@ -1537,10 +1544,9 @@ impl<'de> serde::Deserialize<'de> for ProposalStatus {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(ProposalStatus::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -1550,10 +1556,9 @@ impl<'de> serde::Deserialize<'de> for ProposalStatus {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(ProposalStatus::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
@@ -1593,6 +1598,7 @@ impl serde::Serialize for QueryDepositRequest {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.v1beta1.QueryDepositRequest", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proposalId", ::alloc::string::ToString::to_string(&self.proposal_id).as_str())?;
         }
         if true {
@@ -1655,27 +1661,27 @@ impl<'de> serde::Deserialize<'de> for QueryDepositRequest {
                 formatter.write_str("struct cosmos.gov.v1beta1.QueryDepositRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryDepositRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryDepositRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut proposal_id__ = None;
                 let mut depositor__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ProposalId => {
                             if proposal_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposalId"));
                             }
                             proposal_id__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Depositor => {
                             if depositor__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("depositor"));
                             }
-                            depositor__ = Some(map.next_value()?);
+                            depositor__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1756,18 +1762,18 @@ impl<'de> serde::Deserialize<'de> for QueryDepositResponse {
                 formatter.write_str("struct cosmos.gov.v1beta1.QueryDepositResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryDepositResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryDepositResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut deposit__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Deposit => {
                             if deposit__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("deposit"));
                             }
-                            deposit__ = map.next_value()?;
+                            deposit__ = map_.next_value()?;
                         }
                     }
                 }
@@ -1795,6 +1801,7 @@ impl serde::Serialize for QueryDepositsRequest {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.v1beta1.QueryDepositsRequest", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proposalId", ::alloc::string::ToString::to_string(&self.proposal_id).as_str())?;
         }
         if let Some(v) = self.pagination.as_ref() {
@@ -1857,27 +1864,27 @@ impl<'de> serde::Deserialize<'de> for QueryDepositsRequest {
                 formatter.write_str("struct cosmos.gov.v1beta1.QueryDepositsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryDepositsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryDepositsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut proposal_id__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ProposalId => {
                             if proposal_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposalId"));
                             }
                             proposal_id__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -1967,25 +1974,25 @@ impl<'de> serde::Deserialize<'de> for QueryDepositsResponse {
                 formatter.write_str("struct cosmos.gov.v1beta1.QueryDepositsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryDepositsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryDepositsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut deposits__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Deposits => {
                             if deposits__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("deposits"));
                             }
-                            deposits__ = Some(map.next_value()?);
+                            deposits__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2067,18 +2074,18 @@ impl<'de> serde::Deserialize<'de> for QueryParamsRequest {
                 formatter.write_str("struct cosmos.gov.v1beta1.QueryParamsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryParamsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryParamsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut params_type__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ParamsType => {
                             if params_type__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("paramsType"));
                             }
-                            params_type__ = Some(map.next_value()?);
+                            params_type__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -2179,32 +2186,32 @@ impl<'de> serde::Deserialize<'de> for QueryParamsResponse {
                 formatter.write_str("struct cosmos.gov.v1beta1.QueryParamsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryParamsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryParamsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut voting_params__ = None;
                 let mut deposit_params__ = None;
                 let mut tally_params__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::VotingParams => {
                             if voting_params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("votingParams"));
                             }
-                            voting_params__ = map.next_value()?;
+                            voting_params__ = map_.next_value()?;
                         }
                         GeneratedField::DepositParams => {
                             if deposit_params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("depositParams"));
                             }
-                            deposit_params__ = map.next_value()?;
+                            deposit_params__ = map_.next_value()?;
                         }
                         GeneratedField::TallyParams => {
                             if tally_params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("tallyParams"));
                             }
-                            tally_params__ = map.next_value()?;
+                            tally_params__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2231,6 +2238,7 @@ impl serde::Serialize for QueryProposalRequest {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.v1beta1.QueryProposalRequest", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proposalId", ::alloc::string::ToString::to_string(&self.proposal_id).as_str())?;
         }
         struct_ser.end()
@@ -2287,19 +2295,19 @@ impl<'de> serde::Deserialize<'de> for QueryProposalRequest {
                 formatter.write_str("struct cosmos.gov.v1beta1.QueryProposalRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryProposalRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryProposalRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut proposal_id__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ProposalId => {
                             if proposal_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposalId"));
                             }
                             proposal_id__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -2380,18 +2388,18 @@ impl<'de> serde::Deserialize<'de> for QueryProposalResponse {
                 formatter.write_str("struct cosmos.gov.v1beta1.QueryProposalResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryProposalResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryProposalResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut proposal__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Proposal => {
                             if proposal__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposal"));
                             }
-                            proposal__ = map.next_value()?;
+                            proposal__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2425,8 +2433,8 @@ impl serde::Serialize for QueryProposalsRequest {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.v1beta1.QueryProposalsRequest", len)?;
         if true {
-            let v = ProposalStatus::from_i32(self.proposal_status)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.proposal_status)))?;
+            let v = ProposalStatus::try_from(self.proposal_status)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.proposal_status)))?;
             struct_ser.serialize_field("proposalStatus", &v)?;
         }
         if true {
@@ -2501,7 +2509,7 @@ impl<'de> serde::Deserialize<'de> for QueryProposalsRequest {
                 formatter.write_str("struct cosmos.gov.v1beta1.QueryProposalsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryProposalsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryProposalsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -2509,31 +2517,31 @@ impl<'de> serde::Deserialize<'de> for QueryProposalsRequest {
                 let mut voter__ = None;
                 let mut depositor__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ProposalStatus => {
                             if proposal_status__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposalStatus"));
                             }
-                            proposal_status__ = Some(map.next_value::<ProposalStatus>()? as i32);
+                            proposal_status__ = Some(map_.next_value::<ProposalStatus>()? as i32);
                         }
                         GeneratedField::Voter => {
                             if voter__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("voter"));
                             }
-                            voter__ = Some(map.next_value()?);
+                            voter__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Depositor => {
                             if depositor__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("depositor"));
                             }
-                            depositor__ = Some(map.next_value()?);
+                            depositor__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2625,25 +2633,25 @@ impl<'de> serde::Deserialize<'de> for QueryProposalsResponse {
                 formatter.write_str("struct cosmos.gov.v1beta1.QueryProposalsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryProposalsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryProposalsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut proposals__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Proposals => {
                             if proposals__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposals"));
                             }
-                            proposals__ = Some(map.next_value()?);
+                            proposals__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2669,6 +2677,7 @@ impl serde::Serialize for QueryTallyResultRequest {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.v1beta1.QueryTallyResultRequest", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proposalId", ::alloc::string::ToString::to_string(&self.proposal_id).as_str())?;
         }
         struct_ser.end()
@@ -2725,19 +2734,19 @@ impl<'de> serde::Deserialize<'de> for QueryTallyResultRequest {
                 formatter.write_str("struct cosmos.gov.v1beta1.QueryTallyResultRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryTallyResultRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryTallyResultRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut proposal_id__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ProposalId => {
                             if proposal_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposalId"));
                             }
                             proposal_id__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -2818,18 +2827,18 @@ impl<'de> serde::Deserialize<'de> for QueryTallyResultResponse {
                 formatter.write_str("struct cosmos.gov.v1beta1.QueryTallyResultResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryTallyResultResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryTallyResultResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut tally__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Tally => {
                             if tally__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("tally"));
                             }
-                            tally__ = map.next_value()?;
+                            tally__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2857,6 +2866,7 @@ impl serde::Serialize for QueryVoteRequest {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.v1beta1.QueryVoteRequest", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proposalId", ::alloc::string::ToString::to_string(&self.proposal_id).as_str())?;
         }
         if true {
@@ -2919,27 +2929,27 @@ impl<'de> serde::Deserialize<'de> for QueryVoteRequest {
                 formatter.write_str("struct cosmos.gov.v1beta1.QueryVoteRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryVoteRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryVoteRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut proposal_id__ = None;
                 let mut voter__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ProposalId => {
                             if proposal_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposalId"));
                             }
                             proposal_id__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Voter => {
                             if voter__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("voter"));
                             }
-                            voter__ = Some(map.next_value()?);
+                            voter__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -3020,18 +3030,18 @@ impl<'de> serde::Deserialize<'de> for QueryVoteResponse {
                 formatter.write_str("struct cosmos.gov.v1beta1.QueryVoteResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryVoteResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryVoteResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut vote__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Vote => {
                             if vote__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("vote"));
                             }
-                            vote__ = map.next_value()?;
+                            vote__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3059,6 +3069,7 @@ impl serde::Serialize for QueryVotesRequest {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.v1beta1.QueryVotesRequest", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proposalId", ::alloc::string::ToString::to_string(&self.proposal_id).as_str())?;
         }
         if let Some(v) = self.pagination.as_ref() {
@@ -3121,27 +3132,27 @@ impl<'de> serde::Deserialize<'de> for QueryVotesRequest {
                 formatter.write_str("struct cosmos.gov.v1beta1.QueryVotesRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryVotesRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryVotesRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut proposal_id__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ProposalId => {
                             if proposal_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposalId"));
                             }
                             proposal_id__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3231,25 +3242,25 @@ impl<'de> serde::Deserialize<'de> for QueryVotesResponse {
                 formatter.write_str("struct cosmos.gov.v1beta1.QueryVotesResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryVotesResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryVotesResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut votes__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Votes => {
                             if votes__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("votes"));
                             }
-                            votes__ = Some(map.next_value()?);
+                            votes__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3281,12 +3292,15 @@ impl serde::Serialize for TallyParams {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.v1beta1.TallyParams", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("quorum", pbjson::private::base64::encode(&self.quorum).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("threshold", pbjson::private::base64::encode(&self.threshold).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("vetoThreshold", pbjson::private::base64::encode(&self.veto_threshold).as_str())?;
         }
         struct_ser.end()
@@ -3349,21 +3363,21 @@ impl<'de> serde::Deserialize<'de> for TallyParams {
                 formatter.write_str("struct cosmos.gov.v1beta1.TallyParams")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<TallyParams, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<TallyParams, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut quorum__ = None;
                 let mut threshold__ = None;
                 let mut veto_threshold__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Quorum => {
                             if quorum__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("quorum"));
                             }
                             quorum__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Threshold => {
@@ -3371,7 +3385,7 @@ impl<'de> serde::Deserialize<'de> for TallyParams {
                                 return Err(serde::de::Error::duplicate_field("threshold"));
                             }
                             threshold__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::VetoThreshold => {
@@ -3379,7 +3393,7 @@ impl<'de> serde::Deserialize<'de> for TallyParams {
                                 return Err(serde::de::Error::duplicate_field("vetoThreshold"));
                             }
                             veto_threshold__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -3490,7 +3504,7 @@ impl<'de> serde::Deserialize<'de> for TallyResult {
                 formatter.write_str("struct cosmos.gov.v1beta1.TallyResult")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<TallyResult, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<TallyResult, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -3498,31 +3512,31 @@ impl<'de> serde::Deserialize<'de> for TallyResult {
                 let mut abstain__ = None;
                 let mut no__ = None;
                 let mut no_with_veto__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Yes => {
                             if yes__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("yes"));
                             }
-                            yes__ = Some(map.next_value()?);
+                            yes__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Abstain => {
                             if abstain__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("abstain"));
                             }
-                            abstain__ = Some(map.next_value()?);
+                            abstain__ = Some(map_.next_value()?);
                         }
                         GeneratedField::No => {
                             if no__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("no"));
                             }
-                            no__ = Some(map.next_value()?);
+                            no__ = Some(map_.next_value()?);
                         }
                         GeneratedField::NoWithVeto => {
                             if no_with_veto__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("noWithVeto"));
                             }
-                            no_with_veto__ = Some(map.next_value()?);
+                            no_with_veto__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -3614,25 +3628,25 @@ impl<'de> serde::Deserialize<'de> for TextProposal {
                 formatter.write_str("struct cosmos.gov.v1beta1.TextProposal")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<TextProposal, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<TextProposal, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut title__ = None;
                 let mut description__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Title => {
                             if title__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("title"));
                             }
-                            title__ = Some(map.next_value()?);
+                            title__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Description => {
                             if description__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("description"));
                             }
-                            description__ = Some(map.next_value()?);
+                            description__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -3667,14 +3681,15 @@ impl serde::Serialize for Vote {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.v1beta1.Vote", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proposalId", ::alloc::string::ToString::to_string(&self.proposal_id).as_str())?;
         }
         if true {
             struct_ser.serialize_field("voter", &self.voter)?;
         }
         if true {
-            let v = VoteOption::from_i32(self.option)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.option)))?;
+            let v = VoteOption::try_from(self.option)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.option)))?;
             struct_ser.serialize_field("option", &v)?;
         }
         if true {
@@ -3743,7 +3758,7 @@ impl<'de> serde::Deserialize<'de> for Vote {
                 formatter.write_str("struct cosmos.gov.v1beta1.Vote")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Vote, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Vote, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -3751,33 +3766,33 @@ impl<'de> serde::Deserialize<'de> for Vote {
                 let mut voter__ = None;
                 let mut option__ = None;
                 let mut options__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ProposalId => {
                             if proposal_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proposalId"));
                             }
                             proposal_id__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Voter => {
                             if voter__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("voter"));
                             }
-                            voter__ = Some(map.next_value()?);
+                            voter__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Option => {
                             if option__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("option"));
                             }
-                            option__ = Some(map.next_value::<VoteOption>()? as i32);
+                            option__ = Some(map_.next_value::<VoteOption>()? as i32);
                         }
                         GeneratedField::Options => {
                             if options__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("options"));
                             }
-                            options__ = Some(map.next_value()?);
+                            options__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -3835,10 +3850,9 @@ impl<'de> serde::Deserialize<'de> for VoteOption {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(VoteOption::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -3848,10 +3862,9 @@ impl<'de> serde::Deserialize<'de> for VoteOption {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(VoteOption::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
@@ -3943,18 +3956,18 @@ impl<'de> serde::Deserialize<'de> for VotingParams {
                 formatter.write_str("struct cosmos.gov.v1beta1.VotingParams")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<VotingParams, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<VotingParams, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut voting_period__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::VotingPeriod => {
                             if voting_period__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("votingPeriod"));
                             }
-                            voting_period__ = map.next_value()?;
+                            voting_period__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3982,8 +3995,8 @@ impl serde::Serialize for WeightedVoteOption {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.gov.v1beta1.WeightedVoteOption", len)?;
         if true {
-            let v = VoteOption::from_i32(self.option)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.option)))?;
+            let v = VoteOption::try_from(self.option)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.option)))?;
             struct_ser.serialize_field("option", &v)?;
         }
         if true {
@@ -4045,25 +4058,25 @@ impl<'de> serde::Deserialize<'de> for WeightedVoteOption {
                 formatter.write_str("struct cosmos.gov.v1beta1.WeightedVoteOption")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<WeightedVoteOption, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<WeightedVoteOption, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut option__ = None;
                 let mut weight__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Option => {
                             if option__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("option"));
                             }
-                            option__ = Some(map.next_value::<VoteOption>()? as i32);
+                            option__ = Some(map_.next_value::<VoteOption>()? as i32);
                         }
                         GeneratedField::Weight => {
                             if weight__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("weight"));
                             }
-                            weight__ = Some(map.next_value()?);
+                            weight__ = Some(map_.next_value()?);
                         }
                     }
                 }
diff --git a/src/prost/cosmos.ics23.v1.serde.rs b/src/prost/cosmos.ics23.v1.serde.rs
index 283820a8..776025f5 100644
--- a/src/prost/cosmos.ics23.v1.serde.rs
+++ b/src/prost/cosmos.ics23.v1.serde.rs
@@ -76,25 +76,25 @@ impl<'de> serde::Deserialize<'de> for BatchEntry {
                 formatter.write_str("struct cosmos.ics23.v1.BatchEntry")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<BatchEntry, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<BatchEntry, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut proof__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Exist => {
                             if proof__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("exist"));
                             }
-                            proof__ = map.next_value::<::core::option::Option<_>>()?.map(batch_entry::Proof::Exist)
+                            proof__ = map_.next_value::<::core::option::Option<_>>()?.map(batch_entry::Proof::Exist)
 ;
                         }
                         GeneratedField::Nonexist => {
                             if proof__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("nonexist"));
                             }
-                            proof__ = map.next_value::<::core::option::Option<_>>()?.map(batch_entry::Proof::Nonexist)
+                            proof__ = map_.next_value::<::core::option::Option<_>>()?.map(batch_entry::Proof::Nonexist)
 ;
                         }
                     }
@@ -175,18 +175,18 @@ impl<'de> serde::Deserialize<'de> for BatchProof {
                 formatter.write_str("struct cosmos.ics23.v1.BatchProof")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<BatchProof, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<BatchProof, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut entries__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Entries => {
                             if entries__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("entries"));
                             }
-                            entries__ = Some(map.next_value()?);
+                            entries__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -288,39 +288,39 @@ impl<'de> serde::Deserialize<'de> for CommitmentProof {
                 formatter.write_str("struct cosmos.ics23.v1.CommitmentProof")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<CommitmentProof, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<CommitmentProof, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut proof__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Exist => {
                             if proof__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("exist"));
                             }
-                            proof__ = map.next_value::<::core::option::Option<_>>()?.map(commitment_proof::Proof::Exist)
+                            proof__ = map_.next_value::<::core::option::Option<_>>()?.map(commitment_proof::Proof::Exist)
 ;
                         }
                         GeneratedField::Nonexist => {
                             if proof__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("nonexist"));
                             }
-                            proof__ = map.next_value::<::core::option::Option<_>>()?.map(commitment_proof::Proof::Nonexist)
+                            proof__ = map_.next_value::<::core::option::Option<_>>()?.map(commitment_proof::Proof::Nonexist)
 ;
                         }
                         GeneratedField::Batch => {
                             if proof__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("batch"));
                             }
-                            proof__ = map.next_value::<::core::option::Option<_>>()?.map(commitment_proof::Proof::Batch)
+                            proof__ = map_.next_value::<::core::option::Option<_>>()?.map(commitment_proof::Proof::Batch)
 ;
                         }
                         GeneratedField::Compressed => {
                             if proof__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("compressed"));
                             }
-                            proof__ = map.next_value::<::core::option::Option<_>>()?.map(commitment_proof::Proof::Compressed)
+                            proof__ = map_.next_value::<::core::option::Option<_>>()?.map(commitment_proof::Proof::Compressed)
 ;
                         }
                     }
@@ -411,25 +411,25 @@ impl<'de> serde::Deserialize<'de> for CompressedBatchEntry {
                 formatter.write_str("struct cosmos.ics23.v1.CompressedBatchEntry")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<CompressedBatchEntry, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<CompressedBatchEntry, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut proof__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Exist => {
                             if proof__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("exist"));
                             }
-                            proof__ = map.next_value::<::core::option::Option<_>>()?.map(compressed_batch_entry::Proof::Exist)
+                            proof__ = map_.next_value::<::core::option::Option<_>>()?.map(compressed_batch_entry::Proof::Exist)
 ;
                         }
                         GeneratedField::Nonexist => {
                             if proof__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("nonexist"));
                             }
-                            proof__ = map.next_value::<::core::option::Option<_>>()?.map(compressed_batch_entry::Proof::Nonexist)
+                            proof__ = map_.next_value::<::core::option::Option<_>>()?.map(compressed_batch_entry::Proof::Nonexist)
 ;
                         }
                     }
@@ -520,25 +520,25 @@ impl<'de> serde::Deserialize<'de> for CompressedBatchProof {
                 formatter.write_str("struct cosmos.ics23.v1.CompressedBatchProof")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<CompressedBatchProof, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<CompressedBatchProof, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut entries__ = None;
                 let mut lookup_inners__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Entries => {
                             if entries__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("entries"));
                             }
-                            entries__ = Some(map.next_value()?);
+                            entries__ = Some(map_.next_value()?);
                         }
                         GeneratedField::LookupInners => {
                             if lookup_inners__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("lookupInners"));
                             }
-                            lookup_inners__ = Some(map.next_value()?);
+                            lookup_inners__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -573,9 +573,11 @@ impl serde::Serialize for CompressedExistenceProof {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.ics23.v1.CompressedExistenceProof", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("key", pbjson::private::base64::encode(&self.key).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
         }
         if let Some(v) = self.leaf.as_ref() {
@@ -646,7 +648,7 @@ impl<'de> serde::Deserialize<'de> for CompressedExistenceProof {
                 formatter.write_str("struct cosmos.ics23.v1.CompressedExistenceProof")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<CompressedExistenceProof, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<CompressedExistenceProof, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -654,14 +656,14 @@ impl<'de> serde::Deserialize<'de> for CompressedExistenceProof {
                 let mut value__ = None;
                 let mut leaf__ = None;
                 let mut path__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Key => {
                             if key__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("key"));
                             }
                             key__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Value => {
@@ -669,21 +671,21 @@ impl<'de> serde::Deserialize<'de> for CompressedExistenceProof {
                                 return Err(serde::de::Error::duplicate_field("value"));
                             }
                             value__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Leaf => {
                             if leaf__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("leaf"));
                             }
-                            leaf__ = map.next_value()?;
+                            leaf__ = map_.next_value()?;
                         }
                         GeneratedField::Path => {
                             if path__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("path"));
                             }
                             path__ = 
-                                Some(map.next_value::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()?
+                                Some(map_.next_value::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()?
                                     .into_iter().map(|x| x.0).collect())
                             ;
                         }
@@ -719,6 +721,7 @@ impl serde::Serialize for CompressedNonExistenceProof {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.ics23.v1.CompressedNonExistenceProof", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("key", pbjson::private::base64::encode(&self.key).as_str())?;
         }
         if let Some(v) = self.left.as_ref() {
@@ -786,34 +789,34 @@ impl<'de> serde::Deserialize<'de> for CompressedNonExistenceProof {
                 formatter.write_str("struct cosmos.ics23.v1.CompressedNonExistenceProof")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<CompressedNonExistenceProof, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<CompressedNonExistenceProof, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut key__ = None;
                 let mut left__ = None;
                 let mut right__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Key => {
                             if key__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("key"));
                             }
                             key__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Left => {
                             if left__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("left"));
                             }
-                            left__ = map.next_value()?;
+                            left__ = map_.next_value()?;
                         }
                         GeneratedField::Right => {
                             if right__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("right"));
                             }
-                            right__ = map.next_value()?;
+                            right__ = map_.next_value()?;
                         }
                     }
                 }
@@ -849,9 +852,11 @@ impl serde::Serialize for ExistenceProof {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.ics23.v1.ExistenceProof", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("key", pbjson::private::base64::encode(&self.key).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
         }
         if let Some(v) = self.leaf.as_ref() {
@@ -922,7 +927,7 @@ impl<'de> serde::Deserialize<'de> for ExistenceProof {
                 formatter.write_str("struct cosmos.ics23.v1.ExistenceProof")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ExistenceProof, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ExistenceProof, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -930,14 +935,14 @@ impl<'de> serde::Deserialize<'de> for ExistenceProof {
                 let mut value__ = None;
                 let mut leaf__ = None;
                 let mut path__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Key => {
                             if key__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("key"));
                             }
                             key__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Value => {
@@ -945,20 +950,20 @@ impl<'de> serde::Deserialize<'de> for ExistenceProof {
                                 return Err(serde::de::Error::duplicate_field("value"));
                             }
                             value__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Leaf => {
                             if leaf__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("leaf"));
                             }
-                            leaf__ = map.next_value()?;
+                            leaf__ = map_.next_value()?;
                         }
                         GeneratedField::Path => {
                             if path__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("path"));
                             }
-                            path__ = Some(map.next_value()?);
+                            path__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1020,10 +1025,9 @@ impl<'de> serde::Deserialize<'de> for HashOp {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(HashOp::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -1033,10 +1037,9 @@ impl<'de> serde::Deserialize<'de> for HashOp {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(HashOp::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
@@ -1080,14 +1083,16 @@ impl serde::Serialize for InnerOp {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.ics23.v1.InnerOp", len)?;
         if true {
-            let v = HashOp::from_i32(self.hash)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.hash)))?;
+            let v = HashOp::try_from(self.hash)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.hash)))?;
             struct_ser.serialize_field("hash", &v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("prefix", pbjson::private::base64::encode(&self.prefix).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("suffix", pbjson::private::base64::encode(&self.suffix).as_str())?;
         }
         struct_ser.end()
@@ -1149,27 +1154,27 @@ impl<'de> serde::Deserialize<'de> for InnerOp {
                 formatter.write_str("struct cosmos.ics23.v1.InnerOp")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<InnerOp, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<InnerOp, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut hash__ = None;
                 let mut prefix__ = None;
                 let mut suffix__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Hash => {
                             if hash__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("hash"));
                             }
-                            hash__ = Some(map.next_value::<HashOp>()? as i32);
+                            hash__ = Some(map_.next_value::<HashOp>()? as i32);
                         }
                         GeneratedField::Prefix => {
                             if prefix__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("prefix"));
                             }
                             prefix__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Suffix => {
@@ -1177,7 +1182,7 @@ impl<'de> serde::Deserialize<'de> for InnerOp {
                                 return Err(serde::de::Error::duplicate_field("suffix"));
                             }
                             suffix__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -1232,11 +1237,12 @@ impl serde::Serialize for InnerSpec {
             struct_ser.serialize_field("maxPrefixLength", &self.max_prefix_length)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("emptyChild", pbjson::private::base64::encode(&self.empty_child).as_str())?;
         }
         if true {
-            let v = HashOp::from_i32(self.hash)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.hash)))?;
+            let v = HashOp::try_from(self.hash)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.hash)))?;
             struct_ser.serialize_field("hash", &v)?;
         }
         struct_ser.end()
@@ -1312,7 +1318,7 @@ impl<'de> serde::Deserialize<'de> for InnerSpec {
                 formatter.write_str("struct cosmos.ics23.v1.InnerSpec")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<InnerSpec, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<InnerSpec, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -1322,14 +1328,14 @@ impl<'de> serde::Deserialize<'de> for InnerSpec {
                 let mut max_prefix_length__ = None;
                 let mut empty_child__ = None;
                 let mut hash__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ChildOrder => {
                             if child_order__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("childOrder"));
                             }
                             child_order__ = 
-                                Some(map.next_value::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()?
+                                Some(map_.next_value::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()?
                                     .into_iter().map(|x| x.0).collect())
                             ;
                         }
@@ -1338,7 +1344,7 @@ impl<'de> serde::Deserialize<'de> for InnerSpec {
                                 return Err(serde::de::Error::duplicate_field("childSize"));
                             }
                             child_size__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::MinPrefixLength => {
@@ -1346,7 +1352,7 @@ impl<'de> serde::Deserialize<'de> for InnerSpec {
                                 return Err(serde::de::Error::duplicate_field("minPrefixLength"));
                             }
                             min_prefix_length__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::MaxPrefixLength => {
@@ -1354,7 +1360,7 @@ impl<'de> serde::Deserialize<'de> for InnerSpec {
                                 return Err(serde::de::Error::duplicate_field("maxPrefixLength"));
                             }
                             max_prefix_length__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::EmptyChild => {
@@ -1362,14 +1368,14 @@ impl<'de> serde::Deserialize<'de> for InnerSpec {
                                 return Err(serde::de::Error::duplicate_field("emptyChild"));
                             }
                             empty_child__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Hash => {
                             if hash__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("hash"));
                             }
-                            hash__ = Some(map.next_value::<HashOp>()? as i32);
+                            hash__ = Some(map_.next_value::<HashOp>()? as i32);
                         }
                     }
                 }
@@ -1411,26 +1417,27 @@ impl serde::Serialize for LeafOp {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.ics23.v1.LeafOp", len)?;
         if true {
-            let v = HashOp::from_i32(self.hash)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.hash)))?;
+            let v = HashOp::try_from(self.hash)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.hash)))?;
             struct_ser.serialize_field("hash", &v)?;
         }
         if true {
-            let v = HashOp::from_i32(self.prehash_key)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.prehash_key)))?;
+            let v = HashOp::try_from(self.prehash_key)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.prehash_key)))?;
             struct_ser.serialize_field("prehashKey", &v)?;
         }
         if true {
-            let v = HashOp::from_i32(self.prehash_value)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.prehash_value)))?;
+            let v = HashOp::try_from(self.prehash_value)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.prehash_value)))?;
             struct_ser.serialize_field("prehashValue", &v)?;
         }
         if true {
-            let v = LengthOp::from_i32(self.length)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.length)))?;
+            let v = LengthOp::try_from(self.length)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.length)))?;
             struct_ser.serialize_field("length", &v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("prefix", pbjson::private::base64::encode(&self.prefix).as_str())?;
         }
         struct_ser.end()
@@ -1500,7 +1507,7 @@ impl<'de> serde::Deserialize<'de> for LeafOp {
                 formatter.write_str("struct cosmos.ics23.v1.LeafOp")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<LeafOp, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<LeafOp, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -1509,38 +1516,38 @@ impl<'de> serde::Deserialize<'de> for LeafOp {
                 let mut prehash_value__ = None;
                 let mut length__ = None;
                 let mut prefix__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Hash => {
                             if hash__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("hash"));
                             }
-                            hash__ = Some(map.next_value::<HashOp>()? as i32);
+                            hash__ = Some(map_.next_value::<HashOp>()? as i32);
                         }
                         GeneratedField::PrehashKey => {
                             if prehash_key__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("prehashKey"));
                             }
-                            prehash_key__ = Some(map.next_value::<HashOp>()? as i32);
+                            prehash_key__ = Some(map_.next_value::<HashOp>()? as i32);
                         }
                         GeneratedField::PrehashValue => {
                             if prehash_value__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("prehashValue"));
                             }
-                            prehash_value__ = Some(map.next_value::<HashOp>()? as i32);
+                            prehash_value__ = Some(map_.next_value::<HashOp>()? as i32);
                         }
                         GeneratedField::Length => {
                             if length__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("length"));
                             }
-                            length__ = Some(map.next_value::<LengthOp>()? as i32);
+                            length__ = Some(map_.next_value::<LengthOp>()? as i32);
                         }
                         GeneratedField::Prefix => {
                             if prefix__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("prefix"));
                             }
                             prefix__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -1608,10 +1615,9 @@ impl<'de> serde::Deserialize<'de> for LengthOp {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(LengthOp::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -1621,10 +1627,9 @@ impl<'de> serde::Deserialize<'de> for LengthOp {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(LengthOp::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
@@ -1670,6 +1675,7 @@ impl serde::Serialize for NonExistenceProof {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.ics23.v1.NonExistenceProof", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("key", pbjson::private::base64::encode(&self.key).as_str())?;
         }
         if let Some(v) = self.left.as_ref() {
@@ -1737,34 +1743,34 @@ impl<'de> serde::Deserialize<'de> for NonExistenceProof {
                 formatter.write_str("struct cosmos.ics23.v1.NonExistenceProof")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<NonExistenceProof, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<NonExistenceProof, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut key__ = None;
                 let mut left__ = None;
                 let mut right__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Key => {
                             if key__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("key"));
                             }
                             key__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Left => {
                             if left__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("left"));
                             }
-                            left__ = map.next_value()?;
+                            left__ = map_.next_value()?;
                         }
                         GeneratedField::Right => {
                             if right__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("right"));
                             }
-                            right__ = map.next_value()?;
+                            right__ = map_.next_value()?;
                         }
                     }
                 }
@@ -1877,7 +1883,7 @@ impl<'de> serde::Deserialize<'de> for ProofSpec {
                 formatter.write_str("struct cosmos.ics23.v1.ProofSpec")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ProofSpec, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ProofSpec, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -1885,26 +1891,26 @@ impl<'de> serde::Deserialize<'de> for ProofSpec {
                 let mut inner_spec__ = None;
                 let mut max_depth__ = None;
                 let mut min_depth__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::LeafSpec => {
                             if leaf_spec__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("leafSpec"));
                             }
-                            leaf_spec__ = map.next_value()?;
+                            leaf_spec__ = map_.next_value()?;
                         }
                         GeneratedField::InnerSpec => {
                             if inner_spec__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("innerSpec"));
                             }
-                            inner_spec__ = map.next_value()?;
+                            inner_spec__ = map_.next_value()?;
                         }
                         GeneratedField::MaxDepth => {
                             if max_depth__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("maxDepth"));
                             }
                             max_depth__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::MinDepth => {
@@ -1912,7 +1918,7 @@ impl<'de> serde::Deserialize<'de> for ProofSpec {
                                 return Err(serde::de::Error::duplicate_field("minDepth"));
                             }
                             min_depth__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
diff --git a/src/prost/cosmos.staking.module.v1.serde.rs b/src/prost/cosmos.staking.module.v1.serde.rs
index 07c37646..f9224074 100644
--- a/src/prost/cosmos.staking.module.v1.serde.rs
+++ b/src/prost/cosmos.staking.module.v1.serde.rs
@@ -76,25 +76,25 @@ impl<'de> serde::Deserialize<'de> for Module {
                 formatter.write_str("struct cosmos.staking.module.v1.Module")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Module, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Module, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut hooks_order__ = None;
                 let mut authority__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::HooksOrder => {
                             if hooks_order__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("hooksOrder"));
                             }
-                            hooks_order__ = Some(map.next_value()?);
+                            hooks_order__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Authority => {
                             if authority__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("authority"));
                             }
-                            authority__ = Some(map.next_value()?);
+                            authority__ = Some(map_.next_value()?);
                         }
                     }
                 }
diff --git a/src/prost/cosmos.staking.v1beta1.serde.rs b/src/prost/cosmos.staking.v1beta1.serde.rs
index a7baa70b..38ca4a23 100644
--- a/src/prost/cosmos.staking.v1beta1.serde.rs
+++ b/src/prost/cosmos.staking.v1beta1.serde.rs
@@ -39,10 +39,9 @@ impl<'de> serde::Deserialize<'de> for AuthorizationType {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(AuthorizationType::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -52,10 +51,9 @@ impl<'de> serde::Deserialize<'de> for AuthorizationType {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(AuthorizationType::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
@@ -118,10 +116,9 @@ impl<'de> serde::Deserialize<'de> for BondStatus {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(BondStatus::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -131,10 +128,9 @@ impl<'de> serde::Deserialize<'de> for BondStatus {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(BondStatus::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
@@ -235,25 +231,25 @@ impl<'de> serde::Deserialize<'de> for Commission {
                 formatter.write_str("struct cosmos.staking.v1beta1.Commission")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Commission, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Commission, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut commission_rates__ = None;
                 let mut update_time__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::CommissionRates => {
                             if commission_rates__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("commissionRates"));
                             }
-                            commission_rates__ = map.next_value()?;
+                            commission_rates__ = map_.next_value()?;
                         }
                         GeneratedField::UpdateTime => {
                             if update_time__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("updateTime"));
                             }
-                            update_time__ = map.next_value()?;
+                            update_time__ = map_.next_value()?;
                         }
                     }
                 }
@@ -354,32 +350,32 @@ impl<'de> serde::Deserialize<'de> for CommissionRates {
                 formatter.write_str("struct cosmos.staking.v1beta1.CommissionRates")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<CommissionRates, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<CommissionRates, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut rate__ = None;
                 let mut max_rate__ = None;
                 let mut max_change_rate__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Rate => {
                             if rate__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("rate"));
                             }
-                            rate__ = Some(map.next_value()?);
+                            rate__ = Some(map_.next_value()?);
                         }
                         GeneratedField::MaxRate => {
                             if max_rate__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("maxRate"));
                             }
-                            max_rate__ = Some(map.next_value()?);
+                            max_rate__ = Some(map_.next_value()?);
                         }
                         GeneratedField::MaxChangeRate => {
                             if max_change_rate__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("maxChangeRate"));
                             }
-                            max_change_rate__ = Some(map.next_value()?);
+                            max_change_rate__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -472,25 +468,25 @@ impl<'de> serde::Deserialize<'de> for DvPair {
                 formatter.write_str("struct cosmos.staking.v1beta1.DVPair")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<DvPair, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<DvPair, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut delegator_address__ = None;
                 let mut validator_address__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::DelegatorAddress => {
                             if delegator_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("delegatorAddress"));
                             }
-                            delegator_address__ = Some(map.next_value()?);
+                            delegator_address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ValidatorAddress => {
                             if validator_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("validatorAddress"));
                             }
-                            validator_address__ = Some(map.next_value()?);
+                            validator_address__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -571,18 +567,18 @@ impl<'de> serde::Deserialize<'de> for DvPairs {
                 formatter.write_str("struct cosmos.staking.v1beta1.DVPairs")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<DvPairs, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<DvPairs, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut pairs__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Pairs => {
                             if pairs__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pairs"));
                             }
-                            pairs__ = Some(map.next_value()?);
+                            pairs__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -683,32 +679,32 @@ impl<'de> serde::Deserialize<'de> for DvvTriplet {
                 formatter.write_str("struct cosmos.staking.v1beta1.DVVTriplet")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<DvvTriplet, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<DvvTriplet, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut delegator_address__ = None;
                 let mut validator_src_address__ = None;
                 let mut validator_dst_address__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::DelegatorAddress => {
                             if delegator_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("delegatorAddress"));
                             }
-                            delegator_address__ = Some(map.next_value()?);
+                            delegator_address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ValidatorSrcAddress => {
                             if validator_src_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("validatorSrcAddress"));
                             }
-                            validator_src_address__ = Some(map.next_value()?);
+                            validator_src_address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ValidatorDstAddress => {
                             if validator_dst_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("validatorDstAddress"));
                             }
-                            validator_dst_address__ = Some(map.next_value()?);
+                            validator_dst_address__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -790,18 +786,18 @@ impl<'de> serde::Deserialize<'de> for DvvTriplets {
                 formatter.write_str("struct cosmos.staking.v1beta1.DVVTriplets")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<DvvTriplets, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<DvvTriplets, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut triplets__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Triplets => {
                             if triplets__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("triplets"));
                             }
-                            triplets__ = Some(map.next_value()?);
+                            triplets__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -901,32 +897,32 @@ impl<'de> serde::Deserialize<'de> for Delegation {
                 formatter.write_str("struct cosmos.staking.v1beta1.Delegation")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Delegation, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Delegation, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut delegator_address__ = None;
                 let mut validator_address__ = None;
                 let mut shares__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::DelegatorAddress => {
                             if delegator_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("delegatorAddress"));
                             }
-                            delegator_address__ = Some(map.next_value()?);
+                            delegator_address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ValidatorAddress => {
                             if validator_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("validatorAddress"));
                             }
-                            validator_address__ = Some(map.next_value()?);
+                            validator_address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Shares => {
                             if shares__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("shares"));
                             }
-                            shares__ = Some(map.next_value()?);
+                            shares__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1017,25 +1013,25 @@ impl<'de> serde::Deserialize<'de> for DelegationResponse {
                 formatter.write_str("struct cosmos.staking.v1beta1.DelegationResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<DelegationResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<DelegationResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut delegation__ = None;
                 let mut balance__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Delegation => {
                             if delegation__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("delegation"));
                             }
-                            delegation__ = map.next_value()?;
+                            delegation__ = map_.next_value()?;
                         }
                         GeneratedField::Balance => {
                             if balance__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("balance"));
                             }
-                            balance__ = map.next_value()?;
+                            balance__ = map_.next_value()?;
                         }
                     }
                 }
@@ -1153,7 +1149,7 @@ impl<'de> serde::Deserialize<'de> for Description {
                 formatter.write_str("struct cosmos.staking.v1beta1.Description")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Description, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Description, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -1162,37 +1158,37 @@ impl<'de> serde::Deserialize<'de> for Description {
                 let mut website__ = None;
                 let mut security_contact__ = None;
                 let mut details__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Moniker => {
                             if moniker__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("moniker"));
                             }
-                            moniker__ = Some(map.next_value()?);
+                            moniker__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Identity => {
                             if identity__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("identity"));
                             }
-                            identity__ = Some(map.next_value()?);
+                            identity__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Website => {
                             if website__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("website"));
                             }
-                            website__ = Some(map.next_value()?);
+                            website__ = Some(map_.next_value()?);
                         }
                         GeneratedField::SecurityContact => {
                             if security_contact__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("securityContact"));
                             }
-                            security_contact__ = Some(map.next_value()?);
+                            security_contact__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Details => {
                             if details__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("details"));
                             }
-                            details__ = Some(map.next_value()?);
+                            details__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1245,6 +1241,7 @@ impl serde::Serialize for GenesisState {
             struct_ser.serialize_field("params", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("lastTotalPower", pbjson::private::base64::encode(&self.last_total_power).as_str())?;
         }
         if true {
@@ -1342,7 +1339,7 @@ impl<'de> serde::Deserialize<'de> for GenesisState {
                 formatter.write_str("struct cosmos.staking.v1beta1.GenesisState")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<GenesisState, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<GenesisState, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -1354,57 +1351,57 @@ impl<'de> serde::Deserialize<'de> for GenesisState {
                 let mut unbonding_delegations__ = None;
                 let mut redelegations__ = None;
                 let mut exported__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Params => {
                             if params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("params"));
                             }
-                            params__ = map.next_value()?;
+                            params__ = map_.next_value()?;
                         }
                         GeneratedField::LastTotalPower => {
                             if last_total_power__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("lastTotalPower"));
                             }
                             last_total_power__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::LastValidatorPowers => {
                             if last_validator_powers__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("lastValidatorPowers"));
                             }
-                            last_validator_powers__ = Some(map.next_value()?);
+                            last_validator_powers__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Validators => {
                             if validators__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("validators"));
                             }
-                            validators__ = Some(map.next_value()?);
+                            validators__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Delegations => {
                             if delegations__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("delegations"));
                             }
-                            delegations__ = Some(map.next_value()?);
+                            delegations__ = Some(map_.next_value()?);
                         }
                         GeneratedField::UnbondingDelegations => {
                             if unbonding_delegations__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("unbondingDelegations"));
                             }
-                            unbonding_delegations__ = Some(map.next_value()?);
+                            unbonding_delegations__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Redelegations => {
                             if redelegations__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("redelegations"));
                             }
-                            redelegations__ = Some(map.next_value()?);
+                            redelegations__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Exported => {
                             if exported__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("exported"));
                             }
-                            exported__ = Some(map.next_value()?);
+                            exported__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1500,25 +1497,25 @@ impl<'de> serde::Deserialize<'de> for HistoricalInfo {
                 formatter.write_str("struct cosmos.staking.v1beta1.HistoricalInfo")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<HistoricalInfo, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<HistoricalInfo, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut header__ = None;
                 let mut valset__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Header => {
                             if header__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("header"));
                             }
-                            header__ = map.next_value()?;
+                            header__ = map_.next_value()?;
                         }
                         GeneratedField::Valset => {
                             if valset__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("valset"));
                             }
-                            valset__ = Some(map.next_value()?);
+                            valset__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1570,10 +1567,9 @@ impl<'de> serde::Deserialize<'de> for Infraction {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(Infraction::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -1583,10 +1579,9 @@ impl<'de> serde::Deserialize<'de> for Infraction {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(Infraction::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
@@ -1646,10 +1641,9 @@ impl<'de> serde::Deserialize<'de> for InfractionType {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(InfractionType::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -1659,10 +1653,9 @@ impl<'de> serde::Deserialize<'de> for InfractionType {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(InfractionType::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
@@ -1702,6 +1695,7 @@ impl serde::Serialize for LastValidatorPower {
             struct_ser.serialize_field("address", &self.address)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("power", ::alloc::string::ToString::to_string(&self.power).as_str())?;
         }
         struct_ser.end()
@@ -1760,26 +1754,26 @@ impl<'de> serde::Deserialize<'de> for LastValidatorPower {
                 formatter.write_str("struct cosmos.staking.v1beta1.LastValidatorPower")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<LastValidatorPower, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<LastValidatorPower, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut address__ = None;
                 let mut power__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Address => {
                             if address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("address"));
                             }
-                            address__ = Some(map.next_value()?);
+                            address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Power => {
                             if power__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("power"));
                             }
                             power__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -1891,7 +1885,7 @@ impl<'de> serde::Deserialize<'de> for MsgBeginRedelegate {
                 formatter.write_str("struct cosmos.staking.v1beta1.MsgBeginRedelegate")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgBeginRedelegate, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgBeginRedelegate, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -1899,31 +1893,31 @@ impl<'de> serde::Deserialize<'de> for MsgBeginRedelegate {
                 let mut validator_src_address__ = None;
                 let mut validator_dst_address__ = None;
                 let mut amount__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::DelegatorAddress => {
                             if delegator_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("delegatorAddress"));
                             }
-                            delegator_address__ = Some(map.next_value()?);
+                            delegator_address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ValidatorSrcAddress => {
                             if validator_src_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("validatorSrcAddress"));
                             }
-                            validator_src_address__ = Some(map.next_value()?);
+                            validator_src_address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ValidatorDstAddress => {
                             if validator_dst_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("validatorDstAddress"));
                             }
-                            validator_dst_address__ = Some(map.next_value()?);
+                            validator_dst_address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Amount => {
                             if amount__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("amount"));
                             }
-                            amount__ = map.next_value()?;
+                            amount__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2007,18 +2001,18 @@ impl<'de> serde::Deserialize<'de> for MsgBeginRedelegateResponse {
                 formatter.write_str("struct cosmos.staking.v1beta1.MsgBeginRedelegateResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgBeginRedelegateResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgBeginRedelegateResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut completion_time__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::CompletionTime => {
                             if completion_time__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("completionTime"));
                             }
-                            completion_time__ = map.next_value()?;
+                            completion_time__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2061,6 +2055,7 @@ impl serde::Serialize for MsgCancelUnbondingDelegation {
             struct_ser.serialize_field("amount", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("creationHeight", ::alloc::string::ToString::to_string(&self.creation_height).as_str())?;
         }
         struct_ser.end()
@@ -2128,7 +2123,7 @@ impl<'de> serde::Deserialize<'de> for MsgCancelUnbondingDelegation {
                 formatter.write_str("struct cosmos.staking.v1beta1.MsgCancelUnbondingDelegation")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgCancelUnbondingDelegation, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgCancelUnbondingDelegation, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -2136,32 +2131,32 @@ impl<'de> serde::Deserialize<'de> for MsgCancelUnbondingDelegation {
                 let mut validator_address__ = None;
                 let mut amount__ = None;
                 let mut creation_height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::DelegatorAddress => {
                             if delegator_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("delegatorAddress"));
                             }
-                            delegator_address__ = Some(map.next_value()?);
+                            delegator_address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ValidatorAddress => {
                             if validator_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("validatorAddress"));
                             }
-                            validator_address__ = Some(map.next_value()?);
+                            validator_address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Amount => {
                             if amount__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("amount"));
                             }
-                            amount__ = map.next_value()?;
+                            amount__ = map_.next_value()?;
                         }
                         GeneratedField::CreationHeight => {
                             if creation_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("creationHeight"));
                             }
                             creation_height__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -2234,12 +2229,12 @@ impl<'de> serde::Deserialize<'de> for MsgCancelUnbondingDelegationResponse {
                 formatter.write_str("struct cosmos.staking.v1beta1.MsgCancelUnbondingDelegationResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgCancelUnbondingDelegationResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgCancelUnbondingDelegationResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgCancelUnbondingDelegationResponse {
                 })
@@ -2373,7 +2368,7 @@ impl<'de> serde::Deserialize<'de> for MsgCreateValidator {
                 formatter.write_str("struct cosmos.staking.v1beta1.MsgCreateValidator")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgCreateValidator, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgCreateValidator, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -2384,49 +2379,49 @@ impl<'de> serde::Deserialize<'de> for MsgCreateValidator {
                 let mut validator_address__ = None;
                 let mut pubkey__ = None;
                 let mut value__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Description => {
                             if description__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("description"));
                             }
-                            description__ = map.next_value()?;
+                            description__ = map_.next_value()?;
                         }
                         GeneratedField::Commission => {
                             if commission__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("commission"));
                             }
-                            commission__ = map.next_value()?;
+                            commission__ = map_.next_value()?;
                         }
                         GeneratedField::MinSelfDelegation => {
                             if min_self_delegation__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("minSelfDelegation"));
                             }
-                            min_self_delegation__ = Some(map.next_value()?);
+                            min_self_delegation__ = Some(map_.next_value()?);
                         }
                         GeneratedField::DelegatorAddress => {
                             if delegator_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("delegatorAddress"));
                             }
-                            delegator_address__ = Some(map.next_value()?);
+                            delegator_address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ValidatorAddress => {
                             if validator_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("validatorAddress"));
                             }
-                            validator_address__ = Some(map.next_value()?);
+                            validator_address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pubkey => {
                             if pubkey__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pubkey"));
                             }
-                            pubkey__ = map.next_value()?;
+                            pubkey__ = map_.next_value()?;
                         }
                         GeneratedField::Value => {
                             if value__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("value"));
                             }
-                            value__ = map.next_value()?;
+                            value__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2501,12 +2496,12 @@ impl<'de> serde::Deserialize<'de> for MsgCreateValidatorResponse {
                 formatter.write_str("struct cosmos.staking.v1beta1.MsgCreateValidatorResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgCreateValidatorResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgCreateValidatorResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgCreateValidatorResponse {
                 })
@@ -2603,32 +2598,32 @@ impl<'de> serde::Deserialize<'de> for MsgDelegate {
                 formatter.write_str("struct cosmos.staking.v1beta1.MsgDelegate")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgDelegate, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgDelegate, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut delegator_address__ = None;
                 let mut validator_address__ = None;
                 let mut amount__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::DelegatorAddress => {
                             if delegator_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("delegatorAddress"));
                             }
-                            delegator_address__ = Some(map.next_value()?);
+                            delegator_address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ValidatorAddress => {
                             if validator_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("validatorAddress"));
                             }
-                            validator_address__ = Some(map.next_value()?);
+                            validator_address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Amount => {
                             if amount__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("amount"));
                             }
-                            amount__ = map.next_value()?;
+                            amount__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2699,12 +2694,12 @@ impl<'de> serde::Deserialize<'de> for MsgDelegateResponse {
                 formatter.write_str("struct cosmos.staking.v1beta1.MsgDelegateResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgDelegateResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgDelegateResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgDelegateResponse {
                 })
@@ -2811,7 +2806,7 @@ impl<'de> serde::Deserialize<'de> for MsgEditValidator {
                 formatter.write_str("struct cosmos.staking.v1beta1.MsgEditValidator")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgEditValidator, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgEditValidator, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -2819,31 +2814,31 @@ impl<'de> serde::Deserialize<'de> for MsgEditValidator {
                 let mut validator_address__ = None;
                 let mut commission_rate__ = None;
                 let mut min_self_delegation__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Description => {
                             if description__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("description"));
                             }
-                            description__ = map.next_value()?;
+                            description__ = map_.next_value()?;
                         }
                         GeneratedField::ValidatorAddress => {
                             if validator_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("validatorAddress"));
                             }
-                            validator_address__ = Some(map.next_value()?);
+                            validator_address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::CommissionRate => {
                             if commission_rate__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("commissionRate"));
                             }
-                            commission_rate__ = Some(map.next_value()?);
+                            commission_rate__ = Some(map_.next_value()?);
                         }
                         GeneratedField::MinSelfDelegation => {
                             if min_self_delegation__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("minSelfDelegation"));
                             }
-                            min_self_delegation__ = Some(map.next_value()?);
+                            min_self_delegation__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -2915,12 +2910,12 @@ impl<'de> serde::Deserialize<'de> for MsgEditValidatorResponse {
                 formatter.write_str("struct cosmos.staking.v1beta1.MsgEditValidatorResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgEditValidatorResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgEditValidatorResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgEditValidatorResponse {
                 })
@@ -3017,32 +3012,32 @@ impl<'de> serde::Deserialize<'de> for MsgUndelegate {
                 formatter.write_str("struct cosmos.staking.v1beta1.MsgUndelegate")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgUndelegate, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgUndelegate, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut delegator_address__ = None;
                 let mut validator_address__ = None;
                 let mut amount__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::DelegatorAddress => {
                             if delegator_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("delegatorAddress"));
                             }
-                            delegator_address__ = Some(map.next_value()?);
+                            delegator_address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ValidatorAddress => {
                             if validator_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("validatorAddress"));
                             }
-                            validator_address__ = Some(map.next_value()?);
+                            validator_address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Amount => {
                             if amount__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("amount"));
                             }
-                            amount__ = map.next_value()?;
+                            amount__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3125,18 +3120,18 @@ impl<'de> serde::Deserialize<'de> for MsgUndelegateResponse {
                 formatter.write_str("struct cosmos.staking.v1beta1.MsgUndelegateResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgUndelegateResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgUndelegateResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut completion_time__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::CompletionTime => {
                             if completion_time__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("completionTime"));
                             }
-                            completion_time__ = map.next_value()?;
+                            completion_time__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3225,25 +3220,25 @@ impl<'de> serde::Deserialize<'de> for MsgUpdateParams {
                 formatter.write_str("struct cosmos.staking.v1beta1.MsgUpdateParams")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgUpdateParams, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgUpdateParams, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut authority__ = None;
                 let mut params__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Authority => {
                             if authority__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("authority"));
                             }
-                            authority__ = Some(map.next_value()?);
+                            authority__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Params => {
                             if params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("params"));
                             }
-                            params__ = map.next_value()?;
+                            params__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3313,12 +3308,12 @@ impl<'de> serde::Deserialize<'de> for MsgUpdateParamsResponse {
                 formatter.write_str("struct cosmos.staking.v1beta1.MsgUpdateParamsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgUpdateParamsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgUpdateParamsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgUpdateParamsResponse {
                 })
@@ -3446,7 +3441,7 @@ impl<'de> serde::Deserialize<'de> for Params {
                 formatter.write_str("struct cosmos.staking.v1beta1.Params")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Params, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Params, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -3456,20 +3451,20 @@ impl<'de> serde::Deserialize<'de> for Params {
                 let mut historical_entries__ = None;
                 let mut bond_denom__ = None;
                 let mut min_commission_rate__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::UnbondingTime => {
                             if unbonding_time__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("unbondingTime"));
                             }
-                            unbonding_time__ = map.next_value()?;
+                            unbonding_time__ = map_.next_value()?;
                         }
                         GeneratedField::MaxValidators => {
                             if max_validators__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("maxValidators"));
                             }
                             max_validators__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::MaxEntries => {
@@ -3477,7 +3472,7 @@ impl<'de> serde::Deserialize<'de> for Params {
                                 return Err(serde::de::Error::duplicate_field("maxEntries"));
                             }
                             max_entries__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::HistoricalEntries => {
@@ -3485,20 +3480,20 @@ impl<'de> serde::Deserialize<'de> for Params {
                                 return Err(serde::de::Error::duplicate_field("historicalEntries"));
                             }
                             historical_entries__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::BondDenom => {
                             if bond_denom__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("bondDenom"));
                             }
-                            bond_denom__ = Some(map.next_value()?);
+                            bond_denom__ = Some(map_.next_value()?);
                         }
                         GeneratedField::MinCommissionRate => {
                             if min_commission_rate__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("minCommissionRate"));
                             }
-                            min_commission_rate__ = Some(map.next_value()?);
+                            min_commission_rate__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -3594,25 +3589,25 @@ impl<'de> serde::Deserialize<'de> for Pool {
                 formatter.write_str("struct cosmos.staking.v1beta1.Pool")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Pool, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Pool, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut not_bonded_tokens__ = None;
                 let mut bonded_tokens__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::NotBondedTokens => {
                             if not_bonded_tokens__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("notBondedTokens"));
                             }
-                            not_bonded_tokens__ = Some(map.next_value()?);
+                            not_bonded_tokens__ = Some(map_.next_value()?);
                         }
                         GeneratedField::BondedTokens => {
                             if bonded_tokens__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("bondedTokens"));
                             }
-                            bonded_tokens__ = Some(map.next_value()?);
+                            bonded_tokens__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -3704,25 +3699,25 @@ impl<'de> serde::Deserialize<'de> for QueryDelegationRequest {
                 formatter.write_str("struct cosmos.staking.v1beta1.QueryDelegationRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryDelegationRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryDelegationRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut delegator_addr__ = None;
                 let mut validator_addr__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::DelegatorAddr => {
                             if delegator_addr__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("delegatorAddr"));
                             }
-                            delegator_addr__ = Some(map.next_value()?);
+                            delegator_addr__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ValidatorAddr => {
                             if validator_addr__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("validatorAddr"));
                             }
-                            validator_addr__ = Some(map.next_value()?);
+                            validator_addr__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -3804,18 +3799,18 @@ impl<'de> serde::Deserialize<'de> for QueryDelegationResponse {
                 formatter.write_str("struct cosmos.staking.v1beta1.QueryDelegationResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryDelegationResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryDelegationResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut delegation_response__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::DelegationResponse => {
                             if delegation_response__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("delegationResponse"));
                             }
-                            delegation_response__ = map.next_value()?;
+                            delegation_response__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3905,25 +3900,25 @@ impl<'de> serde::Deserialize<'de> for QueryDelegatorDelegationsRequest {
                 formatter.write_str("struct cosmos.staking.v1beta1.QueryDelegatorDelegationsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryDelegatorDelegationsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryDelegatorDelegationsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut delegator_addr__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::DelegatorAddr => {
                             if delegator_addr__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("delegatorAddr"));
                             }
-                            delegator_addr__ = Some(map.next_value()?);
+                            delegator_addr__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -4014,25 +4009,25 @@ impl<'de> serde::Deserialize<'de> for QueryDelegatorDelegationsResponse {
                 formatter.write_str("struct cosmos.staking.v1beta1.QueryDelegatorDelegationsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryDelegatorDelegationsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryDelegatorDelegationsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut delegation_responses__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::DelegationResponses => {
                             if delegation_responses__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("delegationResponses"));
                             }
-                            delegation_responses__ = Some(map.next_value()?);
+                            delegation_responses__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -4123,25 +4118,25 @@ impl<'de> serde::Deserialize<'de> for QueryDelegatorUnbondingDelegationsRequest
                 formatter.write_str("struct cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryDelegatorUnbondingDelegationsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryDelegatorUnbondingDelegationsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut delegator_addr__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::DelegatorAddr => {
                             if delegator_addr__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("delegatorAddr"));
                             }
-                            delegator_addr__ = Some(map.next_value()?);
+                            delegator_addr__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -4232,25 +4227,25 @@ impl<'de> serde::Deserialize<'de> for QueryDelegatorUnbondingDelegationsResponse
                 formatter.write_str("struct cosmos.staking.v1beta1.QueryDelegatorUnbondingDelegationsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryDelegatorUnbondingDelegationsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryDelegatorUnbondingDelegationsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut unbonding_responses__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::UnbondingResponses => {
                             if unbonding_responses__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("unbondingResponses"));
                             }
-                            unbonding_responses__ = Some(map.next_value()?);
+                            unbonding_responses__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -4342,25 +4337,25 @@ impl<'de> serde::Deserialize<'de> for QueryDelegatorValidatorRequest {
                 formatter.write_str("struct cosmos.staking.v1beta1.QueryDelegatorValidatorRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryDelegatorValidatorRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryDelegatorValidatorRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut delegator_addr__ = None;
                 let mut validator_addr__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::DelegatorAddr => {
                             if delegator_addr__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("delegatorAddr"));
                             }
-                            delegator_addr__ = Some(map.next_value()?);
+                            delegator_addr__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ValidatorAddr => {
                             if validator_addr__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("validatorAddr"));
                             }
-                            validator_addr__ = Some(map.next_value()?);
+                            validator_addr__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -4441,18 +4436,18 @@ impl<'de> serde::Deserialize<'de> for QueryDelegatorValidatorResponse {
                 formatter.write_str("struct cosmos.staking.v1beta1.QueryDelegatorValidatorResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryDelegatorValidatorResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryDelegatorValidatorResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut validator__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Validator => {
                             if validator__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("validator"));
                             }
-                            validator__ = map.next_value()?;
+                            validator__ = map_.next_value()?;
                         }
                     }
                 }
@@ -4542,25 +4537,25 @@ impl<'de> serde::Deserialize<'de> for QueryDelegatorValidatorsRequest {
                 formatter.write_str("struct cosmos.staking.v1beta1.QueryDelegatorValidatorsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryDelegatorValidatorsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryDelegatorValidatorsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut delegator_addr__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::DelegatorAddr => {
                             if delegator_addr__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("delegatorAddr"));
                             }
-                            delegator_addr__ = Some(map.next_value()?);
+                            delegator_addr__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -4650,25 +4645,25 @@ impl<'de> serde::Deserialize<'de> for QueryDelegatorValidatorsResponse {
                 formatter.write_str("struct cosmos.staking.v1beta1.QueryDelegatorValidatorsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryDelegatorValidatorsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryDelegatorValidatorsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut validators__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Validators => {
                             if validators__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("validators"));
                             }
-                            validators__ = Some(map.next_value()?);
+                            validators__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -4694,6 +4689,7 @@ impl serde::Serialize for QueryHistoricalInfoRequest {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.staking.v1beta1.QueryHistoricalInfoRequest", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("height", ::alloc::string::ToString::to_string(&self.height).as_str())?;
         }
         struct_ser.end()
@@ -4749,19 +4745,19 @@ impl<'de> serde::Deserialize<'de> for QueryHistoricalInfoRequest {
                 formatter.write_str("struct cosmos.staking.v1beta1.QueryHistoricalInfoRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryHistoricalInfoRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryHistoricalInfoRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Height => {
                             if height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("height"));
                             }
                             height__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -4842,18 +4838,18 @@ impl<'de> serde::Deserialize<'de> for QueryHistoricalInfoResponse {
                 formatter.write_str("struct cosmos.staking.v1beta1.QueryHistoricalInfoResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryHistoricalInfoResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryHistoricalInfoResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut hist__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Hist => {
                             if hist__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("hist"));
                             }
-                            hist__ = map.next_value()?;
+                            hist__ = map_.next_value()?;
                         }
                     }
                 }
@@ -4922,12 +4918,12 @@ impl<'de> serde::Deserialize<'de> for QueryParamsRequest {
                 formatter.write_str("struct cosmos.staking.v1beta1.QueryParamsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryParamsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryParamsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(QueryParamsRequest {
                 })
@@ -5004,18 +5000,18 @@ impl<'de> serde::Deserialize<'de> for QueryParamsResponse {
                 formatter.write_str("struct cosmos.staking.v1beta1.QueryParamsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryParamsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryParamsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut params__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Params => {
                             if params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("params"));
                             }
-                            params__ = map.next_value()?;
+                            params__ = map_.next_value()?;
                         }
                     }
                 }
@@ -5084,12 +5080,12 @@ impl<'de> serde::Deserialize<'de> for QueryPoolRequest {
                 formatter.write_str("struct cosmos.staking.v1beta1.QueryPoolRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryPoolRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryPoolRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(QueryPoolRequest {
                 })
@@ -5166,18 +5162,18 @@ impl<'de> serde::Deserialize<'de> for QueryPoolResponse {
                 formatter.write_str("struct cosmos.staking.v1beta1.QueryPoolResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryPoolResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryPoolResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut pool__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Pool => {
                             if pool__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pool"));
                             }
-                            pool__ = map.next_value()?;
+                            pool__ = map_.next_value()?;
                         }
                     }
                 }
@@ -5287,7 +5283,7 @@ impl<'de> serde::Deserialize<'de> for QueryRedelegationsRequest {
                 formatter.write_str("struct cosmos.staking.v1beta1.QueryRedelegationsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryRedelegationsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryRedelegationsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -5295,31 +5291,31 @@ impl<'de> serde::Deserialize<'de> for QueryRedelegationsRequest {
                 let mut src_validator_addr__ = None;
                 let mut dst_validator_addr__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::DelegatorAddr => {
                             if delegator_addr__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("delegatorAddr"));
                             }
-                            delegator_addr__ = Some(map.next_value()?);
+                            delegator_addr__ = Some(map_.next_value()?);
                         }
                         GeneratedField::SrcValidatorAddr => {
                             if src_validator_addr__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("srcValidatorAddr"));
                             }
-                            src_validator_addr__ = Some(map.next_value()?);
+                            src_validator_addr__ = Some(map_.next_value()?);
                         }
                         GeneratedField::DstValidatorAddr => {
                             if dst_validator_addr__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("dstValidatorAddr"));
                             }
-                            dst_validator_addr__ = Some(map.next_value()?);
+                            dst_validator_addr__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -5412,25 +5408,25 @@ impl<'de> serde::Deserialize<'de> for QueryRedelegationsResponse {
                 formatter.write_str("struct cosmos.staking.v1beta1.QueryRedelegationsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryRedelegationsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryRedelegationsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut redelegation_responses__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::RedelegationResponses => {
                             if redelegation_responses__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("redelegationResponses"));
                             }
-                            redelegation_responses__ = Some(map.next_value()?);
+                            redelegation_responses__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -5522,25 +5518,25 @@ impl<'de> serde::Deserialize<'de> for QueryUnbondingDelegationRequest {
                 formatter.write_str("struct cosmos.staking.v1beta1.QueryUnbondingDelegationRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryUnbondingDelegationRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryUnbondingDelegationRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut delegator_addr__ = None;
                 let mut validator_addr__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::DelegatorAddr => {
                             if delegator_addr__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("delegatorAddr"));
                             }
-                            delegator_addr__ = Some(map.next_value()?);
+                            delegator_addr__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ValidatorAddr => {
                             if validator_addr__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("validatorAddr"));
                             }
-                            validator_addr__ = Some(map.next_value()?);
+                            validator_addr__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -5621,18 +5617,18 @@ impl<'de> serde::Deserialize<'de> for QueryUnbondingDelegationResponse {
                 formatter.write_str("struct cosmos.staking.v1beta1.QueryUnbondingDelegationResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryUnbondingDelegationResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryUnbondingDelegationResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut unbond__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Unbond => {
                             if unbond__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("unbond"));
                             }
-                            unbond__ = map.next_value()?;
+                            unbond__ = map_.next_value()?;
                         }
                     }
                 }
@@ -5722,25 +5718,25 @@ impl<'de> serde::Deserialize<'de> for QueryValidatorDelegationsRequest {
                 formatter.write_str("struct cosmos.staking.v1beta1.QueryValidatorDelegationsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryValidatorDelegationsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryValidatorDelegationsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut validator_addr__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ValidatorAddr => {
                             if validator_addr__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("validatorAddr"));
                             }
-                            validator_addr__ = Some(map.next_value()?);
+                            validator_addr__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -5831,25 +5827,25 @@ impl<'de> serde::Deserialize<'de> for QueryValidatorDelegationsResponse {
                 formatter.write_str("struct cosmos.staking.v1beta1.QueryValidatorDelegationsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryValidatorDelegationsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryValidatorDelegationsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut delegation_responses__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::DelegationResponses => {
                             if delegation_responses__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("delegationResponses"));
                             }
-                            delegation_responses__ = Some(map.next_value()?);
+                            delegation_responses__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -5931,18 +5927,18 @@ impl<'de> serde::Deserialize<'de> for QueryValidatorRequest {
                 formatter.write_str("struct cosmos.staking.v1beta1.QueryValidatorRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryValidatorRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryValidatorRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut validator_addr__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ValidatorAddr => {
                             if validator_addr__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("validatorAddr"));
                             }
-                            validator_addr__ = Some(map.next_value()?);
+                            validator_addr__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -6022,18 +6018,18 @@ impl<'de> serde::Deserialize<'de> for QueryValidatorResponse {
                 formatter.write_str("struct cosmos.staking.v1beta1.QueryValidatorResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryValidatorResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryValidatorResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut validator__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Validator => {
                             if validator__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("validator"));
                             }
-                            validator__ = map.next_value()?;
+                            validator__ = map_.next_value()?;
                         }
                     }
                 }
@@ -6123,25 +6119,25 @@ impl<'de> serde::Deserialize<'de> for QueryValidatorUnbondingDelegationsRequest
                 formatter.write_str("struct cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryValidatorUnbondingDelegationsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryValidatorUnbondingDelegationsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut validator_addr__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ValidatorAddr => {
                             if validator_addr__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("validatorAddr"));
                             }
-                            validator_addr__ = Some(map.next_value()?);
+                            validator_addr__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -6232,25 +6228,25 @@ impl<'de> serde::Deserialize<'de> for QueryValidatorUnbondingDelegationsResponse
                 formatter.write_str("struct cosmos.staking.v1beta1.QueryValidatorUnbondingDelegationsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryValidatorUnbondingDelegationsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryValidatorUnbondingDelegationsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut unbonding_responses__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::UnbondingResponses => {
                             if unbonding_responses__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("unbondingResponses"));
                             }
-                            unbonding_responses__ = Some(map.next_value()?);
+                            unbonding_responses__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -6340,25 +6336,25 @@ impl<'de> serde::Deserialize<'de> for QueryValidatorsRequest {
                 formatter.write_str("struct cosmos.staking.v1beta1.QueryValidatorsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryValidatorsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryValidatorsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut status__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Status => {
                             if status__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("status"));
                             }
-                            status__ = Some(map.next_value()?);
+                            status__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -6448,25 +6444,25 @@ impl<'de> serde::Deserialize<'de> for QueryValidatorsResponse {
                 formatter.write_str("struct cosmos.staking.v1beta1.QueryValidatorsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryValidatorsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryValidatorsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut validators__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Validators => {
                             if validators__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("validators"));
                             }
-                            validators__ = Some(map.next_value()?);
+                            validators__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -6577,7 +6573,7 @@ impl<'de> serde::Deserialize<'de> for Redelegation {
                 formatter.write_str("struct cosmos.staking.v1beta1.Redelegation")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Redelegation, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Redelegation, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -6585,31 +6581,31 @@ impl<'de> serde::Deserialize<'de> for Redelegation {
                 let mut validator_src_address__ = None;
                 let mut validator_dst_address__ = None;
                 let mut entries__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::DelegatorAddress => {
                             if delegator_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("delegatorAddress"));
                             }
-                            delegator_address__ = Some(map.next_value()?);
+                            delegator_address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ValidatorSrcAddress => {
                             if validator_src_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("validatorSrcAddress"));
                             }
-                            validator_src_address__ = Some(map.next_value()?);
+                            validator_src_address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ValidatorDstAddress => {
                             if validator_dst_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("validatorDstAddress"));
                             }
-                            validator_dst_address__ = Some(map.next_value()?);
+                            validator_dst_address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Entries => {
                             if entries__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("entries"));
                             }
-                            entries__ = Some(map.next_value()?);
+                            entries__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -6652,6 +6648,7 @@ impl serde::Serialize for RedelegationEntry {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.staking.v1beta1.RedelegationEntry", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("creationHeight", ::alloc::string::ToString::to_string(&self.creation_height).as_str())?;
         }
         if let Some(v) = self.completion_time.as_ref() {
@@ -6664,9 +6661,11 @@ impl serde::Serialize for RedelegationEntry {
             struct_ser.serialize_field("sharesDst", &self.shares_dst)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("unbondingId", ::alloc::string::ToString::to_string(&self.unbonding_id).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("unbondingOnHoldRefCount", ::alloc::string::ToString::to_string(&self.unbonding_on_hold_ref_count).as_str())?;
         }
         struct_ser.end()
@@ -6743,7 +6742,7 @@ impl<'de> serde::Deserialize<'de> for RedelegationEntry {
                 formatter.write_str("struct cosmos.staking.v1beta1.RedelegationEntry")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<RedelegationEntry, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<RedelegationEntry, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -6753,40 +6752,40 @@ impl<'de> serde::Deserialize<'de> for RedelegationEntry {
                 let mut shares_dst__ = None;
                 let mut unbonding_id__ = None;
                 let mut unbonding_on_hold_ref_count__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::CreationHeight => {
                             if creation_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("creationHeight"));
                             }
                             creation_height__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::CompletionTime => {
                             if completion_time__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("completionTime"));
                             }
-                            completion_time__ = map.next_value()?;
+                            completion_time__ = map_.next_value()?;
                         }
                         GeneratedField::InitialBalance => {
                             if initial_balance__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("initialBalance"));
                             }
-                            initial_balance__ = Some(map.next_value()?);
+                            initial_balance__ = Some(map_.next_value()?);
                         }
                         GeneratedField::SharesDst => {
                             if shares_dst__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sharesDst"));
                             }
-                            shares_dst__ = Some(map.next_value()?);
+                            shares_dst__ = Some(map_.next_value()?);
                         }
                         GeneratedField::UnbondingId => {
                             if unbonding_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("unbondingId"));
                             }
                             unbonding_id__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::UnbondingOnHoldRefCount => {
@@ -6794,7 +6793,7 @@ impl<'de> serde::Deserialize<'de> for RedelegationEntry {
                                 return Err(serde::de::Error::duplicate_field("unbondingOnHoldRefCount"));
                             }
                             unbonding_on_hold_ref_count__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -6890,25 +6889,25 @@ impl<'de> serde::Deserialize<'de> for RedelegationEntryResponse {
                 formatter.write_str("struct cosmos.staking.v1beta1.RedelegationEntryResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<RedelegationEntryResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<RedelegationEntryResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut redelegation_entry__ = None;
                 let mut balance__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::RedelegationEntry => {
                             if redelegation_entry__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("redelegationEntry"));
                             }
-                            redelegation_entry__ = map.next_value()?;
+                            redelegation_entry__ = map_.next_value()?;
                         }
                         GeneratedField::Balance => {
                             if balance__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("balance"));
                             }
-                            balance__ = Some(map.next_value()?);
+                            balance__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -6998,25 +6997,25 @@ impl<'de> serde::Deserialize<'de> for RedelegationResponse {
                 formatter.write_str("struct cosmos.staking.v1beta1.RedelegationResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<RedelegationResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<RedelegationResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut redelegation__ = None;
                 let mut entries__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Redelegation => {
                             if redelegation__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("redelegation"));
                             }
-                            redelegation__ = map.next_value()?;
+                            redelegation__ = map_.next_value()?;
                         }
                         GeneratedField::Entries => {
                             if entries__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("entries"));
                             }
-                            entries__ = Some(map.next_value()?);
+                            entries__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -7117,32 +7116,32 @@ impl<'de> serde::Deserialize<'de> for UnbondingDelegation {
                 formatter.write_str("struct cosmos.staking.v1beta1.UnbondingDelegation")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<UnbondingDelegation, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<UnbondingDelegation, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut delegator_address__ = None;
                 let mut validator_address__ = None;
                 let mut entries__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::DelegatorAddress => {
                             if delegator_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("delegatorAddress"));
                             }
-                            delegator_address__ = Some(map.next_value()?);
+                            delegator_address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ValidatorAddress => {
                             if validator_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("validatorAddress"));
                             }
-                            validator_address__ = Some(map.next_value()?);
+                            validator_address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Entries => {
                             if entries__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("entries"));
                             }
-                            entries__ = Some(map.next_value()?);
+                            entries__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -7184,6 +7183,7 @@ impl serde::Serialize for UnbondingDelegationEntry {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.staking.v1beta1.UnbondingDelegationEntry", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("creationHeight", ::alloc::string::ToString::to_string(&self.creation_height).as_str())?;
         }
         if let Some(v) = self.completion_time.as_ref() {
@@ -7196,9 +7196,11 @@ impl serde::Serialize for UnbondingDelegationEntry {
             struct_ser.serialize_field("balance", &self.balance)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("unbondingId", ::alloc::string::ToString::to_string(&self.unbonding_id).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("unbondingOnHoldRefCount", ::alloc::string::ToString::to_string(&self.unbonding_on_hold_ref_count).as_str())?;
         }
         struct_ser.end()
@@ -7274,7 +7276,7 @@ impl<'de> serde::Deserialize<'de> for UnbondingDelegationEntry {
                 formatter.write_str("struct cosmos.staking.v1beta1.UnbondingDelegationEntry")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<UnbondingDelegationEntry, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<UnbondingDelegationEntry, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -7284,40 +7286,40 @@ impl<'de> serde::Deserialize<'de> for UnbondingDelegationEntry {
                 let mut balance__ = None;
                 let mut unbonding_id__ = None;
                 let mut unbonding_on_hold_ref_count__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::CreationHeight => {
                             if creation_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("creationHeight"));
                             }
                             creation_height__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::CompletionTime => {
                             if completion_time__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("completionTime"));
                             }
-                            completion_time__ = map.next_value()?;
+                            completion_time__ = map_.next_value()?;
                         }
                         GeneratedField::InitialBalance => {
                             if initial_balance__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("initialBalance"));
                             }
-                            initial_balance__ = Some(map.next_value()?);
+                            initial_balance__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Balance => {
                             if balance__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("balance"));
                             }
-                            balance__ = Some(map.next_value()?);
+                            balance__ = Some(map_.next_value()?);
                         }
                         GeneratedField::UnbondingId => {
                             if unbonding_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("unbondingId"));
                             }
                             unbonding_id__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::UnbondingOnHoldRefCount => {
@@ -7325,7 +7327,7 @@ impl<'de> serde::Deserialize<'de> for UnbondingDelegationEntry {
                                 return Err(serde::de::Error::duplicate_field("unbondingOnHoldRefCount"));
                             }
                             unbonding_on_hold_ref_count__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -7411,18 +7413,18 @@ impl<'de> serde::Deserialize<'de> for ValAddresses {
                 formatter.write_str("struct cosmos.staking.v1beta1.ValAddresses")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ValAddresses, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ValAddresses, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut addresses__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Addresses => {
                             if addresses__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("addresses"));
                             }
-                            addresses__ = Some(map.next_value()?);
+                            addresses__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -7492,8 +7494,8 @@ impl serde::Serialize for Validator {
             struct_ser.serialize_field("jailed", &self.jailed)?;
         }
         if true {
-            let v = BondStatus::from_i32(self.status)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.status)))?;
+            let v = BondStatus::try_from(self.status)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.status)))?;
             struct_ser.serialize_field("status", &v)?;
         }
         if true {
@@ -7506,6 +7508,7 @@ impl serde::Serialize for Validator {
             struct_ser.serialize_field("description", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("unbondingHeight", ::alloc::string::ToString::to_string(&self.unbonding_height).as_str())?;
         }
         if let Some(v) = self.unbonding_time.as_ref() {
@@ -7518,6 +7521,7 @@ impl serde::Serialize for Validator {
             struct_ser.serialize_field("minSelfDelegation", &self.min_self_delegation)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("unbondingOnHoldRefCount", ::alloc::string::ToString::to_string(&self.unbonding_on_hold_ref_count).as_str())?;
         }
         if true {
@@ -7620,7 +7624,7 @@ impl<'de> serde::Deserialize<'de> for Validator {
                 formatter.write_str("struct cosmos.staking.v1beta1.Validator")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Validator, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Validator, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -7637,82 +7641,82 @@ impl<'de> serde::Deserialize<'de> for Validator {
                 let mut min_self_delegation__ = None;
                 let mut unbonding_on_hold_ref_count__ = None;
                 let mut unbonding_ids__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::OperatorAddress => {
                             if operator_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("operatorAddress"));
                             }
-                            operator_address__ = Some(map.next_value()?);
+                            operator_address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ConsensusPubkey => {
                             if consensus_pubkey__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("consensusPubkey"));
                             }
-                            consensus_pubkey__ = map.next_value()?;
+                            consensus_pubkey__ = map_.next_value()?;
                         }
                         GeneratedField::Jailed => {
                             if jailed__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("jailed"));
                             }
-                            jailed__ = Some(map.next_value()?);
+                            jailed__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Status => {
                             if status__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("status"));
                             }
-                            status__ = Some(map.next_value::<BondStatus>()? as i32);
+                            status__ = Some(map_.next_value::<BondStatus>()? as i32);
                         }
                         GeneratedField::Tokens => {
                             if tokens__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("tokens"));
                             }
-                            tokens__ = Some(map.next_value()?);
+                            tokens__ = Some(map_.next_value()?);
                         }
                         GeneratedField::DelegatorShares => {
                             if delegator_shares__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("delegatorShares"));
                             }
-                            delegator_shares__ = Some(map.next_value()?);
+                            delegator_shares__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Description => {
                             if description__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("description"));
                             }
-                            description__ = map.next_value()?;
+                            description__ = map_.next_value()?;
                         }
                         GeneratedField::UnbondingHeight => {
                             if unbonding_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("unbondingHeight"));
                             }
                             unbonding_height__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::UnbondingTime => {
                             if unbonding_time__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("unbondingTime"));
                             }
-                            unbonding_time__ = map.next_value()?;
+                            unbonding_time__ = map_.next_value()?;
                         }
                         GeneratedField::Commission => {
                             if commission__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("commission"));
                             }
-                            commission__ = map.next_value()?;
+                            commission__ = map_.next_value()?;
                         }
                         GeneratedField::MinSelfDelegation => {
                             if min_self_delegation__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("minSelfDelegation"));
                             }
-                            min_self_delegation__ = Some(map.next_value()?);
+                            min_self_delegation__ = Some(map_.next_value()?);
                         }
                         GeneratedField::UnbondingOnHoldRefCount => {
                             if unbonding_on_hold_ref_count__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("unbondingOnHoldRefCount"));
                             }
                             unbonding_on_hold_ref_count__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::UnbondingIds => {
@@ -7720,7 +7724,7 @@ impl<'de> serde::Deserialize<'de> for Validator {
                                 return Err(serde::de::Error::duplicate_field("unbondingIds"));
                             }
                             unbonding_ids__ = 
-                                Some(map.next_value::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()?
+                                Some(map_.next_value::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()?
                                     .into_iter().map(|x| x.0).collect())
                             ;
                         }
diff --git a/src/prost/cosmos.tx.config.v1.serde.rs b/src/prost/cosmos.tx.config.v1.serde.rs
index 3dd5af54..d4283484 100644
--- a/src/prost/cosmos.tx.config.v1.serde.rs
+++ b/src/prost/cosmos.tx.config.v1.serde.rs
@@ -77,25 +77,25 @@ impl<'de> serde::Deserialize<'de> for Config {
                 formatter.write_str("struct cosmos.tx.config.v1.Config")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Config, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Config, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut skip_ante_handler__ = None;
                 let mut skip_post_handler__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::SkipAnteHandler => {
                             if skip_ante_handler__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("skipAnteHandler"));
                             }
-                            skip_ante_handler__ = Some(map.next_value()?);
+                            skip_ante_handler__ = Some(map_.next_value()?);
                         }
                         GeneratedField::SkipPostHandler => {
                             if skip_post_handler__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("skipPostHandler"));
                             }
-                            skip_post_handler__ = Some(map.next_value()?);
+                            skip_post_handler__ = Some(map_.next_value()?);
                         }
                     }
                 }
diff --git a/src/prost/cosmos.tx.signing.v1beta1.serde.rs b/src/prost/cosmos.tx.signing.v1beta1.serde.rs
index 2b4a2462..0a8c385c 100644
--- a/src/prost/cosmos.tx.signing.v1beta1.serde.rs
+++ b/src/prost/cosmos.tx.signing.v1beta1.serde.rs
@@ -43,10 +43,9 @@ impl<'de> serde::Deserialize<'de> for SignMode {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(SignMode::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -56,10 +55,9 @@ impl<'de> serde::Deserialize<'de> for SignMode {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(SignMode::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
@@ -108,6 +106,7 @@ impl serde::Serialize for SignatureDescriptor {
             struct_ser.serialize_field("data", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?;
         }
         struct_ser.end()
@@ -170,33 +169,33 @@ impl<'de> serde::Deserialize<'de> for SignatureDescriptor {
                 formatter.write_str("struct cosmos.tx.signing.v1beta1.SignatureDescriptor")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<SignatureDescriptor, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<SignatureDescriptor, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut public_key__ = None;
                 let mut data__ = None;
                 let mut sequence__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PublicKey => {
                             if public_key__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("publicKey"));
                             }
-                            public_key__ = map.next_value()?;
+                            public_key__ = map_.next_value()?;
                         }
                         GeneratedField::Data => {
                             if data__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("data"));
                             }
-                            data__ = map.next_value()?;
+                            data__ = map_.next_value()?;
                         }
                         GeneratedField::Sequence => {
                             if sequence__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sequence"));
                             }
                             sequence__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -289,25 +288,25 @@ impl<'de> serde::Deserialize<'de> for signature_descriptor::Data {
                 formatter.write_str("struct cosmos.tx.signing.v1beta1.SignatureDescriptor.Data")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<signature_descriptor::Data, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<signature_descriptor::Data, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut sum__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Single => {
                             if sum__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("single"));
                             }
-                            sum__ = map.next_value::<::core::option::Option<_>>()?.map(signature_descriptor::data::Sum::Single)
+                            sum__ = map_.next_value::<::core::option::Option<_>>()?.map(signature_descriptor::data::Sum::Single)
 ;
                         }
                         GeneratedField::Multi => {
                             if sum__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("multi"));
                             }
-                            sum__ = map.next_value::<::core::option::Option<_>>()?.map(signature_descriptor::data::Sum::Multi)
+                            sum__ = map_.next_value::<::core::option::Option<_>>()?.map(signature_descriptor::data::Sum::Multi)
 ;
                         }
                     }
@@ -397,25 +396,25 @@ impl<'de> serde::Deserialize<'de> for signature_descriptor::data::Multi {
                 formatter.write_str("struct cosmos.tx.signing.v1beta1.SignatureDescriptor.Data.Multi")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<signature_descriptor::data::Multi, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<signature_descriptor::data::Multi, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut bitarray__ = None;
                 let mut signatures__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Bitarray => {
                             if bitarray__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("bitarray"));
                             }
-                            bitarray__ = map.next_value()?;
+                            bitarray__ = map_.next_value()?;
                         }
                         GeneratedField::Signatures => {
                             if signatures__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signatures"));
                             }
-                            signatures__ = Some(map.next_value()?);
+                            signatures__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -444,11 +443,12 @@ impl serde::Serialize for signature_descriptor::data::Single {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.tx.signing.v1beta1.SignatureDescriptor.Data.Single", len)?;
         if true {
-            let v = SignMode::from_i32(self.mode)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.mode)))?;
+            let v = SignMode::try_from(self.mode)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.mode)))?;
             struct_ser.serialize_field("mode", &v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("signature", pbjson::private::base64::encode(&self.signature).as_str())?;
         }
         struct_ser.end()
@@ -507,26 +507,26 @@ impl<'de> serde::Deserialize<'de> for signature_descriptor::data::Single {
                 formatter.write_str("struct cosmos.tx.signing.v1beta1.SignatureDescriptor.Data.Single")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<signature_descriptor::data::Single, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<signature_descriptor::data::Single, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut mode__ = None;
                 let mut signature__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Mode => {
                             if mode__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("mode"));
                             }
-                            mode__ = Some(map.next_value::<SignMode>()? as i32);
+                            mode__ = Some(map_.next_value::<SignMode>()? as i32);
                         }
                         GeneratedField::Signature => {
                             if signature__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signature"));
                             }
                             signature__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -608,18 +608,18 @@ impl<'de> serde::Deserialize<'de> for SignatureDescriptors {
                 formatter.write_str("struct cosmos.tx.signing.v1beta1.SignatureDescriptors")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<SignatureDescriptors, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<SignatureDescriptors, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut signatures__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Signatures => {
                             if signatures__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signatures"));
                             }
-                            signatures__ = Some(map.next_value()?);
+                            signatures__ = Some(map_.next_value()?);
                         }
                     }
                 }
diff --git a/src/prost/cosmos.upgrade.module.v1.serde.rs b/src/prost/cosmos.upgrade.module.v1.serde.rs
index 6134b8dd..7aee8176 100644
--- a/src/prost/cosmos.upgrade.module.v1.serde.rs
+++ b/src/prost/cosmos.upgrade.module.v1.serde.rs
@@ -66,18 +66,18 @@ impl<'de> serde::Deserialize<'de> for Module {
                 formatter.write_str("struct cosmos.upgrade.module.v1.Module")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Module, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Module, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut authority__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Authority => {
                             if authority__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("authority"));
                             }
-                            authority__ = Some(map.next_value()?);
+                            authority__ = Some(map_.next_value()?);
                         }
                     }
                 }
diff --git a/src/prost/cosmos.upgrade.v1beta1.serde.rs b/src/prost/cosmos.upgrade.v1beta1.serde.rs
index 3514e308..de744724 100644
--- a/src/prost/cosmos.upgrade.v1beta1.serde.rs
+++ b/src/prost/cosmos.upgrade.v1beta1.serde.rs
@@ -75,25 +75,25 @@ impl<'de> serde::Deserialize<'de> for CancelSoftwareUpgradeProposal {
                 formatter.write_str("struct cosmos.upgrade.v1beta1.CancelSoftwareUpgradeProposal")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<CancelSoftwareUpgradeProposal, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<CancelSoftwareUpgradeProposal, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut title__ = None;
                 let mut description__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Title => {
                             if title__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("title"));
                             }
-                            title__ = Some(map.next_value()?);
+                            title__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Description => {
                             if description__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("description"));
                             }
-                            description__ = Some(map.next_value()?);
+                            description__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -125,6 +125,7 @@ impl serde::Serialize for ModuleVersion {
             struct_ser.serialize_field("name", &self.name)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("version", ::alloc::string::ToString::to_string(&self.version).as_str())?;
         }
         struct_ser.end()
@@ -183,26 +184,26 @@ impl<'de> serde::Deserialize<'de> for ModuleVersion {
                 formatter.write_str("struct cosmos.upgrade.v1beta1.ModuleVersion")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ModuleVersion, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ModuleVersion, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut name__ = None;
                 let mut version__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Name => {
                             if name__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("name"));
                             }
-                            name__ = Some(map.next_value()?);
+                            name__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Version => {
                             if version__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("version"));
                             }
                             version__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -284,18 +285,18 @@ impl<'de> serde::Deserialize<'de> for MsgCancelUpgrade {
                 formatter.write_str("struct cosmos.upgrade.v1beta1.MsgCancelUpgrade")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgCancelUpgrade, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgCancelUpgrade, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut authority__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Authority => {
                             if authority__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("authority"));
                             }
-                            authority__ = Some(map.next_value()?);
+                            authority__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -364,12 +365,12 @@ impl<'de> serde::Deserialize<'de> for MsgCancelUpgradeResponse {
                 formatter.write_str("struct cosmos.upgrade.v1beta1.MsgCancelUpgradeResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgCancelUpgradeResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgCancelUpgradeResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgCancelUpgradeResponse {
                 })
@@ -455,25 +456,25 @@ impl<'de> serde::Deserialize<'de> for MsgSoftwareUpgrade {
                 formatter.write_str("struct cosmos.upgrade.v1beta1.MsgSoftwareUpgrade")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgSoftwareUpgrade, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgSoftwareUpgrade, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut authority__ = None;
                 let mut plan__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Authority => {
                             if authority__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("authority"));
                             }
-                            authority__ = Some(map.next_value()?);
+                            authority__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Plan => {
                             if plan__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("plan"));
                             }
-                            plan__ = map.next_value()?;
+                            plan__ = map_.next_value()?;
                         }
                     }
                 }
@@ -543,12 +544,12 @@ impl<'de> serde::Deserialize<'de> for MsgSoftwareUpgradeResponse {
                 formatter.write_str("struct cosmos.upgrade.v1beta1.MsgSoftwareUpgradeResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgSoftwareUpgradeResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgSoftwareUpgradeResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgSoftwareUpgradeResponse {
                 })
@@ -588,6 +589,7 @@ impl serde::Serialize for Plan {
             struct_ser.serialize_field("time", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("height", ::alloc::string::ToString::to_string(&self.height).as_str())?;
         }
         if true {
@@ -662,7 +664,7 @@ impl<'de> serde::Deserialize<'de> for Plan {
                 formatter.write_str("struct cosmos.upgrade.v1beta1.Plan")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Plan, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Plan, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -671,39 +673,39 @@ impl<'de> serde::Deserialize<'de> for Plan {
                 let mut height__ = None;
                 let mut info__ = None;
                 let mut upgraded_client_state__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Name => {
                             if name__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("name"));
                             }
-                            name__ = Some(map.next_value()?);
+                            name__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Time => {
                             if time__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("time"));
                             }
-                            time__ = map.next_value()?;
+                            time__ = map_.next_value()?;
                         }
                         GeneratedField::Height => {
                             if height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("height"));
                             }
                             height__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Info => {
                             if info__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("info"));
                             }
-                            info__ = Some(map.next_value()?);
+                            info__ = Some(map_.next_value()?);
                         }
                         GeneratedField::UpgradedClientState => {
                             if upgraded_client_state__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("upgradedClientState"));
                             }
-                            upgraded_client_state__ = map.next_value()?;
+                            upgraded_client_state__ = map_.next_value()?;
                         }
                     }
                 }
@@ -787,18 +789,18 @@ impl<'de> serde::Deserialize<'de> for QueryAppliedPlanRequest {
                 formatter.write_str("struct cosmos.upgrade.v1beta1.QueryAppliedPlanRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryAppliedPlanRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryAppliedPlanRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut name__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Name => {
                             if name__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("name"));
                             }
-                            name__ = Some(map.next_value()?);
+                            name__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -823,6 +825,7 @@ impl serde::Serialize for QueryAppliedPlanResponse {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.upgrade.v1beta1.QueryAppliedPlanResponse", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("height", ::alloc::string::ToString::to_string(&self.height).as_str())?;
         }
         struct_ser.end()
@@ -878,19 +881,19 @@ impl<'de> serde::Deserialize<'de> for QueryAppliedPlanResponse {
                 formatter.write_str("struct cosmos.upgrade.v1beta1.QueryAppliedPlanResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryAppliedPlanResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryAppliedPlanResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Height => {
                             if height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("height"));
                             }
                             height__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -960,12 +963,12 @@ impl<'de> serde::Deserialize<'de> for QueryAuthorityRequest {
                 formatter.write_str("struct cosmos.upgrade.v1beta1.QueryAuthorityRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryAuthorityRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryAuthorityRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(QueryAuthorityRequest {
                 })
@@ -1042,18 +1045,18 @@ impl<'de> serde::Deserialize<'de> for QueryAuthorityResponse {
                 formatter.write_str("struct cosmos.upgrade.v1beta1.QueryAuthorityResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryAuthorityResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryAuthorityResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut address__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Address => {
                             if address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("address"));
                             }
-                            address__ = Some(map.next_value()?);
+                            address__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1122,12 +1125,12 @@ impl<'de> serde::Deserialize<'de> for QueryCurrentPlanRequest {
                 formatter.write_str("struct cosmos.upgrade.v1beta1.QueryCurrentPlanRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryCurrentPlanRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryCurrentPlanRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(QueryCurrentPlanRequest {
                 })
@@ -1204,18 +1207,18 @@ impl<'de> serde::Deserialize<'de> for QueryCurrentPlanResponse {
                 formatter.write_str("struct cosmos.upgrade.v1beta1.QueryCurrentPlanResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryCurrentPlanResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryCurrentPlanResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut plan__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Plan => {
                             if plan__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("plan"));
                             }
-                            plan__ = map.next_value()?;
+                            plan__ = map_.next_value()?;
                         }
                     }
                 }
@@ -1296,18 +1299,18 @@ impl<'de> serde::Deserialize<'de> for QueryModuleVersionsRequest {
                 formatter.write_str("struct cosmos.upgrade.v1beta1.QueryModuleVersionsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryModuleVersionsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryModuleVersionsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut module_name__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ModuleName => {
                             if module_name__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("moduleName"));
                             }
-                            module_name__ = Some(map.next_value()?);
+                            module_name__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1388,18 +1391,18 @@ impl<'de> serde::Deserialize<'de> for QueryModuleVersionsResponse {
                 formatter.write_str("struct cosmos.upgrade.v1beta1.QueryModuleVersionsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryModuleVersionsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryModuleVersionsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut module_versions__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ModuleVersions => {
                             if module_versions__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("moduleVersions"));
                             }
-                            module_versions__ = Some(map.next_value()?);
+                            module_versions__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1424,6 +1427,7 @@ impl serde::Serialize for QueryUpgradedConsensusStateRequest {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.upgrade.v1beta1.QueryUpgradedConsensusStateRequest", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("lastHeight", ::alloc::string::ToString::to_string(&self.last_height).as_str())?;
         }
         struct_ser.end()
@@ -1480,19 +1484,19 @@ impl<'de> serde::Deserialize<'de> for QueryUpgradedConsensusStateRequest {
                 formatter.write_str("struct cosmos.upgrade.v1beta1.QueryUpgradedConsensusStateRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryUpgradedConsensusStateRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryUpgradedConsensusStateRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut last_height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::LastHeight => {
                             if last_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("lastHeight"));
                             }
                             last_height__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -1518,6 +1522,7 @@ impl serde::Serialize for QueryUpgradedConsensusStateResponse {
         }
         let mut struct_ser = serializer.serialize_struct("cosmos.upgrade.v1beta1.QueryUpgradedConsensusStateResponse", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("upgradedConsensusState", pbjson::private::base64::encode(&self.upgraded_consensus_state).as_str())?;
         }
         struct_ser.end()
@@ -1574,19 +1579,19 @@ impl<'de> serde::Deserialize<'de> for QueryUpgradedConsensusStateResponse {
                 formatter.write_str("struct cosmos.upgrade.v1beta1.QueryUpgradedConsensusStateResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryUpgradedConsensusStateResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryUpgradedConsensusStateResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut upgraded_consensus_state__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::UpgradedConsensusState => {
                             if upgraded_consensus_state__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("upgradedConsensusState"));
                             }
                             upgraded_consensus_state__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -1685,32 +1690,32 @@ impl<'de> serde::Deserialize<'de> for SoftwareUpgradeProposal {
                 formatter.write_str("struct cosmos.upgrade.v1beta1.SoftwareUpgradeProposal")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<SoftwareUpgradeProposal, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<SoftwareUpgradeProposal, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut title__ = None;
                 let mut description__ = None;
                 let mut plan__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Title => {
                             if title__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("title"));
                             }
-                            title__ = Some(map.next_value()?);
+                            title__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Description => {
                             if description__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("description"));
                             }
-                            description__ = Some(map.next_value()?);
+                            description__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Plan => {
                             if plan__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("plan"));
                             }
-                            plan__ = map.next_value()?;
+                            plan__ = map_.next_value()?;
                         }
                     }
                 }
diff --git a/src/prost/google.api.serde.rs b/src/prost/google.api.serde.rs
index ec0bc7a2..9e4882b4 100644
--- a/src/prost/google.api.serde.rs
+++ b/src/prost/google.api.serde.rs
@@ -75,25 +75,25 @@ impl<'de> serde::Deserialize<'de> for CustomHttpPattern {
                 formatter.write_str("struct google.api.CustomHttpPattern")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<CustomHttpPattern, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<CustomHttpPattern, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut kind__ = None;
                 let mut path__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Kind => {
                             if kind__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("kind"));
                             }
-                            kind__ = Some(map.next_value()?);
+                            kind__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Path => {
                             if path__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("path"));
                             }
-                            path__ = Some(map.next_value()?);
+                            path__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -184,25 +184,25 @@ impl<'de> serde::Deserialize<'de> for Http {
                 formatter.write_str("struct google.api.Http")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Http, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Http, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut rules__ = None;
                 let mut fully_decode_reserved_expansion__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Rules => {
                             if rules__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("rules"));
                             }
-                            rules__ = Some(map.next_value()?);
+                            rules__ = Some(map_.next_value()?);
                         }
                         GeneratedField::FullyDecodeReservedExpansion => {
                             if fully_decode_reserved_expansion__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("fullyDecodeReservedExpansion"));
                             }
-                            fully_decode_reserved_expansion__ = Some(map.next_value()?);
+                            fully_decode_reserved_expansion__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -355,7 +355,7 @@ impl<'de> serde::Deserialize<'de> for HttpRule {
                 formatter.write_str("struct google.api.HttpRule")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<HttpRule, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<HttpRule, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -364,67 +364,67 @@ impl<'de> serde::Deserialize<'de> for HttpRule {
                 let mut response_body__ = None;
                 let mut additional_bindings__ = None;
                 let mut pattern__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Selector => {
                             if selector__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("selector"));
                             }
-                            selector__ = Some(map.next_value()?);
+                            selector__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Body => {
                             if body__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("body"));
                             }
-                            body__ = Some(map.next_value()?);
+                            body__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ResponseBody => {
                             if response_body__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("responseBody"));
                             }
-                            response_body__ = Some(map.next_value()?);
+                            response_body__ = Some(map_.next_value()?);
                         }
                         GeneratedField::AdditionalBindings => {
                             if additional_bindings__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("additionalBindings"));
                             }
-                            additional_bindings__ = Some(map.next_value()?);
+                            additional_bindings__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Get => {
                             if pattern__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("get"));
                             }
-                            pattern__ = map.next_value::<::core::option::Option<_>>()?.map(http_rule::Pattern::Get);
+                            pattern__ = map_.next_value::<::core::option::Option<_>>()?.map(http_rule::Pattern::Get);
                         }
                         GeneratedField::Put => {
                             if pattern__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("put"));
                             }
-                            pattern__ = map.next_value::<::core::option::Option<_>>()?.map(http_rule::Pattern::Put);
+                            pattern__ = map_.next_value::<::core::option::Option<_>>()?.map(http_rule::Pattern::Put);
                         }
                         GeneratedField::Post => {
                             if pattern__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("post"));
                             }
-                            pattern__ = map.next_value::<::core::option::Option<_>>()?.map(http_rule::Pattern::Post);
+                            pattern__ = map_.next_value::<::core::option::Option<_>>()?.map(http_rule::Pattern::Post);
                         }
                         GeneratedField::Delete => {
                             if pattern__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("delete"));
                             }
-                            pattern__ = map.next_value::<::core::option::Option<_>>()?.map(http_rule::Pattern::Delete);
+                            pattern__ = map_.next_value::<::core::option::Option<_>>()?.map(http_rule::Pattern::Delete);
                         }
                         GeneratedField::Patch => {
                             if pattern__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("patch"));
                             }
-                            pattern__ = map.next_value::<::core::option::Option<_>>()?.map(http_rule::Pattern::Patch);
+                            pattern__ = map_.next_value::<::core::option::Option<_>>()?.map(http_rule::Pattern::Patch);
                         }
                         GeneratedField::Custom => {
                             if pattern__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("custom"));
                             }
-                            pattern__ = map.next_value::<::core::option::Option<_>>()?.map(http_rule::Pattern::Custom)
+                            pattern__ = map_.next_value::<::core::option::Option<_>>()?.map(http_rule::Pattern::Custom)
 ;
                         }
                     }
diff --git a/src/prost/google.protobuf.serde.rs b/src/prost/google.protobuf.serde.rs
index 1467d307..5a7056e1 100644
--- a/src/prost/google.protobuf.serde.rs
+++ b/src/prost/google.protobuf.serde.rs
@@ -17,6 +17,7 @@ impl serde::Serialize for Any {
             struct_ser.serialize_field("typeUrl", &self.type_url)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
         }
         struct_ser.end()
@@ -76,26 +77,26 @@ impl<'de> serde::Deserialize<'de> for Any {
                 formatter.write_str("struct google.protobuf.Any")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Any, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Any, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut type_url__ = None;
                 let mut value__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::TypeUrl => {
                             if type_url__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("typeUrl"));
                             }
-                            type_url__ = Some(map.next_value()?);
+                            type_url__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Value => {
                             if value__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("value"));
                             }
                             value__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -264,7 +265,7 @@ impl<'de> serde::Deserialize<'de> for DescriptorProto {
                 formatter.write_str("struct google.protobuf.DescriptorProto")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<DescriptorProto, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<DescriptorProto, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -278,67 +279,67 @@ impl<'de> serde::Deserialize<'de> for DescriptorProto {
                 let mut options__ = None;
                 let mut reserved_range__ = None;
                 let mut reserved_name__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Name => {
                             if name__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("name"));
                             }
-                            name__ = map.next_value()?;
+                            name__ = map_.next_value()?;
                         }
                         GeneratedField::Field => {
                             if field__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("field"));
                             }
-                            field__ = Some(map.next_value()?);
+                            field__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Extension => {
                             if extension__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("extension"));
                             }
-                            extension__ = Some(map.next_value()?);
+                            extension__ = Some(map_.next_value()?);
                         }
                         GeneratedField::NestedType => {
                             if nested_type__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("nestedType"));
                             }
-                            nested_type__ = Some(map.next_value()?);
+                            nested_type__ = Some(map_.next_value()?);
                         }
                         GeneratedField::EnumType => {
                             if enum_type__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("enumType"));
                             }
-                            enum_type__ = Some(map.next_value()?);
+                            enum_type__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ExtensionRange => {
                             if extension_range__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("extensionRange"));
                             }
-                            extension_range__ = Some(map.next_value()?);
+                            extension_range__ = Some(map_.next_value()?);
                         }
                         GeneratedField::OneofDecl => {
                             if oneof_decl__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("oneofDecl"));
                             }
-                            oneof_decl__ = Some(map.next_value()?);
+                            oneof_decl__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Options => {
                             if options__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("options"));
                             }
-                            options__ = map.next_value()?;
+                            options__ = map_.next_value()?;
                         }
                         GeneratedField::ReservedRange => {
                             if reserved_range__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("reservedRange"));
                             }
-                            reserved_range__ = Some(map.next_value()?);
+                            reserved_range__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ReservedName => {
                             if reserved_name__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("reservedName"));
                             }
-                            reserved_name__ = Some(map.next_value()?);
+                            reserved_name__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -445,21 +446,21 @@ impl<'de> serde::Deserialize<'de> for descriptor_proto::ExtensionRange {
                 formatter.write_str("struct google.protobuf.DescriptorProto.ExtensionRange")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<descriptor_proto::ExtensionRange, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<descriptor_proto::ExtensionRange, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut start__ = None;
                 let mut end__ = None;
                 let mut options__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Start => {
                             if start__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("start"));
                             }
                             start__ = 
-                                map.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
+                                map_.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
                             ;
                         }
                         GeneratedField::End => {
@@ -467,14 +468,14 @@ impl<'de> serde::Deserialize<'de> for descriptor_proto::ExtensionRange {
                                 return Err(serde::de::Error::duplicate_field("end"));
                             }
                             end__ = 
-                                map.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
+                                map_.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
                             ;
                         }
                         GeneratedField::Options => {
                             if options__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("options"));
                             }
-                            options__ = map.next_value()?;
+                            options__ = map_.next_value()?;
                         }
                     }
                 }
@@ -565,20 +566,20 @@ impl<'de> serde::Deserialize<'de> for descriptor_proto::ReservedRange {
                 formatter.write_str("struct google.protobuf.DescriptorProto.ReservedRange")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<descriptor_proto::ReservedRange, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<descriptor_proto::ReservedRange, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut start__ = None;
                 let mut end__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Start => {
                             if start__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("start"));
                             }
                             start__ = 
-                                map.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
+                                map_.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
                             ;
                         }
                         GeneratedField::End => {
@@ -586,7 +587,7 @@ impl<'de> serde::Deserialize<'de> for descriptor_proto::ReservedRange {
                                 return Err(serde::de::Error::duplicate_field("end"));
                             }
                             end__ = 
-                                map.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
+                                map_.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
                             ;
                         }
                     }
@@ -616,6 +617,7 @@ impl serde::Serialize for Duration {
         }
         let mut struct_ser = serializer.serialize_struct("google.protobuf.Duration", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("seconds", ::alloc::string::ToString::to_string(&self.seconds).as_str())?;
         }
         if true {
@@ -677,20 +679,20 @@ impl<'de> serde::Deserialize<'de> for Duration {
                 formatter.write_str("struct google.protobuf.Duration")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Duration, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Duration, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut seconds__ = None;
                 let mut nanos__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Seconds => {
                             if seconds__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("seconds"));
                             }
                             seconds__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Nanos => {
@@ -698,7 +700,7 @@ impl<'de> serde::Deserialize<'de> for Duration {
                                 return Err(serde::de::Error::duplicate_field("nanos"));
                             }
                             nanos__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -763,10 +765,9 @@ impl<'de> serde::Deserialize<'de> for Edition {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(Edition::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -776,10 +777,9 @@ impl<'de> serde::Deserialize<'de> for Edition {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(Edition::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
@@ -912,7 +912,7 @@ impl<'de> serde::Deserialize<'de> for EnumDescriptorProto {
                 formatter.write_str("struct google.protobuf.EnumDescriptorProto")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<EnumDescriptorProto, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<EnumDescriptorProto, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -921,37 +921,37 @@ impl<'de> serde::Deserialize<'de> for EnumDescriptorProto {
                 let mut options__ = None;
                 let mut reserved_range__ = None;
                 let mut reserved_name__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Name => {
                             if name__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("name"));
                             }
-                            name__ = map.next_value()?;
+                            name__ = map_.next_value()?;
                         }
                         GeneratedField::Value => {
                             if value__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("value"));
                             }
-                            value__ = Some(map.next_value()?);
+                            value__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Options => {
                             if options__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("options"));
                             }
-                            options__ = map.next_value()?;
+                            options__ = map_.next_value()?;
                         }
                         GeneratedField::ReservedRange => {
                             if reserved_range__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("reservedRange"));
                             }
-                            reserved_range__ = Some(map.next_value()?);
+                            reserved_range__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ReservedName => {
                             if reserved_name__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("reservedName"));
                             }
-                            reserved_name__ = Some(map.next_value()?);
+                            reserved_name__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1044,20 +1044,20 @@ impl<'de> serde::Deserialize<'de> for enum_descriptor_proto::EnumReservedRange {
                 formatter.write_str("struct google.protobuf.EnumDescriptorProto.EnumReservedRange")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<enum_descriptor_proto::EnumReservedRange, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<enum_descriptor_proto::EnumReservedRange, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut start__ = None;
                 let mut end__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Start => {
                             if start__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("start"));
                             }
                             start__ = 
-                                map.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
+                                map_.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
                             ;
                         }
                         GeneratedField::End => {
@@ -1065,7 +1065,7 @@ impl<'de> serde::Deserialize<'de> for enum_descriptor_proto::EnumReservedRange {
                                 return Err(serde::de::Error::duplicate_field("end"));
                             }
                             end__ = 
-                                map.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
+                                map_.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
                             ;
                         }
                     }
@@ -1186,7 +1186,7 @@ impl<'de> serde::Deserialize<'de> for EnumOptions {
                 formatter.write_str("struct google.protobuf.EnumOptions")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<EnumOptions, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<EnumOptions, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -1195,37 +1195,37 @@ impl<'de> serde::Deserialize<'de> for EnumOptions {
                 let mut deprecated_legacy_json_field_conflicts__ = None;
                 let mut features__ = None;
                 let mut uninterpreted_option__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::AllowAlias => {
                             if allow_alias__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("allowAlias"));
                             }
-                            allow_alias__ = map.next_value()?;
+                            allow_alias__ = map_.next_value()?;
                         }
                         GeneratedField::Deprecated => {
                             if deprecated__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("deprecated"));
                             }
-                            deprecated__ = map.next_value()?;
+                            deprecated__ = map_.next_value()?;
                         }
                         GeneratedField::DeprecatedLegacyJsonFieldConflicts => {
                             if deprecated_legacy_json_field_conflicts__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("deprecatedLegacyJsonFieldConflicts"));
                             }
-                            deprecated_legacy_json_field_conflicts__ = map.next_value()?;
+                            deprecated_legacy_json_field_conflicts__ = map_.next_value()?;
                         }
                         GeneratedField::Features => {
                             if features__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("features"));
                             }
-                            features__ = map.next_value()?;
+                            features__ = map_.next_value()?;
                         }
                         GeneratedField::UninterpretedOption => {
                             if uninterpreted_option__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("uninterpretedOption"));
                             }
-                            uninterpreted_option__ = Some(map.next_value()?);
+                            uninterpreted_option__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1327,34 +1327,34 @@ impl<'de> serde::Deserialize<'de> for EnumValueDescriptorProto {
                 formatter.write_str("struct google.protobuf.EnumValueDescriptorProto")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<EnumValueDescriptorProto, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<EnumValueDescriptorProto, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut name__ = None;
                 let mut number__ = None;
                 let mut options__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Name => {
                             if name__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("name"));
                             }
-                            name__ = map.next_value()?;
+                            name__ = map_.next_value()?;
                         }
                         GeneratedField::Number => {
                             if number__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("number"));
                             }
                             number__ = 
-                                map.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
+                                map_.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
                             ;
                         }
                         GeneratedField::Options => {
                             if options__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("options"));
                             }
-                            options__ = map.next_value()?;
+                            options__ = map_.next_value()?;
                         }
                     }
                 }
@@ -1465,7 +1465,7 @@ impl<'de> serde::Deserialize<'de> for EnumValueOptions {
                 formatter.write_str("struct google.protobuf.EnumValueOptions")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<EnumValueOptions, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<EnumValueOptions, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -1473,31 +1473,31 @@ impl<'de> serde::Deserialize<'de> for EnumValueOptions {
                 let mut features__ = None;
                 let mut debug_redact__ = None;
                 let mut uninterpreted_option__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Deprecated => {
                             if deprecated__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("deprecated"));
                             }
-                            deprecated__ = map.next_value()?;
+                            deprecated__ = map_.next_value()?;
                         }
                         GeneratedField::Features => {
                             if features__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("features"));
                             }
-                            features__ = map.next_value()?;
+                            features__ = map_.next_value()?;
                         }
                         GeneratedField::DebugRedact => {
                             if debug_redact__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("debugRedact"));
                             }
-                            debug_redact__ = map.next_value()?;
+                            debug_redact__ = map_.next_value()?;
                         }
                         GeneratedField::UninterpretedOption => {
                             if uninterpreted_option__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("uninterpretedOption"));
                             }
-                            uninterpreted_option__ = Some(map.next_value()?);
+                            uninterpreted_option__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1543,8 +1543,8 @@ impl serde::Serialize for ExtensionRangeOptions {
             struct_ser.serialize_field("features", v)?;
         }
         if let Some(v) = self.verification.as_ref() {
-            let v = extension_range_options::VerificationState::from_i32(*v)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
+            let v = extension_range_options::VerificationState::try_from(*v)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
             struct_ser.serialize_field("verification", &v)?;
         }
         struct_ser.end()
@@ -1610,7 +1610,7 @@ impl<'de> serde::Deserialize<'de> for ExtensionRangeOptions {
                 formatter.write_str("struct google.protobuf.ExtensionRangeOptions")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ExtensionRangeOptions, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ExtensionRangeOptions, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -1618,31 +1618,31 @@ impl<'de> serde::Deserialize<'de> for ExtensionRangeOptions {
                 let mut declaration__ = None;
                 let mut features__ = None;
                 let mut verification__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::UninterpretedOption => {
                             if uninterpreted_option__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("uninterpretedOption"));
                             }
-                            uninterpreted_option__ = Some(map.next_value()?);
+                            uninterpreted_option__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Declaration => {
                             if declaration__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("declaration"));
                             }
-                            declaration__ = Some(map.next_value()?);
+                            declaration__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Features => {
                             if features__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("features"));
                             }
-                            features__ = map.next_value()?;
+                            features__ = map_.next_value()?;
                         }
                         GeneratedField::Verification => {
                             if verification__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("verification"));
                             }
-                            verification__ = map.next_value::<::core::option::Option<extension_range_options::VerificationState>>()?.map(|x| x as i32);
+                            verification__ = map_.next_value::<::core::option::Option<extension_range_options::VerificationState>>()?.map(|x| x as i32);
                         }
                     }
                 }
@@ -1762,7 +1762,7 @@ impl<'de> serde::Deserialize<'de> for extension_range_options::Declaration {
                 formatter.write_str("struct google.protobuf.ExtensionRangeOptions.Declaration")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<extension_range_options::Declaration, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<extension_range_options::Declaration, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -1771,39 +1771,39 @@ impl<'de> serde::Deserialize<'de> for extension_range_options::Declaration {
                 let mut r#type__ = None;
                 let mut reserved__ = None;
                 let mut repeated__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Number => {
                             if number__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("number"));
                             }
                             number__ = 
-                                map.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
+                                map_.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
                             ;
                         }
                         GeneratedField::FullName => {
                             if full_name__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("fullName"));
                             }
-                            full_name__ = map.next_value()?;
+                            full_name__ = map_.next_value()?;
                         }
                         GeneratedField::Type => {
                             if r#type__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("type"));
                             }
-                            r#type__ = map.next_value()?;
+                            r#type__ = map_.next_value()?;
                         }
                         GeneratedField::Reserved => {
                             if reserved__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("reserved"));
                             }
-                            reserved__ = map.next_value()?;
+                            reserved__ = map_.next_value()?;
                         }
                         GeneratedField::Repeated => {
                             if repeated__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("repeated"));
                             }
-                            repeated__ = map.next_value()?;
+                            repeated__ = map_.next_value()?;
                         }
                     }
                 }
@@ -1856,10 +1856,9 @@ impl<'de> serde::Deserialize<'de> for extension_range_options::VerificationState
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(extension_range_options::VerificationState::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -1869,10 +1868,9 @@ impl<'de> serde::Deserialize<'de> for extension_range_options::VerificationState
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(extension_range_options::VerificationState::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
@@ -1920,33 +1918,33 @@ impl serde::Serialize for FeatureSet {
         }
         let mut struct_ser = serializer.serialize_struct("google.protobuf.FeatureSet", len)?;
         if let Some(v) = self.field_presence.as_ref() {
-            let v = feature_set::FieldPresence::from_i32(*v)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
+            let v = feature_set::FieldPresence::try_from(*v)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
             struct_ser.serialize_field("fieldPresence", &v)?;
         }
         if let Some(v) = self.enum_type.as_ref() {
-            let v = feature_set::EnumType::from_i32(*v)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
+            let v = feature_set::EnumType::try_from(*v)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
             struct_ser.serialize_field("enumType", &v)?;
         }
         if let Some(v) = self.repeated_field_encoding.as_ref() {
-            let v = feature_set::RepeatedFieldEncoding::from_i32(*v)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
+            let v = feature_set::RepeatedFieldEncoding::try_from(*v)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
             struct_ser.serialize_field("repeatedFieldEncoding", &v)?;
         }
         if let Some(v) = self.utf8_validation.as_ref() {
-            let v = feature_set::Utf8Validation::from_i32(*v)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
+            let v = feature_set::Utf8Validation::try_from(*v)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
             struct_ser.serialize_field("utf8Validation", &v)?;
         }
         if let Some(v) = self.message_encoding.as_ref() {
-            let v = feature_set::MessageEncoding::from_i32(*v)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
+            let v = feature_set::MessageEncoding::try_from(*v)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
             struct_ser.serialize_field("messageEncoding", &v)?;
         }
         if let Some(v) = self.json_format.as_ref() {
-            let v = feature_set::JsonFormat::from_i32(*v)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
+            let v = feature_set::JsonFormat::try_from(*v)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
             struct_ser.serialize_field("jsonFormat", &v)?;
         }
         struct_ser.end()
@@ -2023,7 +2021,7 @@ impl<'de> serde::Deserialize<'de> for FeatureSet {
                 formatter.write_str("struct google.protobuf.FeatureSet")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<FeatureSet, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<FeatureSet, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -2033,43 +2031,43 @@ impl<'de> serde::Deserialize<'de> for FeatureSet {
                 let mut utf8_validation__ = None;
                 let mut message_encoding__ = None;
                 let mut json_format__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::FieldPresence => {
                             if field_presence__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("fieldPresence"));
                             }
-                            field_presence__ = map.next_value::<::core::option::Option<feature_set::FieldPresence>>()?.map(|x| x as i32);
+                            field_presence__ = map_.next_value::<::core::option::Option<feature_set::FieldPresence>>()?.map(|x| x as i32);
                         }
                         GeneratedField::EnumType => {
                             if enum_type__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("enumType"));
                             }
-                            enum_type__ = map.next_value::<::core::option::Option<feature_set::EnumType>>()?.map(|x| x as i32);
+                            enum_type__ = map_.next_value::<::core::option::Option<feature_set::EnumType>>()?.map(|x| x as i32);
                         }
                         GeneratedField::RepeatedFieldEncoding => {
                             if repeated_field_encoding__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("repeatedFieldEncoding"));
                             }
-                            repeated_field_encoding__ = map.next_value::<::core::option::Option<feature_set::RepeatedFieldEncoding>>()?.map(|x| x as i32);
+                            repeated_field_encoding__ = map_.next_value::<::core::option::Option<feature_set::RepeatedFieldEncoding>>()?.map(|x| x as i32);
                         }
                         GeneratedField::Utf8Validation => {
                             if utf8_validation__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("utf8Validation"));
                             }
-                            utf8_validation__ = map.next_value::<::core::option::Option<feature_set::Utf8Validation>>()?.map(|x| x as i32);
+                            utf8_validation__ = map_.next_value::<::core::option::Option<feature_set::Utf8Validation>>()?.map(|x| x as i32);
                         }
                         GeneratedField::MessageEncoding => {
                             if message_encoding__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("messageEncoding"));
                             }
-                            message_encoding__ = map.next_value::<::core::option::Option<feature_set::MessageEncoding>>()?.map(|x| x as i32);
+                            message_encoding__ = map_.next_value::<::core::option::Option<feature_set::MessageEncoding>>()?.map(|x| x as i32);
                         }
                         GeneratedField::JsonFormat => {
                             if json_format__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("jsonFormat"));
                             }
-                            json_format__ = map.next_value::<::core::option::Option<feature_set::JsonFormat>>()?.map(|x| x as i32);
+                            json_format__ = map_.next_value::<::core::option::Option<feature_set::JsonFormat>>()?.map(|x| x as i32);
                         }
                     }
                 }
@@ -2125,10 +2123,9 @@ impl<'de> serde::Deserialize<'de> for feature_set::EnumType {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(feature_set::EnumType::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -2138,10 +2135,9 @@ impl<'de> serde::Deserialize<'de> for feature_set::EnumType {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(feature_set::EnumType::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
@@ -2203,10 +2199,9 @@ impl<'de> serde::Deserialize<'de> for feature_set::FieldPresence {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(feature_set::FieldPresence::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -2216,10 +2211,9 @@ impl<'de> serde::Deserialize<'de> for feature_set::FieldPresence {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(feature_set::FieldPresence::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
@@ -2280,10 +2274,9 @@ impl<'de> serde::Deserialize<'de> for feature_set::JsonFormat {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(feature_set::JsonFormat::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -2293,10 +2286,9 @@ impl<'de> serde::Deserialize<'de> for feature_set::JsonFormat {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(feature_set::JsonFormat::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
@@ -2356,10 +2348,9 @@ impl<'de> serde::Deserialize<'de> for feature_set::MessageEncoding {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(feature_set::MessageEncoding::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -2369,10 +2360,9 @@ impl<'de> serde::Deserialize<'de> for feature_set::MessageEncoding {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(feature_set::MessageEncoding::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
@@ -2432,10 +2422,9 @@ impl<'de> serde::Deserialize<'de> for feature_set::RepeatedFieldEncoding {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(feature_set::RepeatedFieldEncoding::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -2445,10 +2434,9 @@ impl<'de> serde::Deserialize<'de> for feature_set::RepeatedFieldEncoding {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(feature_set::RepeatedFieldEncoding::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
@@ -2508,10 +2496,9 @@ impl<'de> serde::Deserialize<'de> for feature_set::Utf8Validation {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(feature_set::Utf8Validation::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -2521,10 +2508,9 @@ impl<'de> serde::Deserialize<'de> for feature_set::Utf8Validation {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(feature_set::Utf8Validation::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
@@ -2567,13 +2553,13 @@ impl serde::Serialize for FeatureSetDefaults {
             struct_ser.serialize_field("defaults", &self.defaults)?;
         }
         if let Some(v) = self.minimum_edition.as_ref() {
-            let v = Edition::from_i32(*v)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
+            let v = Edition::try_from(*v)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
             struct_ser.serialize_field("minimumEdition", &v)?;
         }
         if let Some(v) = self.maximum_edition.as_ref() {
-            let v = Edition::from_i32(*v)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
+            let v = Edition::try_from(*v)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
             struct_ser.serialize_field("maximumEdition", &v)?;
         }
         struct_ser.end()
@@ -2637,32 +2623,32 @@ impl<'de> serde::Deserialize<'de> for FeatureSetDefaults {
                 formatter.write_str("struct google.protobuf.FeatureSetDefaults")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<FeatureSetDefaults, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<FeatureSetDefaults, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut defaults__ = None;
                 let mut minimum_edition__ = None;
                 let mut maximum_edition__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Defaults => {
                             if defaults__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("defaults"));
                             }
-                            defaults__ = Some(map.next_value()?);
+                            defaults__ = Some(map_.next_value()?);
                         }
                         GeneratedField::MinimumEdition => {
                             if minimum_edition__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("minimumEdition"));
                             }
-                            minimum_edition__ = map.next_value::<::core::option::Option<Edition>>()?.map(|x| x as i32);
+                            minimum_edition__ = map_.next_value::<::core::option::Option<Edition>>()?.map(|x| x as i32);
                         }
                         GeneratedField::MaximumEdition => {
                             if maximum_edition__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("maximumEdition"));
                             }
-                            maximum_edition__ = map.next_value::<::core::option::Option<Edition>>()?.map(|x| x as i32);
+                            maximum_edition__ = map_.next_value::<::core::option::Option<Edition>>()?.map(|x| x as i32);
                         }
                     }
                 }
@@ -2692,8 +2678,8 @@ impl serde::Serialize for feature_set_defaults::FeatureSetEditionDefault {
         }
         let mut struct_ser = serializer.serialize_struct("google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault", len)?;
         if let Some(v) = self.edition.as_ref() {
-            let v = Edition::from_i32(*v)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
+            let v = Edition::try_from(*v)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
             struct_ser.serialize_field("edition", &v)?;
         }
         if let Some(v) = self.features.as_ref() {
@@ -2755,25 +2741,25 @@ impl<'de> serde::Deserialize<'de> for feature_set_defaults::FeatureSetEditionDef
                 formatter.write_str("struct google.protobuf.FeatureSetDefaults.FeatureSetEditionDefault")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<feature_set_defaults::FeatureSetEditionDefault, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<feature_set_defaults::FeatureSetEditionDefault, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut edition__ = None;
                 let mut features__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Edition => {
                             if edition__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("edition"));
                             }
-                            edition__ = map.next_value::<::core::option::Option<Edition>>()?.map(|x| x as i32);
+                            edition__ = map_.next_value::<::core::option::Option<Edition>>()?.map(|x| x as i32);
                         }
                         GeneratedField::Features => {
                             if features__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("features"));
                             }
-                            features__ = map.next_value()?;
+                            features__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2835,13 +2821,13 @@ impl serde::Serialize for FieldDescriptorProto {
             struct_ser.serialize_field("number", v)?;
         }
         if let Some(v) = self.label.as_ref() {
-            let v = field_descriptor_proto::Label::from_i32(*v)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
+            let v = field_descriptor_proto::Label::try_from(*v)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
             struct_ser.serialize_field("label", &v)?;
         }
         if let Some(v) = self.r#type.as_ref() {
-            let v = field_descriptor_proto::Type::from_i32(*v)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
+            let v = field_descriptor_proto::Type::try_from(*v)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
             struct_ser.serialize_field("type", &v)?;
         }
         if let Some(v) = self.type_name.as_ref() {
@@ -2953,7 +2939,7 @@ impl<'de> serde::Deserialize<'de> for FieldDescriptorProto {
                 formatter.write_str("struct google.protobuf.FieldDescriptorProto")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<FieldDescriptorProto, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<FieldDescriptorProto, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -2968,77 +2954,77 @@ impl<'de> serde::Deserialize<'de> for FieldDescriptorProto {
                 let mut json_name__ = None;
                 let mut options__ = None;
                 let mut proto3_optional__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Name => {
                             if name__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("name"));
                             }
-                            name__ = map.next_value()?;
+                            name__ = map_.next_value()?;
                         }
                         GeneratedField::Number => {
                             if number__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("number"));
                             }
                             number__ = 
-                                map.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
+                                map_.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
                             ;
                         }
                         GeneratedField::Label => {
                             if label__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("label"));
                             }
-                            label__ = map.next_value::<::core::option::Option<field_descriptor_proto::Label>>()?.map(|x| x as i32);
+                            label__ = map_.next_value::<::core::option::Option<field_descriptor_proto::Label>>()?.map(|x| x as i32);
                         }
                         GeneratedField::Type => {
                             if r#type__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("type"));
                             }
-                            r#type__ = map.next_value::<::core::option::Option<field_descriptor_proto::Type>>()?.map(|x| x as i32);
+                            r#type__ = map_.next_value::<::core::option::Option<field_descriptor_proto::Type>>()?.map(|x| x as i32);
                         }
                         GeneratedField::TypeName => {
                             if type_name__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("typeName"));
                             }
-                            type_name__ = map.next_value()?;
+                            type_name__ = map_.next_value()?;
                         }
                         GeneratedField::Extendee => {
                             if extendee__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("extendee"));
                             }
-                            extendee__ = map.next_value()?;
+                            extendee__ = map_.next_value()?;
                         }
                         GeneratedField::DefaultValue => {
                             if default_value__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("defaultValue"));
                             }
-                            default_value__ = map.next_value()?;
+                            default_value__ = map_.next_value()?;
                         }
                         GeneratedField::OneofIndex => {
                             if oneof_index__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("oneofIndex"));
                             }
                             oneof_index__ = 
-                                map.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
+                                map_.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
                             ;
                         }
                         GeneratedField::JsonName => {
                             if json_name__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("jsonName"));
                             }
-                            json_name__ = map.next_value()?;
+                            json_name__ = map_.next_value()?;
                         }
                         GeneratedField::Options => {
                             if options__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("options"));
                             }
-                            options__ = map.next_value()?;
+                            options__ = map_.next_value()?;
                         }
                         GeneratedField::Proto3Optional => {
                             if proto3_optional__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proto3Optional"));
                             }
-                            proto3_optional__ = map.next_value()?;
+                            proto3_optional__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3099,10 +3085,9 @@ impl<'de> serde::Deserialize<'de> for field_descriptor_proto::Label {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(field_descriptor_proto::Label::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -3112,10 +3097,9 @@ impl<'de> serde::Deserialize<'de> for field_descriptor_proto::Label {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(field_descriptor_proto::Label::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
@@ -3205,10 +3189,9 @@ impl<'de> serde::Deserialize<'de> for field_descriptor_proto::Type {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(field_descriptor_proto::Type::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -3218,10 +3201,9 @@ impl<'de> serde::Deserialize<'de> for field_descriptor_proto::Type {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(field_descriptor_proto::Type::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
@@ -3306,16 +3288,16 @@ impl serde::Serialize for FieldOptions {
         }
         let mut struct_ser = serializer.serialize_struct("google.protobuf.FieldOptions", len)?;
         if let Some(v) = self.ctype.as_ref() {
-            let v = field_options::CType::from_i32(*v)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
+            let v = field_options::CType::try_from(*v)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
             struct_ser.serialize_field("ctype", &v)?;
         }
         if let Some(v) = self.packed.as_ref() {
             struct_ser.serialize_field("packed", v)?;
         }
         if let Some(v) = self.jstype.as_ref() {
-            let v = field_options::JsType::from_i32(*v)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
+            let v = field_options::JsType::try_from(*v)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
             struct_ser.serialize_field("jstype", &v)?;
         }
         if let Some(v) = self.lazy.as_ref() {
@@ -3334,14 +3316,14 @@ impl serde::Serialize for FieldOptions {
             struct_ser.serialize_field("debugRedact", v)?;
         }
         if let Some(v) = self.retention.as_ref() {
-            let v = field_options::OptionRetention::from_i32(*v)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
+            let v = field_options::OptionRetention::try_from(*v)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
             struct_ser.serialize_field("retention", &v)?;
         }
         if true {
             let v = self.targets.iter().cloned().map(|v| {
-                field_options::OptionTargetType::from_i32(v)
-                    .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", v)))
+                field_options::OptionTargetType::try_from(v)
+                    .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", v)))
                 }).collect::<Result<::alloc::vec::Vec<_>, _>>()?;
             struct_ser.serialize_field("targets", &v)?;
         }
@@ -3447,7 +3429,7 @@ impl<'de> serde::Deserialize<'de> for FieldOptions {
                 formatter.write_str("struct google.protobuf.FieldOptions")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<FieldOptions, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<FieldOptions, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -3464,85 +3446,85 @@ impl<'de> serde::Deserialize<'de> for FieldOptions {
                 let mut edition_defaults__ = None;
                 let mut features__ = None;
                 let mut uninterpreted_option__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Ctype => {
                             if ctype__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("ctype"));
                             }
-                            ctype__ = map.next_value::<::core::option::Option<field_options::CType>>()?.map(|x| x as i32);
+                            ctype__ = map_.next_value::<::core::option::Option<field_options::CType>>()?.map(|x| x as i32);
                         }
                         GeneratedField::Packed => {
                             if packed__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("packed"));
                             }
-                            packed__ = map.next_value()?;
+                            packed__ = map_.next_value()?;
                         }
                         GeneratedField::Jstype => {
                             if jstype__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("jstype"));
                             }
-                            jstype__ = map.next_value::<::core::option::Option<field_options::JsType>>()?.map(|x| x as i32);
+                            jstype__ = map_.next_value::<::core::option::Option<field_options::JsType>>()?.map(|x| x as i32);
                         }
                         GeneratedField::Lazy => {
                             if lazy__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("lazy"));
                             }
-                            lazy__ = map.next_value()?;
+                            lazy__ = map_.next_value()?;
                         }
                         GeneratedField::UnverifiedLazy => {
                             if unverified_lazy__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("unverifiedLazy"));
                             }
-                            unverified_lazy__ = map.next_value()?;
+                            unverified_lazy__ = map_.next_value()?;
                         }
                         GeneratedField::Deprecated => {
                             if deprecated__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("deprecated"));
                             }
-                            deprecated__ = map.next_value()?;
+                            deprecated__ = map_.next_value()?;
                         }
                         GeneratedField::Weak => {
                             if weak__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("weak"));
                             }
-                            weak__ = map.next_value()?;
+                            weak__ = map_.next_value()?;
                         }
                         GeneratedField::DebugRedact => {
                             if debug_redact__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("debugRedact"));
                             }
-                            debug_redact__ = map.next_value()?;
+                            debug_redact__ = map_.next_value()?;
                         }
                         GeneratedField::Retention => {
                             if retention__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("retention"));
                             }
-                            retention__ = map.next_value::<::core::option::Option<field_options::OptionRetention>>()?.map(|x| x as i32);
+                            retention__ = map_.next_value::<::core::option::Option<field_options::OptionRetention>>()?.map(|x| x as i32);
                         }
                         GeneratedField::Targets => {
                             if targets__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("targets"));
                             }
-                            targets__ = Some(map.next_value::<::alloc::vec::Vec<field_options::OptionTargetType>>()?.into_iter().map(|x| x as i32).collect());
+                            targets__ = Some(map_.next_value::<::alloc::vec::Vec<field_options::OptionTargetType>>()?.into_iter().map(|x| x as i32).collect());
                         }
                         GeneratedField::EditionDefaults => {
                             if edition_defaults__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("editionDefaults"));
                             }
-                            edition_defaults__ = Some(map.next_value()?);
+                            edition_defaults__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Features => {
                             if features__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("features"));
                             }
-                            features__ = map.next_value()?;
+                            features__ = map_.next_value()?;
                         }
                         GeneratedField::UninterpretedOption => {
                             if uninterpreted_option__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("uninterpretedOption"));
                             }
-                            uninterpreted_option__ = Some(map.next_value()?);
+                            uninterpreted_option__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -3605,10 +3587,9 @@ impl<'de> serde::Deserialize<'de> for field_options::CType {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(field_options::CType::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -3618,10 +3599,9 @@ impl<'de> serde::Deserialize<'de> for field_options::CType {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(field_options::CType::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
@@ -3658,8 +3638,8 @@ impl serde::Serialize for field_options::EditionDefault {
         }
         let mut struct_ser = serializer.serialize_struct("google.protobuf.FieldOptions.EditionDefault", len)?;
         if let Some(v) = self.edition.as_ref() {
-            let v = Edition::from_i32(*v)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
+            let v = Edition::try_from(*v)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
             struct_ser.serialize_field("edition", &v)?;
         }
         if let Some(v) = self.value.as_ref() {
@@ -3721,25 +3701,25 @@ impl<'de> serde::Deserialize<'de> for field_options::EditionDefault {
                 formatter.write_str("struct google.protobuf.FieldOptions.EditionDefault")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<field_options::EditionDefault, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<field_options::EditionDefault, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut edition__ = None;
                 let mut value__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Edition => {
                             if edition__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("edition"));
                             }
-                            edition__ = map.next_value::<::core::option::Option<Edition>>()?.map(|x| x as i32);
+                            edition__ = map_.next_value::<::core::option::Option<Edition>>()?.map(|x| x as i32);
                         }
                         GeneratedField::Value => {
                             if value__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("value"));
                             }
-                            value__ = map.next_value()?;
+                            value__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3791,10 +3771,9 @@ impl<'de> serde::Deserialize<'de> for field_options::JsType {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(field_options::JsType::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -3804,10 +3783,9 @@ impl<'de> serde::Deserialize<'de> for field_options::JsType {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(field_options::JsType::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
@@ -3867,10 +3845,9 @@ impl<'de> serde::Deserialize<'de> for field_options::OptionRetention {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(field_options::OptionRetention::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -3880,10 +3857,9 @@ impl<'de> serde::Deserialize<'de> for field_options::OptionRetention {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(field_options::OptionRetention::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
@@ -3957,10 +3933,9 @@ impl<'de> serde::Deserialize<'de> for field_options::OptionTargetType {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(field_options::OptionTargetType::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -3970,10 +3945,9 @@ impl<'de> serde::Deserialize<'de> for field_options::OptionTargetType {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(field_options::OptionTargetType::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
@@ -4086,8 +4060,8 @@ impl serde::Serialize for FileDescriptorProto {
             struct_ser.serialize_field("syntax", v)?;
         }
         if let Some(v) = self.edition.as_ref() {
-            let v = Edition::from_i32(*v)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
+            let v = Edition::try_from(*v)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
             struct_ser.serialize_field("edition", &v)?;
         }
         struct_ser.end()
@@ -4184,7 +4158,7 @@ impl<'de> serde::Deserialize<'de> for FileDescriptorProto {
                 formatter.write_str("struct google.protobuf.FileDescriptorProto")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<FileDescriptorProto, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<FileDescriptorProto, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -4201,32 +4175,32 @@ impl<'de> serde::Deserialize<'de> for FileDescriptorProto {
                 let mut source_code_info__ = None;
                 let mut syntax__ = None;
                 let mut edition__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Name => {
                             if name__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("name"));
                             }
-                            name__ = map.next_value()?;
+                            name__ = map_.next_value()?;
                         }
                         GeneratedField::Package => {
                             if package__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("package"));
                             }
-                            package__ = map.next_value()?;
+                            package__ = map_.next_value()?;
                         }
                         GeneratedField::Dependency => {
                             if dependency__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("dependency"));
                             }
-                            dependency__ = Some(map.next_value()?);
+                            dependency__ = Some(map_.next_value()?);
                         }
                         GeneratedField::PublicDependency => {
                             if public_dependency__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("publicDependency"));
                             }
                             public_dependency__ = 
-                                Some(map.next_value::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()?
+                                Some(map_.next_value::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()?
                                     .into_iter().map(|x| x.0).collect())
                             ;
                         }
@@ -4235,7 +4209,7 @@ impl<'de> serde::Deserialize<'de> for FileDescriptorProto {
                                 return Err(serde::de::Error::duplicate_field("weakDependency"));
                             }
                             weak_dependency__ = 
-                                Some(map.next_value::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()?
+                                Some(map_.next_value::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()?
                                     .into_iter().map(|x| x.0).collect())
                             ;
                         }
@@ -4243,49 +4217,49 @@ impl<'de> serde::Deserialize<'de> for FileDescriptorProto {
                             if message_type__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("messageType"));
                             }
-                            message_type__ = Some(map.next_value()?);
+                            message_type__ = Some(map_.next_value()?);
                         }
                         GeneratedField::EnumType => {
                             if enum_type__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("enumType"));
                             }
-                            enum_type__ = Some(map.next_value()?);
+                            enum_type__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Service => {
                             if service__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("service"));
                             }
-                            service__ = Some(map.next_value()?);
+                            service__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Extension => {
                             if extension__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("extension"));
                             }
-                            extension__ = Some(map.next_value()?);
+                            extension__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Options => {
                             if options__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("options"));
                             }
-                            options__ = map.next_value()?;
+                            options__ = map_.next_value()?;
                         }
                         GeneratedField::SourceCodeInfo => {
                             if source_code_info__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sourceCodeInfo"));
                             }
-                            source_code_info__ = map.next_value()?;
+                            source_code_info__ = map_.next_value()?;
                         }
                         GeneratedField::Syntax => {
                             if syntax__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("syntax"));
                             }
-                            syntax__ = map.next_value()?;
+                            syntax__ = map_.next_value()?;
                         }
                         GeneratedField::Edition => {
                             if edition__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("edition"));
                             }
-                            edition__ = map.next_value::<::core::option::Option<Edition>>()?.map(|x| x as i32);
+                            edition__ = map_.next_value::<::core::option::Option<Edition>>()?.map(|x| x as i32);
                         }
                     }
                 }
@@ -4377,18 +4351,18 @@ impl<'de> serde::Deserialize<'de> for FileDescriptorSet {
                 formatter.write_str("struct google.protobuf.FileDescriptorSet")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<FileDescriptorSet, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<FileDescriptorSet, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut file__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::File => {
                             if file__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("file"));
                             }
-                            file__ = Some(map.next_value()?);
+                            file__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -4491,8 +4465,8 @@ impl serde::Serialize for FileOptions {
             struct_ser.serialize_field("javaStringCheckUtf8", v)?;
         }
         if let Some(v) = self.optimize_for.as_ref() {
-            let v = file_options::OptimizeMode::from_i32(*v)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
+            let v = file_options::OptimizeMode::try_from(*v)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
             struct_ser.serialize_field("optimizeFor", &v)?;
         }
         if let Some(v) = self.go_package.as_ref() {
@@ -4679,7 +4653,7 @@ impl<'de> serde::Deserialize<'de> for FileOptions {
                 formatter.write_str("struct google.protobuf.FileOptions")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<FileOptions, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<FileOptions, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -4705,139 +4679,139 @@ impl<'de> serde::Deserialize<'de> for FileOptions {
                 let mut ruby_package__ = None;
                 let mut features__ = None;
                 let mut uninterpreted_option__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::JavaPackage => {
                             if java_package__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("javaPackage"));
                             }
-                            java_package__ = map.next_value()?;
+                            java_package__ = map_.next_value()?;
                         }
                         GeneratedField::JavaOuterClassname => {
                             if java_outer_classname__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("javaOuterClassname"));
                             }
-                            java_outer_classname__ = map.next_value()?;
+                            java_outer_classname__ = map_.next_value()?;
                         }
                         GeneratedField::JavaMultipleFiles => {
                             if java_multiple_files__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("javaMultipleFiles"));
                             }
-                            java_multiple_files__ = map.next_value()?;
+                            java_multiple_files__ = map_.next_value()?;
                         }
                         GeneratedField::JavaGenerateEqualsAndHash => {
                             if java_generate_equals_and_hash__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("javaGenerateEqualsAndHash"));
                             }
-                            java_generate_equals_and_hash__ = map.next_value()?;
+                            java_generate_equals_and_hash__ = map_.next_value()?;
                         }
                         GeneratedField::JavaStringCheckUtf8 => {
                             if java_string_check_utf8__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("javaStringCheckUtf8"));
                             }
-                            java_string_check_utf8__ = map.next_value()?;
+                            java_string_check_utf8__ = map_.next_value()?;
                         }
                         GeneratedField::OptimizeFor => {
                             if optimize_for__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("optimizeFor"));
                             }
-                            optimize_for__ = map.next_value::<::core::option::Option<file_options::OptimizeMode>>()?.map(|x| x as i32);
+                            optimize_for__ = map_.next_value::<::core::option::Option<file_options::OptimizeMode>>()?.map(|x| x as i32);
                         }
                         GeneratedField::GoPackage => {
                             if go_package__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("goPackage"));
                             }
-                            go_package__ = map.next_value()?;
+                            go_package__ = map_.next_value()?;
                         }
                         GeneratedField::CcGenericServices => {
                             if cc_generic_services__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("ccGenericServices"));
                             }
-                            cc_generic_services__ = map.next_value()?;
+                            cc_generic_services__ = map_.next_value()?;
                         }
                         GeneratedField::JavaGenericServices => {
                             if java_generic_services__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("javaGenericServices"));
                             }
-                            java_generic_services__ = map.next_value()?;
+                            java_generic_services__ = map_.next_value()?;
                         }
                         GeneratedField::PyGenericServices => {
                             if py_generic_services__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pyGenericServices"));
                             }
-                            py_generic_services__ = map.next_value()?;
+                            py_generic_services__ = map_.next_value()?;
                         }
                         GeneratedField::PhpGenericServices => {
                             if php_generic_services__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("phpGenericServices"));
                             }
-                            php_generic_services__ = map.next_value()?;
+                            php_generic_services__ = map_.next_value()?;
                         }
                         GeneratedField::Deprecated => {
                             if deprecated__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("deprecated"));
                             }
-                            deprecated__ = map.next_value()?;
+                            deprecated__ = map_.next_value()?;
                         }
                         GeneratedField::CcEnableArenas => {
                             if cc_enable_arenas__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("ccEnableArenas"));
                             }
-                            cc_enable_arenas__ = map.next_value()?;
+                            cc_enable_arenas__ = map_.next_value()?;
                         }
                         GeneratedField::ObjcClassPrefix => {
                             if objc_class_prefix__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("objcClassPrefix"));
                             }
-                            objc_class_prefix__ = map.next_value()?;
+                            objc_class_prefix__ = map_.next_value()?;
                         }
                         GeneratedField::CsharpNamespace => {
                             if csharp_namespace__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("csharpNamespace"));
                             }
-                            csharp_namespace__ = map.next_value()?;
+                            csharp_namespace__ = map_.next_value()?;
                         }
                         GeneratedField::SwiftPrefix => {
                             if swift_prefix__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("swiftPrefix"));
                             }
-                            swift_prefix__ = map.next_value()?;
+                            swift_prefix__ = map_.next_value()?;
                         }
                         GeneratedField::PhpClassPrefix => {
                             if php_class_prefix__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("phpClassPrefix"));
                             }
-                            php_class_prefix__ = map.next_value()?;
+                            php_class_prefix__ = map_.next_value()?;
                         }
                         GeneratedField::PhpNamespace => {
                             if php_namespace__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("phpNamespace"));
                             }
-                            php_namespace__ = map.next_value()?;
+                            php_namespace__ = map_.next_value()?;
                         }
                         GeneratedField::PhpMetadataNamespace => {
                             if php_metadata_namespace__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("phpMetadataNamespace"));
                             }
-                            php_metadata_namespace__ = map.next_value()?;
+                            php_metadata_namespace__ = map_.next_value()?;
                         }
                         GeneratedField::RubyPackage => {
                             if ruby_package__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("rubyPackage"));
                             }
-                            ruby_package__ = map.next_value()?;
+                            ruby_package__ = map_.next_value()?;
                         }
                         GeneratedField::Features => {
                             if features__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("features"));
                             }
-                            features__ = map.next_value()?;
+                            features__ = map_.next_value()?;
                         }
                         GeneratedField::UninterpretedOption => {
                             if uninterpreted_option__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("uninterpretedOption"));
                             }
-                            uninterpreted_option__ = Some(map.next_value()?);
+                            uninterpreted_option__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -4909,10 +4883,9 @@ impl<'de> serde::Deserialize<'de> for file_options::OptimizeMode {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(file_options::OptimizeMode::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -4922,10 +4895,9 @@ impl<'de> serde::Deserialize<'de> for file_options::OptimizeMode {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(file_options::OptimizeMode::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
@@ -5014,18 +4986,18 @@ impl<'de> serde::Deserialize<'de> for GeneratedCodeInfo {
                 formatter.write_str("struct google.protobuf.GeneratedCodeInfo")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<GeneratedCodeInfo, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<GeneratedCodeInfo, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut annotation__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Annotation => {
                             if annotation__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("annotation"));
                             }
-                            annotation__ = Some(map.next_value()?);
+                            annotation__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -5074,8 +5046,8 @@ impl serde::Serialize for generated_code_info::Annotation {
             struct_ser.serialize_field("end", v)?;
         }
         if let Some(v) = self.semantic.as_ref() {
-            let v = generated_code_info::annotation::Semantic::from_i32(*v)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
+            let v = generated_code_info::annotation::Semantic::try_from(*v)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
             struct_ser.serialize_field("semantic", &v)?;
         }
         struct_ser.end()
@@ -5144,7 +5116,7 @@ impl<'de> serde::Deserialize<'de> for generated_code_info::Annotation {
                 formatter.write_str("struct google.protobuf.GeneratedCodeInfo.Annotation")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<generated_code_info::Annotation, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<generated_code_info::Annotation, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -5153,14 +5125,14 @@ impl<'de> serde::Deserialize<'de> for generated_code_info::Annotation {
                 let mut begin__ = None;
                 let mut end__ = None;
                 let mut semantic__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Path => {
                             if path__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("path"));
                             }
                             path__ = 
-                                Some(map.next_value::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()?
+                                Some(map_.next_value::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()?
                                     .into_iter().map(|x| x.0).collect())
                             ;
                         }
@@ -5168,14 +5140,14 @@ impl<'de> serde::Deserialize<'de> for generated_code_info::Annotation {
                             if source_file__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sourceFile"));
                             }
-                            source_file__ = map.next_value()?;
+                            source_file__ = map_.next_value()?;
                         }
                         GeneratedField::Begin => {
                             if begin__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("begin"));
                             }
                             begin__ = 
-                                map.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
+                                map_.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
                             ;
                         }
                         GeneratedField::End => {
@@ -5183,14 +5155,14 @@ impl<'de> serde::Deserialize<'de> for generated_code_info::Annotation {
                                 return Err(serde::de::Error::duplicate_field("end"));
                             }
                             end__ = 
-                                map.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
+                                map_.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
                             ;
                         }
                         GeneratedField::Semantic => {
                             if semantic__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("semantic"));
                             }
-                            semantic__ = map.next_value::<::core::option::Option<generated_code_info::annotation::Semantic>>()?.map(|x| x as i32);
+                            semantic__ = map_.next_value::<::core::option::Option<generated_code_info::annotation::Semantic>>()?.map(|x| x as i32);
                         }
                     }
                 }
@@ -5245,10 +5217,9 @@ impl<'de> serde::Deserialize<'de> for generated_code_info::annotation::Semantic
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(generated_code_info::annotation::Semantic::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -5258,10 +5229,9 @@ impl<'de> serde::Deserialize<'de> for generated_code_info::annotation::Semantic
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(generated_code_info::annotation::Semantic::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
@@ -5409,7 +5379,7 @@ impl<'de> serde::Deserialize<'de> for MessageOptions {
                 formatter.write_str("struct google.protobuf.MessageOptions")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MessageOptions, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MessageOptions, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -5420,49 +5390,49 @@ impl<'de> serde::Deserialize<'de> for MessageOptions {
                 let mut deprecated_legacy_json_field_conflicts__ = None;
                 let mut features__ = None;
                 let mut uninterpreted_option__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::MessageSetWireFormat => {
                             if message_set_wire_format__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("messageSetWireFormat"));
                             }
-                            message_set_wire_format__ = map.next_value()?;
+                            message_set_wire_format__ = map_.next_value()?;
                         }
                         GeneratedField::NoStandardDescriptorAccessor => {
                             if no_standard_descriptor_accessor__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("noStandardDescriptorAccessor"));
                             }
-                            no_standard_descriptor_accessor__ = map.next_value()?;
+                            no_standard_descriptor_accessor__ = map_.next_value()?;
                         }
                         GeneratedField::Deprecated => {
                             if deprecated__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("deprecated"));
                             }
-                            deprecated__ = map.next_value()?;
+                            deprecated__ = map_.next_value()?;
                         }
                         GeneratedField::MapEntry => {
                             if map_entry__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("mapEntry"));
                             }
-                            map_entry__ = map.next_value()?;
+                            map_entry__ = map_.next_value()?;
                         }
                         GeneratedField::DeprecatedLegacyJsonFieldConflicts => {
                             if deprecated_legacy_json_field_conflicts__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("deprecatedLegacyJsonFieldConflicts"));
                             }
-                            deprecated_legacy_json_field_conflicts__ = map.next_value()?;
+                            deprecated_legacy_json_field_conflicts__ = map_.next_value()?;
                         }
                         GeneratedField::Features => {
                             if features__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("features"));
                             }
-                            features__ = map.next_value()?;
+                            features__ = map_.next_value()?;
                         }
                         GeneratedField::UninterpretedOption => {
                             if uninterpreted_option__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("uninterpretedOption"));
                             }
-                            uninterpreted_option__ = Some(map.next_value()?);
+                            uninterpreted_option__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -5597,7 +5567,7 @@ impl<'de> serde::Deserialize<'de> for MethodDescriptorProto {
                 formatter.write_str("struct google.protobuf.MethodDescriptorProto")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MethodDescriptorProto, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MethodDescriptorProto, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -5607,43 +5577,43 @@ impl<'de> serde::Deserialize<'de> for MethodDescriptorProto {
                 let mut options__ = None;
                 let mut client_streaming__ = None;
                 let mut server_streaming__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Name => {
                             if name__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("name"));
                             }
-                            name__ = map.next_value()?;
+                            name__ = map_.next_value()?;
                         }
                         GeneratedField::InputType => {
                             if input_type__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("inputType"));
                             }
-                            input_type__ = map.next_value()?;
+                            input_type__ = map_.next_value()?;
                         }
                         GeneratedField::OutputType => {
                             if output_type__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("outputType"));
                             }
-                            output_type__ = map.next_value()?;
+                            output_type__ = map_.next_value()?;
                         }
                         GeneratedField::Options => {
                             if options__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("options"));
                             }
-                            options__ = map.next_value()?;
+                            options__ = map_.next_value()?;
                         }
                         GeneratedField::ClientStreaming => {
                             if client_streaming__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientStreaming"));
                             }
-                            client_streaming__ = map.next_value()?;
+                            client_streaming__ = map_.next_value()?;
                         }
                         GeneratedField::ServerStreaming => {
                             if server_streaming__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("serverStreaming"));
                             }
-                            server_streaming__ = map.next_value()?;
+                            server_streaming__ = map_.next_value()?;
                         }
                     }
                 }
@@ -5685,8 +5655,8 @@ impl serde::Serialize for MethodOptions {
             struct_ser.serialize_field("deprecated", v)?;
         }
         if let Some(v) = self.idempotency_level.as_ref() {
-            let v = method_options::IdempotencyLevel::from_i32(*v)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
+            let v = method_options::IdempotencyLevel::try_from(*v)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", *v)))?;
             struct_ser.serialize_field("idempotencyLevel", &v)?;
         }
         if let Some(v) = self.features.as_ref() {
@@ -5759,7 +5729,7 @@ impl<'de> serde::Deserialize<'de> for MethodOptions {
                 formatter.write_str("struct google.protobuf.MethodOptions")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MethodOptions, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MethodOptions, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -5767,31 +5737,31 @@ impl<'de> serde::Deserialize<'de> for MethodOptions {
                 let mut idempotency_level__ = None;
                 let mut features__ = None;
                 let mut uninterpreted_option__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Deprecated => {
                             if deprecated__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("deprecated"));
                             }
-                            deprecated__ = map.next_value()?;
+                            deprecated__ = map_.next_value()?;
                         }
                         GeneratedField::IdempotencyLevel => {
                             if idempotency_level__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("idempotencyLevel"));
                             }
-                            idempotency_level__ = map.next_value::<::core::option::Option<method_options::IdempotencyLevel>>()?.map(|x| x as i32);
+                            idempotency_level__ = map_.next_value::<::core::option::Option<method_options::IdempotencyLevel>>()?.map(|x| x as i32);
                         }
                         GeneratedField::Features => {
                             if features__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("features"));
                             }
-                            features__ = map.next_value()?;
+                            features__ = map_.next_value()?;
                         }
                         GeneratedField::UninterpretedOption => {
                             if uninterpreted_option__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("uninterpretedOption"));
                             }
-                            uninterpreted_option__ = Some(map.next_value()?);
+                            uninterpreted_option__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -5845,10 +5815,9 @@ impl<'de> serde::Deserialize<'de> for method_options::IdempotencyLevel {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(method_options::IdempotencyLevel::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -5858,10 +5827,9 @@ impl<'de> serde::Deserialize<'de> for method_options::IdempotencyLevel {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(method_options::IdempotencyLevel::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
@@ -5959,25 +5927,25 @@ impl<'de> serde::Deserialize<'de> for OneofDescriptorProto {
                 formatter.write_str("struct google.protobuf.OneofDescriptorProto")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<OneofDescriptorProto, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<OneofDescriptorProto, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut name__ = None;
                 let mut options__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Name => {
                             if name__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("name"));
                             }
-                            name__ = map.next_value()?;
+                            name__ = map_.next_value()?;
                         }
                         GeneratedField::Options => {
                             if options__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("options"));
                             }
-                            options__ = map.next_value()?;
+                            options__ = map_.next_value()?;
                         }
                     }
                 }
@@ -6068,25 +6036,25 @@ impl<'de> serde::Deserialize<'de> for OneofOptions {
                 formatter.write_str("struct google.protobuf.OneofOptions")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<OneofOptions, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<OneofOptions, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut features__ = None;
                 let mut uninterpreted_option__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Features => {
                             if features__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("features"));
                             }
-                            features__ = map.next_value()?;
+                            features__ = map_.next_value()?;
                         }
                         GeneratedField::UninterpretedOption => {
                             if uninterpreted_option__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("uninterpretedOption"));
                             }
-                            uninterpreted_option__ = Some(map.next_value()?);
+                            uninterpreted_option__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -6185,32 +6153,32 @@ impl<'de> serde::Deserialize<'de> for ServiceDescriptorProto {
                 formatter.write_str("struct google.protobuf.ServiceDescriptorProto")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ServiceDescriptorProto, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ServiceDescriptorProto, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut name__ = None;
                 let mut method__ = None;
                 let mut options__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Name => {
                             if name__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("name"));
                             }
-                            name__ = map.next_value()?;
+                            name__ = map_.next_value()?;
                         }
                         GeneratedField::Method => {
                             if method__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("method"));
                             }
-                            method__ = Some(map.next_value()?);
+                            method__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Options => {
                             if options__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("options"));
                             }
-                            options__ = map.next_value()?;
+                            options__ = map_.next_value()?;
                         }
                     }
                 }
@@ -6311,32 +6279,32 @@ impl<'de> serde::Deserialize<'de> for ServiceOptions {
                 formatter.write_str("struct google.protobuf.ServiceOptions")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ServiceOptions, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ServiceOptions, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut features__ = None;
                 let mut deprecated__ = None;
                 let mut uninterpreted_option__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Features => {
                             if features__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("features"));
                             }
-                            features__ = map.next_value()?;
+                            features__ = map_.next_value()?;
                         }
                         GeneratedField::Deprecated => {
                             if deprecated__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("deprecated"));
                             }
-                            deprecated__ = map.next_value()?;
+                            deprecated__ = map_.next_value()?;
                         }
                         GeneratedField::UninterpretedOption => {
                             if uninterpreted_option__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("uninterpretedOption"));
                             }
-                            uninterpreted_option__ = Some(map.next_value()?);
+                            uninterpreted_option__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -6418,18 +6386,18 @@ impl<'de> serde::Deserialize<'de> for SourceCodeInfo {
                 formatter.write_str("struct google.protobuf.SourceCodeInfo")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<SourceCodeInfo, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<SourceCodeInfo, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut location__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Location => {
                             if location__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("location"));
                             }
-                            location__ = Some(map.next_value()?);
+                            location__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -6548,7 +6516,7 @@ impl<'de> serde::Deserialize<'de> for source_code_info::Location {
                 formatter.write_str("struct google.protobuf.SourceCodeInfo.Location")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<source_code_info::Location, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<source_code_info::Location, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -6557,14 +6525,14 @@ impl<'de> serde::Deserialize<'de> for source_code_info::Location {
                 let mut leading_comments__ = None;
                 let mut trailing_comments__ = None;
                 let mut leading_detached_comments__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Path => {
                             if path__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("path"));
                             }
                             path__ = 
-                                Some(map.next_value::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()?
+                                Some(map_.next_value::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()?
                                     .into_iter().map(|x| x.0).collect())
                             ;
                         }
@@ -6573,7 +6541,7 @@ impl<'de> serde::Deserialize<'de> for source_code_info::Location {
                                 return Err(serde::de::Error::duplicate_field("span"));
                             }
                             span__ = 
-                                Some(map.next_value::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()?
+                                Some(map_.next_value::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()?
                                     .into_iter().map(|x| x.0).collect())
                             ;
                         }
@@ -6581,19 +6549,19 @@ impl<'de> serde::Deserialize<'de> for source_code_info::Location {
                             if leading_comments__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("leadingComments"));
                             }
-                            leading_comments__ = map.next_value()?;
+                            leading_comments__ = map_.next_value()?;
                         }
                         GeneratedField::TrailingComments => {
                             if trailing_comments__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("trailingComments"));
                             }
-                            trailing_comments__ = map.next_value()?;
+                            trailing_comments__ = map_.next_value()?;
                         }
                         GeneratedField::LeadingDetachedComments => {
                             if leading_detached_comments__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("leadingDetachedComments"));
                             }
-                            leading_detached_comments__ = Some(map.next_value()?);
+                            leading_detached_comments__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -6625,6 +6593,7 @@ impl serde::Serialize for Timestamp {
         }
         let mut struct_ser = serializer.serialize_struct("google.protobuf.Timestamp", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("seconds", ::alloc::string::ToString::to_string(&self.seconds).as_str())?;
         }
         if true {
@@ -6686,20 +6655,20 @@ impl<'de> serde::Deserialize<'de> for Timestamp {
                 formatter.write_str("struct google.protobuf.Timestamp")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Timestamp, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Timestamp, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut seconds__ = None;
                 let mut nanos__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Seconds => {
                             if seconds__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("seconds"));
                             }
                             seconds__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Nanos => {
@@ -6707,7 +6676,7 @@ impl<'de> serde::Deserialize<'de> for Timestamp {
                                 return Err(serde::de::Error::duplicate_field("nanos"));
                             }
                             nanos__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -6758,16 +6727,19 @@ impl serde::Serialize for UninterpretedOption {
             struct_ser.serialize_field("identifierValue", v)?;
         }
         if let Some(v) = self.positive_int_value.as_ref() {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("positiveIntValue", ::alloc::string::ToString::to_string(&v).as_str())?;
         }
         if let Some(v) = self.negative_int_value.as_ref() {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("negativeIntValue", ::alloc::string::ToString::to_string(&v).as_str())?;
         }
         if let Some(v) = self.double_value.as_ref() {
             struct_ser.serialize_field("doubleValue", v)?;
         }
         if let Some(v) = self.string_value.as_ref() {
-            struct_ser.serialize_field("stringValue", pbjson::private::base64::encode(v).as_str())?;
+            #[allow(clippy::needless_borrow)]
+            struct_ser.serialize_field("stringValue", pbjson::private::base64::encode(&v).as_str())?;
         }
         if let Some(v) = self.aggregate_value.as_ref() {
             struct_ser.serialize_field("aggregateValue", v)?;
@@ -6849,7 +6821,7 @@ impl<'de> serde::Deserialize<'de> for UninterpretedOption {
                 formatter.write_str("struct google.protobuf.UninterpretedOption")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<UninterpretedOption, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<UninterpretedOption, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -6860,26 +6832,26 @@ impl<'de> serde::Deserialize<'de> for UninterpretedOption {
                 let mut double_value__ = None;
                 let mut string_value__ = None;
                 let mut aggregate_value__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Name => {
                             if name__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("name"));
                             }
-                            name__ = Some(map.next_value()?);
+                            name__ = Some(map_.next_value()?);
                         }
                         GeneratedField::IdentifierValue => {
                             if identifier_value__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("identifierValue"));
                             }
-                            identifier_value__ = map.next_value()?;
+                            identifier_value__ = map_.next_value()?;
                         }
                         GeneratedField::PositiveIntValue => {
                             if positive_int_value__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("positiveIntValue"));
                             }
                             positive_int_value__ = 
-                                map.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
+                                map_.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
                             ;
                         }
                         GeneratedField::NegativeIntValue => {
@@ -6887,7 +6859,7 @@ impl<'de> serde::Deserialize<'de> for UninterpretedOption {
                                 return Err(serde::de::Error::duplicate_field("negativeIntValue"));
                             }
                             negative_int_value__ = 
-                                map.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
+                                map_.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
                             ;
                         }
                         GeneratedField::DoubleValue => {
@@ -6895,7 +6867,7 @@ impl<'de> serde::Deserialize<'de> for UninterpretedOption {
                                 return Err(serde::de::Error::duplicate_field("doubleValue"));
                             }
                             double_value__ = 
-                                map.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
+                                map_.next_value::<::core::option::Option<::pbjson::private::NumberDeserialize<_>>>()?.map(|x| x.0)
                             ;
                         }
                         GeneratedField::StringValue => {
@@ -6903,14 +6875,14 @@ impl<'de> serde::Deserialize<'de> for UninterpretedOption {
                                 return Err(serde::de::Error::duplicate_field("stringValue"));
                             }
                             string_value__ = 
-                                map.next_value::<::core::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| x.0)
+                                map_.next_value::<::core::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| x.0)
                             ;
                         }
                         GeneratedField::AggregateValue => {
                             if aggregate_value__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("aggregateValue"));
                             }
-                            aggregate_value__ = map.next_value()?;
+                            aggregate_value__ = map_.next_value()?;
                         }
                     }
                 }
@@ -6997,25 +6969,25 @@ impl<'de> serde::Deserialize<'de> for uninterpreted_option::NamePart {
                 formatter.write_str("struct google.protobuf.UninterpretedOption.NamePart")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<uninterpreted_option::NamePart, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<uninterpreted_option::NamePart, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut name_part__ = None;
                 let mut is_extension__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::NamePart => {
                             if name_part__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("namePart"));
                             }
-                            name_part__ = Some(map.next_value()?);
+                            name_part__ = Some(map_.next_value()?);
                         }
                         GeneratedField::IsExtension => {
                             if is_extension__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("isExtension"));
                             }
-                            is_extension__ = Some(map.next_value()?);
+                            is_extension__ = Some(map_.next_value()?);
                         }
                     }
                 }
diff --git a/src/prost/ibc.applications.fee.v1.serde.rs b/src/prost/ibc.applications.fee.v1.serde.rs
index e0fe7f52..c7cf56b5 100644
--- a/src/prost/ibc.applications.fee.v1.serde.rs
+++ b/src/prost/ibc.applications.fee.v1.serde.rs
@@ -87,32 +87,32 @@ impl<'de> serde::Deserialize<'de> for Fee {
                 formatter.write_str("struct ibc.applications.fee.v1.Fee")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Fee, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Fee, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut recv_fee__ = None;
                 let mut ack_fee__ = None;
                 let mut timeout_fee__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::RecvFee => {
                             if recv_fee__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("recvFee"));
                             }
-                            recv_fee__ = Some(map.next_value()?);
+                            recv_fee__ = Some(map_.next_value()?);
                         }
                         GeneratedField::AckFee => {
                             if ack_fee__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("ackFee"));
                             }
-                            ack_fee__ = Some(map.next_value()?);
+                            ack_fee__ = Some(map_.next_value()?);
                         }
                         GeneratedField::TimeoutFee => {
                             if timeout_fee__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("timeoutFee"));
                             }
-                            timeout_fee__ = Some(map.next_value()?);
+                            timeout_fee__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -205,25 +205,25 @@ impl<'de> serde::Deserialize<'de> for FeeEnabledChannel {
                 formatter.write_str("struct ibc.applications.fee.v1.FeeEnabledChannel")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<FeeEnabledChannel, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<FeeEnabledChannel, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut port_id__ = None;
                 let mut channel_id__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -314,25 +314,25 @@ impl<'de> serde::Deserialize<'de> for ForwardRelayerAddress {
                 formatter.write_str("struct ibc.applications.fee.v1.ForwardRelayerAddress")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ForwardRelayerAddress, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ForwardRelayerAddress, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut address__ = None;
                 let mut packet_id__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Address => {
                             if address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("address"));
                             }
-                            address__ = Some(map.next_value()?);
+                            address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::PacketId => {
                             if packet_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("packetId"));
                             }
-                            packet_id__ = map.next_value()?;
+                            packet_id__ = map_.next_value()?;
                         }
                     }
                 }
@@ -454,7 +454,7 @@ impl<'de> serde::Deserialize<'de> for GenesisState {
                 formatter.write_str("struct ibc.applications.fee.v1.GenesisState")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<GenesisState, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<GenesisState, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -463,37 +463,37 @@ impl<'de> serde::Deserialize<'de> for GenesisState {
                 let mut registered_payees__ = None;
                 let mut registered_counterparty_payees__ = None;
                 let mut forward_relayers__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::IdentifiedFees => {
                             if identified_fees__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("identifiedFees"));
                             }
-                            identified_fees__ = Some(map.next_value()?);
+                            identified_fees__ = Some(map_.next_value()?);
                         }
                         GeneratedField::FeeEnabledChannels => {
                             if fee_enabled_channels__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("feeEnabledChannels"));
                             }
-                            fee_enabled_channels__ = Some(map.next_value()?);
+                            fee_enabled_channels__ = Some(map_.next_value()?);
                         }
                         GeneratedField::RegisteredPayees => {
                             if registered_payees__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("registeredPayees"));
                             }
-                            registered_payees__ = Some(map.next_value()?);
+                            registered_payees__ = Some(map_.next_value()?);
                         }
                         GeneratedField::RegisteredCounterpartyPayees => {
                             if registered_counterparty_payees__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("registeredCounterpartyPayees"));
                             }
-                            registered_counterparty_payees__ = Some(map.next_value()?);
+                            registered_counterparty_payees__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ForwardRelayers => {
                             if forward_relayers__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("forwardRelayers"));
                             }
-                            forward_relayers__ = Some(map.next_value()?);
+                            forward_relayers__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -588,25 +588,25 @@ impl<'de> serde::Deserialize<'de> for IdentifiedPacketFees {
                 formatter.write_str("struct ibc.applications.fee.v1.IdentifiedPacketFees")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<IdentifiedPacketFees, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<IdentifiedPacketFees, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut packet_id__ = None;
                 let mut packet_fees__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PacketId => {
                             if packet_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("packetId"));
                             }
-                            packet_id__ = map.next_value()?;
+                            packet_id__ = map_.next_value()?;
                         }
                         GeneratedField::PacketFees => {
                             if packet_fees__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("packetFees"));
                             }
-                            packet_fees__ = Some(map.next_value()?);
+                            packet_fees__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -638,6 +638,7 @@ impl serde::Serialize for IncentivizedAcknowledgement {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.applications.fee.v1.IncentivizedAcknowledgement", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("appAcknowledgement", pbjson::private::base64::encode(&self.app_acknowledgement).as_str())?;
         }
         if true {
@@ -708,34 +709,34 @@ impl<'de> serde::Deserialize<'de> for IncentivizedAcknowledgement {
                 formatter.write_str("struct ibc.applications.fee.v1.IncentivizedAcknowledgement")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<IncentivizedAcknowledgement, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<IncentivizedAcknowledgement, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut app_acknowledgement__ = None;
                 let mut forward_relayer_address__ = None;
                 let mut underlying_app_success__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::AppAcknowledgement => {
                             if app_acknowledgement__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("appAcknowledgement"));
                             }
                             app_acknowledgement__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ForwardRelayerAddress => {
                             if forward_relayer_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("forwardRelayerAddress"));
                             }
-                            forward_relayer_address__ = Some(map.next_value()?);
+                            forward_relayer_address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::UnderlyingAppSuccess => {
                             if underlying_app_success__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("underlyingAppSuccess"));
                             }
-                            underlying_app_success__ = Some(map.next_value()?);
+                            underlying_app_success__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -828,25 +829,25 @@ impl<'de> serde::Deserialize<'de> for Metadata {
                 formatter.write_str("struct ibc.applications.fee.v1.Metadata")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Metadata, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Metadata, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut fee_version__ = None;
                 let mut app_version__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::FeeVersion => {
                             if fee_version__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("feeVersion"));
                             }
-                            fee_version__ = Some(map.next_value()?);
+                            fee_version__ = Some(map_.next_value()?);
                         }
                         GeneratedField::AppVersion => {
                             if app_version__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("appVersion"));
                             }
-                            app_version__ = Some(map.next_value()?);
+                            app_version__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -965,7 +966,7 @@ impl<'de> serde::Deserialize<'de> for MsgPayPacketFee {
                 formatter.write_str("struct ibc.applications.fee.v1.MsgPayPacketFee")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgPayPacketFee, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgPayPacketFee, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -974,37 +975,37 @@ impl<'de> serde::Deserialize<'de> for MsgPayPacketFee {
                 let mut source_channel_id__ = None;
                 let mut signer__ = None;
                 let mut relayers__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Fee => {
                             if fee__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("fee"));
                             }
-                            fee__ = map.next_value()?;
+                            fee__ = map_.next_value()?;
                         }
                         GeneratedField::SourcePortId => {
                             if source_port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sourcePortId"));
                             }
-                            source_port_id__ = Some(map.next_value()?);
+                            source_port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::SourceChannelId => {
                             if source_channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sourceChannelId"));
                             }
-                            source_channel_id__ = Some(map.next_value()?);
+                            source_channel_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Signer => {
                             if signer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signer"));
                             }
-                            signer__ = Some(map.next_value()?);
+                            signer__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Relayers => {
                             if relayers__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("relayers"));
                             }
-                            relayers__ = Some(map.next_value()?);
+                            relayers__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1099,25 +1100,25 @@ impl<'de> serde::Deserialize<'de> for MsgPayPacketFeeAsync {
                 formatter.write_str("struct ibc.applications.fee.v1.MsgPayPacketFeeAsync")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgPayPacketFeeAsync, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgPayPacketFeeAsync, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut packet_id__ = None;
                 let mut packet_fee__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PacketId => {
                             if packet_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("packetId"));
                             }
-                            packet_id__ = map.next_value()?;
+                            packet_id__ = map_.next_value()?;
                         }
                         GeneratedField::PacketFee => {
                             if packet_fee__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("packetFee"));
                             }
-                            packet_fee__ = map.next_value()?;
+                            packet_fee__ = map_.next_value()?;
                         }
                     }
                 }
@@ -1187,12 +1188,12 @@ impl<'de> serde::Deserialize<'de> for MsgPayPacketFeeAsyncResponse {
                 formatter.write_str("struct ibc.applications.fee.v1.MsgPayPacketFeeAsyncResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgPayPacketFeeAsyncResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgPayPacketFeeAsyncResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgPayPacketFeeAsyncResponse {
                 })
@@ -1258,12 +1259,12 @@ impl<'de> serde::Deserialize<'de> for MsgPayPacketFeeResponse {
                 formatter.write_str("struct ibc.applications.fee.v1.MsgPayPacketFeeResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgPayPacketFeeResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgPayPacketFeeResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgPayPacketFeeResponse {
                 })
@@ -1370,7 +1371,7 @@ impl<'de> serde::Deserialize<'de> for MsgRegisterCounterpartyPayee {
                 formatter.write_str("struct ibc.applications.fee.v1.MsgRegisterCounterpartyPayee")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgRegisterCounterpartyPayee, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgRegisterCounterpartyPayee, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -1378,31 +1379,31 @@ impl<'de> serde::Deserialize<'de> for MsgRegisterCounterpartyPayee {
                 let mut channel_id__ = None;
                 let mut relayer__ = None;
                 let mut counterparty_payee__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Relayer => {
                             if relayer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("relayer"));
                             }
-                            relayer__ = Some(map.next_value()?);
+                            relayer__ = Some(map_.next_value()?);
                         }
                         GeneratedField::CounterpartyPayee => {
                             if counterparty_payee__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("counterpartyPayee"));
                             }
-                            counterparty_payee__ = Some(map.next_value()?);
+                            counterparty_payee__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1474,12 +1475,12 @@ impl<'de> serde::Deserialize<'de> for MsgRegisterCounterpartyPayeeResponse {
                 formatter.write_str("struct ibc.applications.fee.v1.MsgRegisterCounterpartyPayeeResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgRegisterCounterpartyPayeeResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgRegisterCounterpartyPayeeResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgRegisterCounterpartyPayeeResponse {
                 })
@@ -1585,7 +1586,7 @@ impl<'de> serde::Deserialize<'de> for MsgRegisterPayee {
                 formatter.write_str("struct ibc.applications.fee.v1.MsgRegisterPayee")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgRegisterPayee, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgRegisterPayee, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -1593,31 +1594,31 @@ impl<'de> serde::Deserialize<'de> for MsgRegisterPayee {
                 let mut channel_id__ = None;
                 let mut relayer__ = None;
                 let mut payee__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Relayer => {
                             if relayer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("relayer"));
                             }
-                            relayer__ = Some(map.next_value()?);
+                            relayer__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Payee => {
                             if payee__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("payee"));
                             }
-                            payee__ = Some(map.next_value()?);
+                            payee__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1689,12 +1690,12 @@ impl<'de> serde::Deserialize<'de> for MsgRegisterPayeeResponse {
                 formatter.write_str("struct ibc.applications.fee.v1.MsgRegisterPayeeResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgRegisterPayeeResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgRegisterPayeeResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgRegisterPayeeResponse {
                 })
@@ -1790,32 +1791,32 @@ impl<'de> serde::Deserialize<'de> for PacketFee {
                 formatter.write_str("struct ibc.applications.fee.v1.PacketFee")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<PacketFee, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<PacketFee, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut fee__ = None;
                 let mut refund_address__ = None;
                 let mut relayers__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Fee => {
                             if fee__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("fee"));
                             }
-                            fee__ = map.next_value()?;
+                            fee__ = map_.next_value()?;
                         }
                         GeneratedField::RefundAddress => {
                             if refund_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("refundAddress"));
                             }
-                            refund_address__ = Some(map.next_value()?);
+                            refund_address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Relayers => {
                             if relayers__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("relayers"));
                             }
-                            relayers__ = Some(map.next_value()?);
+                            relayers__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1898,18 +1899,18 @@ impl<'de> serde::Deserialize<'de> for PacketFees {
                 formatter.write_str("struct ibc.applications.fee.v1.PacketFees")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<PacketFees, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<PacketFees, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut packet_fees__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PacketFees => {
                             if packet_fees__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("packetFees"));
                             }
-                            packet_fees__ = Some(map.next_value()?);
+                            packet_fees__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1999,25 +2000,25 @@ impl<'de> serde::Deserialize<'de> for QueryCounterpartyPayeeRequest {
                 formatter.write_str("struct ibc.applications.fee.v1.QueryCounterpartyPayeeRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryCounterpartyPayeeRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryCounterpartyPayeeRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut channel_id__ = None;
                 let mut relayer__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Relayer => {
                             if relayer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("relayer"));
                             }
-                            relayer__ = Some(map.next_value()?);
+                            relayer__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -2099,18 +2100,18 @@ impl<'de> serde::Deserialize<'de> for QueryCounterpartyPayeeResponse {
                 formatter.write_str("struct ibc.applications.fee.v1.QueryCounterpartyPayeeResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryCounterpartyPayeeResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryCounterpartyPayeeResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut counterparty_payee__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::CounterpartyPayee => {
                             if counterparty_payee__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("counterpartyPayee"));
                             }
-                            counterparty_payee__ = Some(map.next_value()?);
+                            counterparty_payee__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -2201,25 +2202,25 @@ impl<'de> serde::Deserialize<'de> for QueryFeeEnabledChannelRequest {
                 formatter.write_str("struct ibc.applications.fee.v1.QueryFeeEnabledChannelRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryFeeEnabledChannelRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryFeeEnabledChannelRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut port_id__ = None;
                 let mut channel_id__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -2301,18 +2302,18 @@ impl<'de> serde::Deserialize<'de> for QueryFeeEnabledChannelResponse {
                 formatter.write_str("struct ibc.applications.fee.v1.QueryFeeEnabledChannelResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryFeeEnabledChannelResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryFeeEnabledChannelResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut fee_enabled__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::FeeEnabled => {
                             if fee_enabled__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("feeEnabled"));
                             }
-                            fee_enabled__ = Some(map.next_value()?);
+                            fee_enabled__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -2343,6 +2344,7 @@ impl serde::Serialize for QueryFeeEnabledChannelsRequest {
             struct_ser.serialize_field("pagination", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("queryHeight", ::alloc::string::ToString::to_string(&self.query_height).as_str())?;
         }
         struct_ser.end()
@@ -2402,26 +2404,26 @@ impl<'de> serde::Deserialize<'de> for QueryFeeEnabledChannelsRequest {
                 formatter.write_str("struct ibc.applications.fee.v1.QueryFeeEnabledChannelsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryFeeEnabledChannelsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryFeeEnabledChannelsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut pagination__ = None;
                 let mut query_height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                         GeneratedField::QueryHeight => {
                             if query_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("queryHeight"));
                             }
                             query_height__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -2513,25 +2515,25 @@ impl<'de> serde::Deserialize<'de> for QueryFeeEnabledChannelsResponse {
                 formatter.write_str("struct ibc.applications.fee.v1.QueryFeeEnabledChannelsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryFeeEnabledChannelsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryFeeEnabledChannelsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut fee_enabled_channels__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::FeeEnabledChannels => {
                             if fee_enabled_channels__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("feeEnabledChannels"));
                             }
-                            fee_enabled_channels__ = Some(map.next_value()?);
+                            fee_enabled_channels__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2563,6 +2565,7 @@ impl serde::Serialize for QueryIncentivizedPacketRequest {
             struct_ser.serialize_field("packetId", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("queryHeight", ::alloc::string::ToString::to_string(&self.query_height).as_str())?;
         }
         struct_ser.end()
@@ -2623,26 +2626,26 @@ impl<'de> serde::Deserialize<'de> for QueryIncentivizedPacketRequest {
                 formatter.write_str("struct ibc.applications.fee.v1.QueryIncentivizedPacketRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryIncentivizedPacketRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryIncentivizedPacketRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut packet_id__ = None;
                 let mut query_height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PacketId => {
                             if packet_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("packetId"));
                             }
-                            packet_id__ = map.next_value()?;
+                            packet_id__ = map_.next_value()?;
                         }
                         GeneratedField::QueryHeight => {
                             if query_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("queryHeight"));
                             }
                             query_height__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -2725,18 +2728,18 @@ impl<'de> serde::Deserialize<'de> for QueryIncentivizedPacketResponse {
                 formatter.write_str("struct ibc.applications.fee.v1.QueryIncentivizedPacketResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryIncentivizedPacketResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryIncentivizedPacketResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut incentivized_packet__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::IncentivizedPacket => {
                             if incentivized_packet__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("incentivizedPacket"));
                             }
-                            incentivized_packet__ = map.next_value()?;
+                            incentivized_packet__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2779,6 +2782,7 @@ impl serde::Serialize for QueryIncentivizedPacketsForChannelRequest {
             struct_ser.serialize_field("channelId", &self.channel_id)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("queryHeight", ::alloc::string::ToString::to_string(&self.query_height).as_str())?;
         }
         struct_ser.end()
@@ -2846,7 +2850,7 @@ impl<'de> serde::Deserialize<'de> for QueryIncentivizedPacketsForChannelRequest
                 formatter.write_str("struct ibc.applications.fee.v1.QueryIncentivizedPacketsForChannelRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryIncentivizedPacketsForChannelRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryIncentivizedPacketsForChannelRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -2854,32 +2858,32 @@ impl<'de> serde::Deserialize<'de> for QueryIncentivizedPacketsForChannelRequest
                 let mut port_id__ = None;
                 let mut channel_id__ = None;
                 let mut query_height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::QueryHeight => {
                             if query_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("queryHeight"));
                             }
                             query_height__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -2973,25 +2977,25 @@ impl<'de> serde::Deserialize<'de> for QueryIncentivizedPacketsForChannelResponse
                 formatter.write_str("struct ibc.applications.fee.v1.QueryIncentivizedPacketsForChannelResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryIncentivizedPacketsForChannelResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryIncentivizedPacketsForChannelResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut incentivized_packets__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::IncentivizedPackets => {
                             if incentivized_packets__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("incentivizedPackets"));
                             }
-                            incentivized_packets__ = Some(map.next_value()?);
+                            incentivized_packets__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3023,6 +3027,7 @@ impl serde::Serialize for QueryIncentivizedPacketsRequest {
             struct_ser.serialize_field("pagination", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("queryHeight", ::alloc::string::ToString::to_string(&self.query_height).as_str())?;
         }
         struct_ser.end()
@@ -3082,26 +3087,26 @@ impl<'de> serde::Deserialize<'de> for QueryIncentivizedPacketsRequest {
                 formatter.write_str("struct ibc.applications.fee.v1.QueryIncentivizedPacketsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryIncentivizedPacketsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryIncentivizedPacketsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut pagination__ = None;
                 let mut query_height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                         GeneratedField::QueryHeight => {
                             if query_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("queryHeight"));
                             }
                             query_height__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -3193,25 +3198,25 @@ impl<'de> serde::Deserialize<'de> for QueryIncentivizedPacketsResponse {
                 formatter.write_str("struct ibc.applications.fee.v1.QueryIncentivizedPacketsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryIncentivizedPacketsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryIncentivizedPacketsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut incentivized_packets__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::IncentivizedPackets => {
                             if incentivized_packets__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("incentivizedPackets"));
                             }
-                            incentivized_packets__ = Some(map.next_value()?);
+                            incentivized_packets__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3302,25 +3307,25 @@ impl<'de> serde::Deserialize<'de> for QueryPayeeRequest {
                 formatter.write_str("struct ibc.applications.fee.v1.QueryPayeeRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryPayeeRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryPayeeRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut channel_id__ = None;
                 let mut relayer__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Relayer => {
                             if relayer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("relayer"));
                             }
-                            relayer__ = Some(map.next_value()?);
+                            relayer__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -3402,18 +3407,18 @@ impl<'de> serde::Deserialize<'de> for QueryPayeeResponse {
                 formatter.write_str("struct ibc.applications.fee.v1.QueryPayeeResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryPayeeResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryPayeeResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut payee_address__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PayeeAddress => {
                             if payee_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("payeeAddress"));
                             }
-                            payee_address__ = Some(map.next_value()?);
+                            payee_address__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -3494,18 +3499,18 @@ impl<'de> serde::Deserialize<'de> for QueryTotalAckFeesRequest {
                 formatter.write_str("struct ibc.applications.fee.v1.QueryTotalAckFeesRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryTotalAckFeesRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryTotalAckFeesRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut packet_id__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PacketId => {
                             if packet_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("packetId"));
                             }
-                            packet_id__ = map.next_value()?;
+                            packet_id__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3586,18 +3591,18 @@ impl<'de> serde::Deserialize<'de> for QueryTotalAckFeesResponse {
                 formatter.write_str("struct ibc.applications.fee.v1.QueryTotalAckFeesResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryTotalAckFeesResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryTotalAckFeesResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut ack_fees__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::AckFees => {
                             if ack_fees__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("ackFees"));
                             }
-                            ack_fees__ = Some(map.next_value()?);
+                            ack_fees__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -3678,18 +3683,18 @@ impl<'de> serde::Deserialize<'de> for QueryTotalRecvFeesRequest {
                 formatter.write_str("struct ibc.applications.fee.v1.QueryTotalRecvFeesRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryTotalRecvFeesRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryTotalRecvFeesRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut packet_id__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PacketId => {
                             if packet_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("packetId"));
                             }
-                            packet_id__ = map.next_value()?;
+                            packet_id__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3770,18 +3775,18 @@ impl<'de> serde::Deserialize<'de> for QueryTotalRecvFeesResponse {
                 formatter.write_str("struct ibc.applications.fee.v1.QueryTotalRecvFeesResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryTotalRecvFeesResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryTotalRecvFeesResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut recv_fees__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::RecvFees => {
                             if recv_fees__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("recvFees"));
                             }
-                            recv_fees__ = Some(map.next_value()?);
+                            recv_fees__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -3862,18 +3867,18 @@ impl<'de> serde::Deserialize<'de> for QueryTotalTimeoutFeesRequest {
                 formatter.write_str("struct ibc.applications.fee.v1.QueryTotalTimeoutFeesRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryTotalTimeoutFeesRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryTotalTimeoutFeesRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut packet_id__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PacketId => {
                             if packet_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("packetId"));
                             }
-                            packet_id__ = map.next_value()?;
+                            packet_id__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3954,18 +3959,18 @@ impl<'de> serde::Deserialize<'de> for QueryTotalTimeoutFeesResponse {
                 formatter.write_str("struct ibc.applications.fee.v1.QueryTotalTimeoutFeesResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryTotalTimeoutFeesResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryTotalTimeoutFeesResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut timeout_fees__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::TimeoutFees => {
                             if timeout_fees__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("timeoutFees"));
                             }
-                            timeout_fees__ = Some(map.next_value()?);
+                            timeout_fees__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -4065,32 +4070,32 @@ impl<'de> serde::Deserialize<'de> for RegisteredCounterpartyPayee {
                 formatter.write_str("struct ibc.applications.fee.v1.RegisteredCounterpartyPayee")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<RegisteredCounterpartyPayee, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<RegisteredCounterpartyPayee, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut channel_id__ = None;
                 let mut relayer__ = None;
                 let mut counterparty_payee__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Relayer => {
                             if relayer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("relayer"));
                             }
-                            relayer__ = Some(map.next_value()?);
+                            relayer__ = Some(map_.next_value()?);
                         }
                         GeneratedField::CounterpartyPayee => {
                             if counterparty_payee__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("counterpartyPayee"));
                             }
-                            counterparty_payee__ = Some(map.next_value()?);
+                            counterparty_payee__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -4191,32 +4196,32 @@ impl<'de> serde::Deserialize<'de> for RegisteredPayee {
                 formatter.write_str("struct ibc.applications.fee.v1.RegisteredPayee")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<RegisteredPayee, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<RegisteredPayee, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut channel_id__ = None;
                 let mut relayer__ = None;
                 let mut payee__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Relayer => {
                             if relayer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("relayer"));
                             }
-                            relayer__ = Some(map.next_value()?);
+                            relayer__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Payee => {
                             if payee__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("payee"));
                             }
-                            payee__ = Some(map.next_value()?);
+                            payee__ = Some(map_.next_value()?);
                         }
                     }
                 }
diff --git a/src/prost/ibc.applications.interchain_accounts.controller.v1.serde.rs b/src/prost/ibc.applications.interchain_accounts.controller.v1.serde.rs
index 50d9444b..b438d22c 100644
--- a/src/prost/ibc.applications.interchain_accounts.controller.v1.serde.rs
+++ b/src/prost/ibc.applications.interchain_accounts.controller.v1.serde.rs
@@ -85,32 +85,32 @@ impl<'de> serde::Deserialize<'de> for MsgRegisterInterchainAccount {
                 formatter.write_str("struct ibc.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccount")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgRegisterInterchainAccount, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgRegisterInterchainAccount, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut owner__ = None;
                 let mut connection_id__ = None;
                 let mut version__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Owner => {
                             if owner__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("owner"));
                             }
-                            owner__ = Some(map.next_value()?);
+                            owner__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ConnectionId => {
                             if connection_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("connectionId"));
                             }
-                            connection_id__ = Some(map.next_value()?);
+                            connection_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Version => {
                             if version__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("version"));
                             }
-                            version__ = Some(map.next_value()?);
+                            version__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -203,25 +203,25 @@ impl<'de> serde::Deserialize<'de> for MsgRegisterInterchainAccountResponse {
                 formatter.write_str("struct ibc.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccountResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgRegisterInterchainAccountResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgRegisterInterchainAccountResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut channel_id__ = None;
                 let mut port_id__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -265,6 +265,7 @@ impl serde::Serialize for MsgSendTx {
             struct_ser.serialize_field("packetData", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("relativeTimeout", ::alloc::string::ToString::to_string(&self.relative_timeout).as_str())?;
         }
         struct_ser.end()
@@ -332,7 +333,7 @@ impl<'de> serde::Deserialize<'de> for MsgSendTx {
                 formatter.write_str("struct ibc.applications.interchain_accounts.controller.v1.MsgSendTx")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgSendTx, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgSendTx, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -340,32 +341,32 @@ impl<'de> serde::Deserialize<'de> for MsgSendTx {
                 let mut connection_id__ = None;
                 let mut packet_data__ = None;
                 let mut relative_timeout__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Owner => {
                             if owner__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("owner"));
                             }
-                            owner__ = Some(map.next_value()?);
+                            owner__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ConnectionId => {
                             if connection_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("connectionId"));
                             }
-                            connection_id__ = Some(map.next_value()?);
+                            connection_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::PacketData => {
                             if packet_data__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("packetData"));
                             }
-                            packet_data__ = map.next_value()?;
+                            packet_data__ = map_.next_value()?;
                         }
                         GeneratedField::RelativeTimeout => {
                             if relative_timeout__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("relativeTimeout"));
                             }
                             relative_timeout__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -394,6 +395,7 @@ impl serde::Serialize for MsgSendTxResponse {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.applications.interchain_accounts.controller.v1.MsgSendTxResponse", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?;
         }
         struct_ser.end()
@@ -449,19 +451,19 @@ impl<'de> serde::Deserialize<'de> for MsgSendTxResponse {
                 formatter.write_str("struct ibc.applications.interchain_accounts.controller.v1.MsgSendTxResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgSendTxResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgSendTxResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut sequence__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Sequence => {
                             if sequence__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sequence"));
                             }
                             sequence__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -551,25 +553,25 @@ impl<'de> serde::Deserialize<'de> for MsgUpdateParams {
                 formatter.write_str("struct ibc.applications.interchain_accounts.controller.v1.MsgUpdateParams")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgUpdateParams, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgUpdateParams, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut signer__ = None;
                 let mut params__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Signer => {
                             if signer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signer"));
                             }
-                            signer__ = Some(map.next_value()?);
+                            signer__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Params => {
                             if params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("params"));
                             }
-                            params__ = map.next_value()?;
+                            params__ = map_.next_value()?;
                         }
                     }
                 }
@@ -639,12 +641,12 @@ impl<'de> serde::Deserialize<'de> for MsgUpdateParamsResponse {
                 formatter.write_str("struct ibc.applications.interchain_accounts.controller.v1.MsgUpdateParamsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgUpdateParamsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgUpdateParamsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgUpdateParamsResponse {
                 })
@@ -722,18 +724,18 @@ impl<'de> serde::Deserialize<'de> for Params {
                 formatter.write_str("struct ibc.applications.interchain_accounts.controller.v1.Params")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Params, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Params, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut controller_enabled__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ControllerEnabled => {
                             if controller_enabled__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("controllerEnabled"));
                             }
-                            controller_enabled__ = Some(map.next_value()?);
+                            controller_enabled__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -823,25 +825,25 @@ impl<'de> serde::Deserialize<'de> for QueryInterchainAccountRequest {
                 formatter.write_str("struct ibc.applications.interchain_accounts.controller.v1.QueryInterchainAccountRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryInterchainAccountRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryInterchainAccountRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut owner__ = None;
                 let mut connection_id__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Owner => {
                             if owner__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("owner"));
                             }
-                            owner__ = Some(map.next_value()?);
+                            owner__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ConnectionId => {
                             if connection_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("connectionId"));
                             }
-                            connection_id__ = Some(map.next_value()?);
+                            connection_id__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -922,18 +924,18 @@ impl<'de> serde::Deserialize<'de> for QueryInterchainAccountResponse {
                 formatter.write_str("struct ibc.applications.interchain_accounts.controller.v1.QueryInterchainAccountResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryInterchainAccountResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryInterchainAccountResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut address__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Address => {
                             if address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("address"));
                             }
-                            address__ = Some(map.next_value()?);
+                            address__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1002,12 +1004,12 @@ impl<'de> serde::Deserialize<'de> for QueryParamsRequest {
                 formatter.write_str("struct ibc.applications.interchain_accounts.controller.v1.QueryParamsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryParamsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryParamsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(QueryParamsRequest {
                 })
@@ -1084,18 +1086,18 @@ impl<'de> serde::Deserialize<'de> for QueryParamsResponse {
                 formatter.write_str("struct ibc.applications.interchain_accounts.controller.v1.QueryParamsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryParamsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryParamsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut params__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Params => {
                             if params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("params"));
                             }
-                            params__ = map.next_value()?;
+                            params__ = map_.next_value()?;
                         }
                     }
                 }
diff --git a/src/prost/ibc.applications.interchain_accounts.genesis.v1.serde.rs b/src/prost/ibc.applications.interchain_accounts.genesis.v1.serde.rs
index f02aca11..76478f97 100644
--- a/src/prost/ibc.applications.interchain_accounts.genesis.v1.serde.rs
+++ b/src/prost/ibc.applications.interchain_accounts.genesis.v1.serde.rs
@@ -97,7 +97,7 @@ impl<'de> serde::Deserialize<'de> for ActiveChannel {
                 formatter.write_str("struct ibc.applications.interchain_accounts.genesis.v1.ActiveChannel")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ActiveChannel, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ActiveChannel, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -105,31 +105,31 @@ impl<'de> serde::Deserialize<'de> for ActiveChannel {
                 let mut port_id__ = None;
                 let mut channel_id__ = None;
                 let mut is_middleware_enabled__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ConnectionId => {
                             if connection_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("connectionId"));
                             }
-                            connection_id__ = Some(map.next_value()?);
+                            connection_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::IsMiddlewareEnabled => {
                             if is_middleware_enabled__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("isMiddlewareEnabled"));
                             }
-                            is_middleware_enabled__ = Some(map.next_value()?);
+                            is_middleware_enabled__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -241,7 +241,7 @@ impl<'de> serde::Deserialize<'de> for ControllerGenesisState {
                 formatter.write_str("struct ibc.applications.interchain_accounts.genesis.v1.ControllerGenesisState")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ControllerGenesisState, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ControllerGenesisState, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -249,31 +249,31 @@ impl<'de> serde::Deserialize<'de> for ControllerGenesisState {
                 let mut interchain_accounts__ = None;
                 let mut ports__ = None;
                 let mut params__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ActiveChannels => {
                             if active_channels__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("activeChannels"));
                             }
-                            active_channels__ = Some(map.next_value()?);
+                            active_channels__ = Some(map_.next_value()?);
                         }
                         GeneratedField::InterchainAccounts => {
                             if interchain_accounts__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("interchainAccounts"));
                             }
-                            interchain_accounts__ = Some(map.next_value()?);
+                            interchain_accounts__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Ports => {
                             if ports__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("ports"));
                             }
-                            ports__ = Some(map.next_value()?);
+                            ports__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Params => {
                             if params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("params"));
                             }
-                            params__ = map.next_value()?;
+                            params__ = map_.next_value()?;
                         }
                     }
                 }
@@ -367,25 +367,25 @@ impl<'de> serde::Deserialize<'de> for GenesisState {
                 formatter.write_str("struct ibc.applications.interchain_accounts.genesis.v1.GenesisState")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<GenesisState, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<GenesisState, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut controller_genesis_state__ = None;
                 let mut host_genesis_state__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ControllerGenesisState => {
                             if controller_genesis_state__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("controllerGenesisState"));
                             }
-                            controller_genesis_state__ = map.next_value()?;
+                            controller_genesis_state__ = map_.next_value()?;
                         }
                         GeneratedField::HostGenesisState => {
                             if host_genesis_state__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("hostGenesisState"));
                             }
-                            host_genesis_state__ = map.next_value()?;
+                            host_genesis_state__ = map_.next_value()?;
                         }
                     }
                 }
@@ -495,7 +495,7 @@ impl<'de> serde::Deserialize<'de> for HostGenesisState {
                 formatter.write_str("struct ibc.applications.interchain_accounts.genesis.v1.HostGenesisState")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<HostGenesisState, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<HostGenesisState, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -503,31 +503,31 @@ impl<'de> serde::Deserialize<'de> for HostGenesisState {
                 let mut interchain_accounts__ = None;
                 let mut port__ = None;
                 let mut params__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ActiveChannels => {
                             if active_channels__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("activeChannels"));
                             }
-                            active_channels__ = Some(map.next_value()?);
+                            active_channels__ = Some(map_.next_value()?);
                         }
                         GeneratedField::InterchainAccounts => {
                             if interchain_accounts__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("interchainAccounts"));
                             }
-                            interchain_accounts__ = Some(map.next_value()?);
+                            interchain_accounts__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Port => {
                             if port__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("port"));
                             }
-                            port__ = Some(map.next_value()?);
+                            port__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Params => {
                             if params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("params"));
                             }
-                            params__ = map.next_value()?;
+                            params__ = map_.next_value()?;
                         }
                     }
                 }
@@ -631,32 +631,32 @@ impl<'de> serde::Deserialize<'de> for RegisteredInterchainAccount {
                 formatter.write_str("struct ibc.applications.interchain_accounts.genesis.v1.RegisteredInterchainAccount")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<RegisteredInterchainAccount, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<RegisteredInterchainAccount, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut connection_id__ = None;
                 let mut port_id__ = None;
                 let mut account_address__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ConnectionId => {
                             if connection_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("connectionId"));
                             }
-                            connection_id__ = Some(map.next_value()?);
+                            connection_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::AccountAddress => {
                             if account_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("accountAddress"));
                             }
-                            account_address__ = Some(map.next_value()?);
+                            account_address__ = Some(map_.next_value()?);
                         }
                     }
                 }
diff --git a/src/prost/ibc.applications.interchain_accounts.host.v1.serde.rs b/src/prost/ibc.applications.interchain_accounts.host.v1.serde.rs
index 8be94e1b..8b52ba9b 100644
--- a/src/prost/ibc.applications.interchain_accounts.host.v1.serde.rs
+++ b/src/prost/ibc.applications.interchain_accounts.host.v1.serde.rs
@@ -75,25 +75,25 @@ impl<'de> serde::Deserialize<'de> for MsgUpdateParams {
                 formatter.write_str("struct ibc.applications.interchain_accounts.host.v1.MsgUpdateParams")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgUpdateParams, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgUpdateParams, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut signer__ = None;
                 let mut params__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Signer => {
                             if signer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signer"));
                             }
-                            signer__ = Some(map.next_value()?);
+                            signer__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Params => {
                             if params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("params"));
                             }
-                            params__ = map.next_value()?;
+                            params__ = map_.next_value()?;
                         }
                     }
                 }
@@ -163,12 +163,12 @@ impl<'de> serde::Deserialize<'de> for MsgUpdateParamsResponse {
                 formatter.write_str("struct ibc.applications.interchain_accounts.host.v1.MsgUpdateParamsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgUpdateParamsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgUpdateParamsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgUpdateParamsResponse {
                 })
@@ -256,25 +256,25 @@ impl<'de> serde::Deserialize<'de> for Params {
                 formatter.write_str("struct ibc.applications.interchain_accounts.host.v1.Params")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Params, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Params, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut host_enabled__ = None;
                 let mut allow_messages__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::HostEnabled => {
                             if host_enabled__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("hostEnabled"));
                             }
-                            host_enabled__ = Some(map.next_value()?);
+                            host_enabled__ = Some(map_.next_value()?);
                         }
                         GeneratedField::AllowMessages => {
                             if allow_messages__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("allowMessages"));
                             }
-                            allow_messages__ = Some(map.next_value()?);
+                            allow_messages__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -344,12 +344,12 @@ impl<'de> serde::Deserialize<'de> for QueryParamsRequest {
                 formatter.write_str("struct ibc.applications.interchain_accounts.host.v1.QueryParamsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryParamsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryParamsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(QueryParamsRequest {
                 })
@@ -426,18 +426,18 @@ impl<'de> serde::Deserialize<'de> for QueryParamsResponse {
                 formatter.write_str("struct ibc.applications.interchain_accounts.host.v1.QueryParamsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryParamsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryParamsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut params__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Params => {
                             if params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("params"));
                             }
-                            params__ = map.next_value()?;
+                            params__ = map_.next_value()?;
                         }
                     }
                 }
diff --git a/src/prost/ibc.applications.interchain_accounts.v1.serde.rs b/src/prost/ibc.applications.interchain_accounts.v1.serde.rs
index 50da6b1e..966bc3e9 100644
--- a/src/prost/ibc.applications.interchain_accounts.v1.serde.rs
+++ b/src/prost/ibc.applications.interchain_accounts.v1.serde.rs
@@ -66,18 +66,18 @@ impl<'de> serde::Deserialize<'de> for CosmosTx {
                 formatter.write_str("struct ibc.applications.interchain_accounts.v1.CosmosTx")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<CosmosTx, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<CosmosTx, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut messages__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Messages => {
                             if messages__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("messages"));
                             }
-                            messages__ = Some(map.next_value()?);
+                            messages__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -168,25 +168,25 @@ impl<'de> serde::Deserialize<'de> for InterchainAccount {
                 formatter.write_str("struct ibc.applications.interchain_accounts.v1.InterchainAccount")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<InterchainAccount, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<InterchainAccount, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut base_account__ = None;
                 let mut account_owner__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::BaseAccount => {
                             if base_account__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("baseAccount"));
                             }
-                            base_account__ = map.next_value()?;
+                            base_account__ = map_.next_value()?;
                         }
                         GeneratedField::AccountOwner => {
                             if account_owner__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("accountOwner"));
                             }
-                            account_owner__ = Some(map.next_value()?);
+                            account_owner__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -218,11 +218,12 @@ impl serde::Serialize for InterchainAccountPacketData {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.applications.interchain_accounts.v1.InterchainAccountPacketData", len)?;
         if true {
-            let v = Type::from_i32(self.r#type)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.r#type)))?;
+            let v = Type::try_from(self.r#type)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.r#type)))?;
             struct_ser.serialize_field("type", &v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("data", pbjson::private::base64::encode(&self.data).as_str())?;
         }
         if true {
@@ -287,34 +288,34 @@ impl<'de> serde::Deserialize<'de> for InterchainAccountPacketData {
                 formatter.write_str("struct ibc.applications.interchain_accounts.v1.InterchainAccountPacketData")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<InterchainAccountPacketData, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<InterchainAccountPacketData, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut r#type__ = None;
                 let mut data__ = None;
                 let mut memo__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Type => {
                             if r#type__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("type"));
                             }
-                            r#type__ = Some(map.next_value::<Type>()? as i32);
+                            r#type__ = Some(map_.next_value::<Type>()? as i32);
                         }
                         GeneratedField::Data => {
                             if data__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("data"));
                             }
                             data__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Memo => {
                             if memo__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("memo"));
                             }
-                            memo__ = Some(map.next_value()?);
+                            memo__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -444,7 +445,7 @@ impl<'de> serde::Deserialize<'de> for Metadata {
                 formatter.write_str("struct ibc.applications.interchain_accounts.v1.Metadata")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Metadata, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Metadata, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -454,43 +455,43 @@ impl<'de> serde::Deserialize<'de> for Metadata {
                 let mut address__ = None;
                 let mut encoding__ = None;
                 let mut tx_type__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Version => {
                             if version__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("version"));
                             }
-                            version__ = Some(map.next_value()?);
+                            version__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ControllerConnectionId => {
                             if controller_connection_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("controllerConnectionId"));
                             }
-                            controller_connection_id__ = Some(map.next_value()?);
+                            controller_connection_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::HostConnectionId => {
                             if host_connection_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("hostConnectionId"));
                             }
-                            host_connection_id__ = Some(map.next_value()?);
+                            host_connection_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Address => {
                             if address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("address"));
                             }
-                            address__ = Some(map.next_value()?);
+                            address__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Encoding => {
                             if encoding__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("encoding"));
                             }
-                            encoding__ = Some(map.next_value()?);
+                            encoding__ = Some(map_.next_value()?);
                         }
                         GeneratedField::TxType => {
                             if tx_type__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("txType"));
                             }
-                            tx_type__ = Some(map.next_value()?);
+                            tx_type__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -544,10 +545,9 @@ impl<'de> serde::Deserialize<'de> for Type {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(Type::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -557,10 +557,9 @@ impl<'de> serde::Deserialize<'de> for Type {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(Type::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
diff --git a/src/prost/ibc.applications.nft_transfer.v1.serde.rs b/src/prost/ibc.applications.nft_transfer.v1.serde.rs
index b7073db8..b194a0c6 100644
--- a/src/prost/ibc.applications.nft_transfer.v1.serde.rs
+++ b/src/prost/ibc.applications.nft_transfer.v1.serde.rs
@@ -76,25 +76,25 @@ impl<'de> serde::Deserialize<'de> for ClassTrace {
                 formatter.write_str("struct ibc.applications.nft_transfer.v1.ClassTrace")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ClassTrace, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ClassTrace, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut path__ = None;
                 let mut base_class_id__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Path => {
                             if path__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("path"));
                             }
-                            path__ = Some(map.next_value()?);
+                            path__ = Some(map_.next_value()?);
                         }
                         GeneratedField::BaseClassId => {
                             if base_class_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("baseClassId"));
                             }
-                            base_class_id__ = Some(map.next_value()?);
+                            base_class_id__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -194,32 +194,32 @@ impl<'de> serde::Deserialize<'de> for GenesisState {
                 formatter.write_str("struct ibc.applications.nft_transfer.v1.GenesisState")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<GenesisState, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<GenesisState, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut port_id__ = None;
                 let mut traces__ = None;
                 let mut params__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Traces => {
                             if traces__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("traces"));
                             }
-                            traces__ = Some(map.next_value()?);
+                            traces__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Params => {
                             if params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("params"));
                             }
-                            params__ = map.next_value()?;
+                            params__ = map_.next_value()?;
                         }
                     }
                 }
@@ -291,6 +291,7 @@ impl serde::Serialize for MsgTransfer {
             struct_ser.serialize_field("timeoutHeight", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("timeoutTimestamp", ::alloc::string::ToString::to_string(&self.timeout_timestamp).as_str())?;
         }
         if true {
@@ -379,7 +380,7 @@ impl<'de> serde::Deserialize<'de> for MsgTransfer {
                 formatter.write_str("struct ibc.applications.nft_transfer.v1.MsgTransfer")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgTransfer, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgTransfer, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -392,63 +393,63 @@ impl<'de> serde::Deserialize<'de> for MsgTransfer {
                 let mut timeout_height__ = None;
                 let mut timeout_timestamp__ = None;
                 let mut memo__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::SourcePort => {
                             if source_port__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sourcePort"));
                             }
-                            source_port__ = Some(map.next_value()?);
+                            source_port__ = Some(map_.next_value()?);
                         }
                         GeneratedField::SourceChannel => {
                             if source_channel__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sourceChannel"));
                             }
-                            source_channel__ = Some(map.next_value()?);
+                            source_channel__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ClassId => {
                             if class_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("classId"));
                             }
-                            class_id__ = Some(map.next_value()?);
+                            class_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::TokenIds => {
                             if token_ids__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("tokenIds"));
                             }
-                            token_ids__ = Some(map.next_value()?);
+                            token_ids__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Sender => {
                             if sender__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sender"));
                             }
-                            sender__ = Some(map.next_value()?);
+                            sender__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Receiver => {
                             if receiver__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("receiver"));
                             }
-                            receiver__ = Some(map.next_value()?);
+                            receiver__ = Some(map_.next_value()?);
                         }
                         GeneratedField::TimeoutHeight => {
                             if timeout_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("timeoutHeight"));
                             }
-                            timeout_height__ = map.next_value()?;
+                            timeout_height__ = map_.next_value()?;
                         }
                         GeneratedField::TimeoutTimestamp => {
                             if timeout_timestamp__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("timeoutTimestamp"));
                             }
                             timeout_timestamp__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Memo => {
                             if memo__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("memo"));
                             }
-                            memo__ = Some(map.next_value()?);
+                            memo__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -481,6 +482,7 @@ impl serde::Serialize for MsgTransferResponse {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.applications.nft_transfer.v1.MsgTransferResponse", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?;
         }
         struct_ser.end()
@@ -536,19 +538,19 @@ impl<'de> serde::Deserialize<'de> for MsgTransferResponse {
                 formatter.write_str("struct ibc.applications.nft_transfer.v1.MsgTransferResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgTransferResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgTransferResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut sequence__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Sequence => {
                             if sequence__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sequence"));
                             }
                             sequence__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -638,25 +640,25 @@ impl<'de> serde::Deserialize<'de> for MsgUpdateParams {
                 formatter.write_str("struct ibc.applications.nft_transfer.v1.MsgUpdateParams")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgUpdateParams, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgUpdateParams, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut authority__ = None;
                 let mut params__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Authority => {
                             if authority__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("authority"));
                             }
-                            authority__ = Some(map.next_value()?);
+                            authority__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Params => {
                             if params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("params"));
                             }
-                            params__ = map.next_value()?;
+                            params__ = map_.next_value()?;
                         }
                     }
                 }
@@ -726,12 +728,12 @@ impl<'de> serde::Deserialize<'de> for MsgUpdateParamsResponse {
                 formatter.write_str("struct ibc.applications.nft_transfer.v1.MsgUpdateParamsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgUpdateParamsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgUpdateParamsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgUpdateParamsResponse {
                 })
@@ -886,7 +888,7 @@ impl<'de> serde::Deserialize<'de> for NonFungibleTokenPacketData {
                 formatter.write_str("struct ibc.applications.nft_transfer.v1.NonFungibleTokenPacketData")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<NonFungibleTokenPacketData, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<NonFungibleTokenPacketData, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -899,61 +901,61 @@ impl<'de> serde::Deserialize<'de> for NonFungibleTokenPacketData {
                 let mut sender__ = None;
                 let mut receiver__ = None;
                 let mut memo__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ClassId => {
                             if class_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("classId"));
                             }
-                            class_id__ = Some(map.next_value()?);
+                            class_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ClassUri => {
                             if class_uri__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("classUri"));
                             }
-                            class_uri__ = Some(map.next_value()?);
+                            class_uri__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ClassData => {
                             if class_data__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("classData"));
                             }
-                            class_data__ = Some(map.next_value()?);
+                            class_data__ = Some(map_.next_value()?);
                         }
                         GeneratedField::TokenIds => {
                             if token_ids__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("tokenIds"));
                             }
-                            token_ids__ = Some(map.next_value()?);
+                            token_ids__ = Some(map_.next_value()?);
                         }
                         GeneratedField::TokenUris => {
                             if token_uris__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("tokenUris"));
                             }
-                            token_uris__ = Some(map.next_value()?);
+                            token_uris__ = Some(map_.next_value()?);
                         }
                         GeneratedField::TokenData => {
                             if token_data__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("tokenData"));
                             }
-                            token_data__ = Some(map.next_value()?);
+                            token_data__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Sender => {
                             if sender__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sender"));
                             }
-                            sender__ = Some(map.next_value()?);
+                            sender__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Receiver => {
                             if receiver__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("receiver"));
                             }
-                            receiver__ = Some(map.next_value()?);
+                            receiver__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Memo => {
                             if memo__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("memo"));
                             }
-                            memo__ = Some(map.next_value()?);
+                            memo__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1052,25 +1054,25 @@ impl<'de> serde::Deserialize<'de> for Params {
                 formatter.write_str("struct ibc.applications.nft_transfer.v1.Params")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Params, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Params, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut send_enabled__ = None;
                 let mut receive_enabled__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::SendEnabled => {
                             if send_enabled__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sendEnabled"));
                             }
-                            send_enabled__ = Some(map.next_value()?);
+                            send_enabled__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ReceiveEnabled => {
                             if receive_enabled__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("receiveEnabled"));
                             }
-                            receive_enabled__ = Some(map.next_value()?);
+                            receive_enabled__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1151,18 +1153,18 @@ impl<'de> serde::Deserialize<'de> for QueryClassHashRequest {
                 formatter.write_str("struct ibc.applications.nft_transfer.v1.QueryClassHashRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryClassHashRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryClassHashRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut trace__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Trace => {
                             if trace__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("trace"));
                             }
-                            trace__ = Some(map.next_value()?);
+                            trace__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1242,18 +1244,18 @@ impl<'de> serde::Deserialize<'de> for QueryClassHashResponse {
                 formatter.write_str("struct ibc.applications.nft_transfer.v1.QueryClassHashResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryClassHashResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryClassHashResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut hash__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Hash => {
                             if hash__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("hash"));
                             }
-                            hash__ = Some(map.next_value()?);
+                            hash__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1333,18 +1335,18 @@ impl<'de> serde::Deserialize<'de> for QueryClassTraceRequest {
                 formatter.write_str("struct ibc.applications.nft_transfer.v1.QueryClassTraceRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryClassTraceRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryClassTraceRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut hash__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Hash => {
                             if hash__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("hash"));
                             }
-                            hash__ = Some(map.next_value()?);
+                            hash__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1425,18 +1427,18 @@ impl<'de> serde::Deserialize<'de> for QueryClassTraceResponse {
                 formatter.write_str("struct ibc.applications.nft_transfer.v1.QueryClassTraceResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryClassTraceResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryClassTraceResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut class_trace__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ClassTrace => {
                             if class_trace__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("classTrace"));
                             }
-                            class_trace__ = map.next_value()?;
+                            class_trace__ = map_.next_value()?;
                         }
                     }
                 }
@@ -1516,18 +1518,18 @@ impl<'de> serde::Deserialize<'de> for QueryClassTracesRequest {
                 formatter.write_str("struct ibc.applications.nft_transfer.v1.QueryClassTracesRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryClassTracesRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryClassTracesRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -1617,25 +1619,25 @@ impl<'de> serde::Deserialize<'de> for QueryClassTracesResponse {
                 formatter.write_str("struct ibc.applications.nft_transfer.v1.QueryClassTracesResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryClassTracesResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryClassTracesResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut class_traces__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ClassTraces => {
                             if class_traces__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("classTraces"));
                             }
-                            class_traces__ = Some(map.next_value()?);
+                            class_traces__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -1727,25 +1729,25 @@ impl<'de> serde::Deserialize<'de> for QueryEscrowAddressRequest {
                 formatter.write_str("struct ibc.applications.nft_transfer.v1.QueryEscrowAddressRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryEscrowAddressRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryEscrowAddressRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut port_id__ = None;
                 let mut channel_id__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1827,18 +1829,18 @@ impl<'de> serde::Deserialize<'de> for QueryEscrowAddressResponse {
                 formatter.write_str("struct ibc.applications.nft_transfer.v1.QueryEscrowAddressResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryEscrowAddressResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryEscrowAddressResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut escrow_address__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::EscrowAddress => {
                             if escrow_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("escrowAddress"));
                             }
-                            escrow_address__ = Some(map.next_value()?);
+                            escrow_address__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1907,12 +1909,12 @@ impl<'de> serde::Deserialize<'de> for QueryParamsRequest {
                 formatter.write_str("struct ibc.applications.nft_transfer.v1.QueryParamsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryParamsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryParamsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(QueryParamsRequest {
                 })
@@ -1989,18 +1991,18 @@ impl<'de> serde::Deserialize<'de> for QueryParamsResponse {
                 formatter.write_str("struct ibc.applications.nft_transfer.v1.QueryParamsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryParamsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryParamsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut params__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Params => {
                             if params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("params"));
                             }
-                            params__ = map.next_value()?;
+                            params__ = map_.next_value()?;
                         }
                     }
                 }
diff --git a/src/prost/ibc.applications.transfer.v1.serde.rs b/src/prost/ibc.applications.transfer.v1.serde.rs
index 846c4f9b..23d490a8 100644
--- a/src/prost/ibc.applications.transfer.v1.serde.rs
+++ b/src/prost/ibc.applications.transfer.v1.serde.rs
@@ -97,7 +97,7 @@ impl<'de> serde::Deserialize<'de> for Allocation {
                 formatter.write_str("struct ibc.applications.transfer.v1.Allocation")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Allocation, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Allocation, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -105,31 +105,31 @@ impl<'de> serde::Deserialize<'de> for Allocation {
                 let mut source_channel__ = None;
                 let mut spend_limit__ = None;
                 let mut allow_list__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::SourcePort => {
                             if source_port__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sourcePort"));
                             }
-                            source_port__ = Some(map.next_value()?);
+                            source_port__ = Some(map_.next_value()?);
                         }
                         GeneratedField::SourceChannel => {
                             if source_channel__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sourceChannel"));
                             }
-                            source_channel__ = Some(map.next_value()?);
+                            source_channel__ = Some(map_.next_value()?);
                         }
                         GeneratedField::SpendLimit => {
                             if spend_limit__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("spendLimit"));
                             }
-                            spend_limit__ = Some(map.next_value()?);
+                            spend_limit__ = Some(map_.next_value()?);
                         }
                         GeneratedField::AllowList => {
                             if allow_list__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("allowList"));
                             }
-                            allow_list__ = Some(map.next_value()?);
+                            allow_list__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -222,25 +222,25 @@ impl<'de> serde::Deserialize<'de> for DenomTrace {
                 formatter.write_str("struct ibc.applications.transfer.v1.DenomTrace")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<DenomTrace, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<DenomTrace, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut path__ = None;
                 let mut base_denom__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Path => {
                             if path__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("path"));
                             }
-                            path__ = Some(map.next_value()?);
+                            path__ = Some(map_.next_value()?);
                         }
                         GeneratedField::BaseDenom => {
                             if base_denom__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("baseDenom"));
                             }
-                            base_denom__ = Some(map.next_value()?);
+                            base_denom__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -351,7 +351,7 @@ impl<'de> serde::Deserialize<'de> for GenesisState {
                 formatter.write_str("struct ibc.applications.transfer.v1.GenesisState")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<GenesisState, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<GenesisState, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -359,31 +359,31 @@ impl<'de> serde::Deserialize<'de> for GenesisState {
                 let mut denom_traces__ = None;
                 let mut params__ = None;
                 let mut total_escrowed__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::DenomTraces => {
                             if denom_traces__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("denomTraces"));
                             }
-                            denom_traces__ = Some(map.next_value()?);
+                            denom_traces__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Params => {
                             if params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("params"));
                             }
-                            params__ = map.next_value()?;
+                            params__ = map_.next_value()?;
                         }
                         GeneratedField::TotalEscrowed => {
                             if total_escrowed__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("totalEscrowed"));
                             }
-                            total_escrowed__ = Some(map.next_value()?);
+                            total_escrowed__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -450,6 +450,7 @@ impl serde::Serialize for MsgTransfer {
             struct_ser.serialize_field("timeoutHeight", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("timeoutTimestamp", ::alloc::string::ToString::to_string(&self.timeout_timestamp).as_str())?;
         }
         if true {
@@ -533,7 +534,7 @@ impl<'de> serde::Deserialize<'de> for MsgTransfer {
                 formatter.write_str("struct ibc.applications.transfer.v1.MsgTransfer")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgTransfer, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgTransfer, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -545,57 +546,57 @@ impl<'de> serde::Deserialize<'de> for MsgTransfer {
                 let mut timeout_height__ = None;
                 let mut timeout_timestamp__ = None;
                 let mut memo__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::SourcePort => {
                             if source_port__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sourcePort"));
                             }
-                            source_port__ = Some(map.next_value()?);
+                            source_port__ = Some(map_.next_value()?);
                         }
                         GeneratedField::SourceChannel => {
                             if source_channel__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sourceChannel"));
                             }
-                            source_channel__ = Some(map.next_value()?);
+                            source_channel__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Token => {
                             if token__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("token"));
                             }
-                            token__ = map.next_value()?;
+                            token__ = map_.next_value()?;
                         }
                         GeneratedField::Sender => {
                             if sender__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sender"));
                             }
-                            sender__ = Some(map.next_value()?);
+                            sender__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Receiver => {
                             if receiver__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("receiver"));
                             }
-                            receiver__ = Some(map.next_value()?);
+                            receiver__ = Some(map_.next_value()?);
                         }
                         GeneratedField::TimeoutHeight => {
                             if timeout_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("timeoutHeight"));
                             }
-                            timeout_height__ = map.next_value()?;
+                            timeout_height__ = map_.next_value()?;
                         }
                         GeneratedField::TimeoutTimestamp => {
                             if timeout_timestamp__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("timeoutTimestamp"));
                             }
                             timeout_timestamp__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Memo => {
                             if memo__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("memo"));
                             }
-                            memo__ = Some(map.next_value()?);
+                            memo__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -627,6 +628,7 @@ impl serde::Serialize for MsgTransferResponse {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.applications.transfer.v1.MsgTransferResponse", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?;
         }
         struct_ser.end()
@@ -682,19 +684,19 @@ impl<'de> serde::Deserialize<'de> for MsgTransferResponse {
                 formatter.write_str("struct ibc.applications.transfer.v1.MsgTransferResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgTransferResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgTransferResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut sequence__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Sequence => {
                             if sequence__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sequence"));
                             }
                             sequence__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -784,25 +786,25 @@ impl<'de> serde::Deserialize<'de> for MsgUpdateParams {
                 formatter.write_str("struct ibc.applications.transfer.v1.MsgUpdateParams")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgUpdateParams, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgUpdateParams, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut signer__ = None;
                 let mut params__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Signer => {
                             if signer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signer"));
                             }
-                            signer__ = Some(map.next_value()?);
+                            signer__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Params => {
                             if params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("params"));
                             }
-                            params__ = map.next_value()?;
+                            params__ = map_.next_value()?;
                         }
                     }
                 }
@@ -872,12 +874,12 @@ impl<'de> serde::Deserialize<'de> for MsgUpdateParamsResponse {
                 formatter.write_str("struct ibc.applications.transfer.v1.MsgUpdateParamsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgUpdateParamsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgUpdateParamsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgUpdateParamsResponse {
                 })
@@ -965,25 +967,25 @@ impl<'de> serde::Deserialize<'de> for Params {
                 formatter.write_str("struct ibc.applications.transfer.v1.Params")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Params, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Params, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut send_enabled__ = None;
                 let mut receive_enabled__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::SendEnabled => {
                             if send_enabled__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sendEnabled"));
                             }
-                            send_enabled__ = Some(map.next_value()?);
+                            send_enabled__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ReceiveEnabled => {
                             if receive_enabled__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("receiveEnabled"));
                             }
-                            receive_enabled__ = Some(map.next_value()?);
+                            receive_enabled__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1064,18 +1066,18 @@ impl<'de> serde::Deserialize<'de> for QueryDenomHashRequest {
                 formatter.write_str("struct ibc.applications.transfer.v1.QueryDenomHashRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryDenomHashRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryDenomHashRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut trace__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Trace => {
                             if trace__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("trace"));
                             }
-                            trace__ = Some(map.next_value()?);
+                            trace__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1155,18 +1157,18 @@ impl<'de> serde::Deserialize<'de> for QueryDenomHashResponse {
                 formatter.write_str("struct ibc.applications.transfer.v1.QueryDenomHashResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryDenomHashResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryDenomHashResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut hash__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Hash => {
                             if hash__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("hash"));
                             }
-                            hash__ = Some(map.next_value()?);
+                            hash__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1246,18 +1248,18 @@ impl<'de> serde::Deserialize<'de> for QueryDenomTraceRequest {
                 formatter.write_str("struct ibc.applications.transfer.v1.QueryDenomTraceRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryDenomTraceRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryDenomTraceRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut hash__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Hash => {
                             if hash__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("hash"));
                             }
-                            hash__ = Some(map.next_value()?);
+                            hash__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1338,18 +1340,18 @@ impl<'de> serde::Deserialize<'de> for QueryDenomTraceResponse {
                 formatter.write_str("struct ibc.applications.transfer.v1.QueryDenomTraceResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryDenomTraceResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryDenomTraceResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut denom_trace__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::DenomTrace => {
                             if denom_trace__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("denomTrace"));
                             }
-                            denom_trace__ = map.next_value()?;
+                            denom_trace__ = map_.next_value()?;
                         }
                     }
                 }
@@ -1429,18 +1431,18 @@ impl<'de> serde::Deserialize<'de> for QueryDenomTracesRequest {
                 formatter.write_str("struct ibc.applications.transfer.v1.QueryDenomTracesRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryDenomTracesRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryDenomTracesRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -1530,25 +1532,25 @@ impl<'de> serde::Deserialize<'de> for QueryDenomTracesResponse {
                 formatter.write_str("struct ibc.applications.transfer.v1.QueryDenomTracesResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryDenomTracesResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryDenomTracesResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut denom_traces__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::DenomTraces => {
                             if denom_traces__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("denomTraces"));
                             }
-                            denom_traces__ = Some(map.next_value()?);
+                            denom_traces__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -1640,25 +1642,25 @@ impl<'de> serde::Deserialize<'de> for QueryEscrowAddressRequest {
                 formatter.write_str("struct ibc.applications.transfer.v1.QueryEscrowAddressRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryEscrowAddressRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryEscrowAddressRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut port_id__ = None;
                 let mut channel_id__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1740,18 +1742,18 @@ impl<'de> serde::Deserialize<'de> for QueryEscrowAddressResponse {
                 formatter.write_str("struct ibc.applications.transfer.v1.QueryEscrowAddressResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryEscrowAddressResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryEscrowAddressResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut escrow_address__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::EscrowAddress => {
                             if escrow_address__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("escrowAddress"));
                             }
-                            escrow_address__ = Some(map.next_value()?);
+                            escrow_address__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1820,12 +1822,12 @@ impl<'de> serde::Deserialize<'de> for QueryParamsRequest {
                 formatter.write_str("struct ibc.applications.transfer.v1.QueryParamsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryParamsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryParamsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(QueryParamsRequest {
                 })
@@ -1902,18 +1904,18 @@ impl<'de> serde::Deserialize<'de> for QueryParamsResponse {
                 formatter.write_str("struct ibc.applications.transfer.v1.QueryParamsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryParamsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryParamsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut params__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Params => {
                             if params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("params"));
                             }
-                            params__ = map.next_value()?;
+                            params__ = map_.next_value()?;
                         }
                     }
                 }
@@ -1993,18 +1995,18 @@ impl<'de> serde::Deserialize<'de> for QueryTotalEscrowForDenomRequest {
                 formatter.write_str("struct ibc.applications.transfer.v1.QueryTotalEscrowForDenomRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryTotalEscrowForDenomRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryTotalEscrowForDenomRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut denom__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Denom => {
                             if denom__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("denom"));
                             }
-                            denom__ = Some(map.next_value()?);
+                            denom__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -2084,18 +2086,18 @@ impl<'de> serde::Deserialize<'de> for QueryTotalEscrowForDenomResponse {
                 formatter.write_str("struct ibc.applications.transfer.v1.QueryTotalEscrowForDenomResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryTotalEscrowForDenomResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryTotalEscrowForDenomResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut amount__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Amount => {
                             if amount__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("amount"));
                             }
-                            amount__ = map.next_value()?;
+                            amount__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2175,18 +2177,18 @@ impl<'de> serde::Deserialize<'de> for TransferAuthorization {
                 formatter.write_str("struct ibc.applications.transfer.v1.TransferAuthorization")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<TransferAuthorization, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<TransferAuthorization, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut allocations__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Allocations => {
                             if allocations__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("allocations"));
                             }
-                            allocations__ = Some(map.next_value()?);
+                            allocations__ = Some(map_.next_value()?);
                         }
                     }
                 }
diff --git a/src/prost/ibc.applications.transfer.v2.serde.rs b/src/prost/ibc.applications.transfer.v2.serde.rs
index e5631f1d..251c80e2 100644
--- a/src/prost/ibc.applications.transfer.v2.serde.rs
+++ b/src/prost/ibc.applications.transfer.v2.serde.rs
@@ -102,7 +102,7 @@ impl<'de> serde::Deserialize<'de> for FungibleTokenPacketData {
                 formatter.write_str("struct ibc.applications.transfer.v2.FungibleTokenPacketData")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<FungibleTokenPacketData, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<FungibleTokenPacketData, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -111,37 +111,37 @@ impl<'de> serde::Deserialize<'de> for FungibleTokenPacketData {
                 let mut sender__ = None;
                 let mut receiver__ = None;
                 let mut memo__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Denom => {
                             if denom__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("denom"));
                             }
-                            denom__ = Some(map.next_value()?);
+                            denom__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Amount => {
                             if amount__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("amount"));
                             }
-                            amount__ = Some(map.next_value()?);
+                            amount__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Sender => {
                             if sender__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sender"));
                             }
-                            sender__ = Some(map.next_value()?);
+                            sender__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Receiver => {
                             if receiver__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("receiver"));
                             }
-                            receiver__ = Some(map.next_value()?);
+                            receiver__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Memo => {
                             if memo__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("memo"));
                             }
-                            memo__ = Some(map.next_value()?);
+                            memo__ = Some(map_.next_value()?);
                         }
                     }
                 }
diff --git a/src/prost/ibc.core.channel.v1.serde.rs b/src/prost/ibc.core.channel.v1.serde.rs
index cd67218c..1bf7c67b 100644
--- a/src/prost/ibc.core.channel.v1.serde.rs
+++ b/src/prost/ibc.core.channel.v1.serde.rs
@@ -13,7 +13,8 @@ impl serde::Serialize for Acknowledgement {
         if let Some(v) = self.response.as_ref() {
             match v {
                 acknowledgement::Response::Result(v) => {
-                    struct_ser.serialize_field("result", pbjson::private::base64::encode(v).as_str())?;
+                    #[allow(clippy::needless_borrow)]
+                    struct_ser.serialize_field("result", pbjson::private::base64::encode(&v).as_str())?;
                 }
                 acknowledgement::Response::Error(v) => {
                     struct_ser.serialize_field("error", v)?;
@@ -76,24 +77,24 @@ impl<'de> serde::Deserialize<'de> for Acknowledgement {
                 formatter.write_str("struct ibc.core.channel.v1.Acknowledgement")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Acknowledgement, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Acknowledgement, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut response__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Result => {
                             if response__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("result"));
                             }
-                            response__ = map.next_value::<::core::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| acknowledgement::Response::Result(x.0));
+                            response__ = map_.next_value::<::core::option::Option<::pbjson::private::BytesDeserialize<_>>>()?.map(|x| acknowledgement::Response::Result(x.0));
                         }
                         GeneratedField::Error => {
                             if response__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("error"));
                             }
-                            response__ = map.next_value::<::core::option::Option<_>>()?.map(acknowledgement::Response::Error);
+                            response__ = map_.next_value::<::core::option::Option<_>>()?.map(acknowledgement::Response::Error);
                         }
                     }
                 }
@@ -130,13 +131,13 @@ impl serde::Serialize for Channel {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.Channel", len)?;
         if true {
-            let v = State::from_i32(self.state)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.state)))?;
+            let v = State::try_from(self.state)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.state)))?;
             struct_ser.serialize_field("state", &v)?;
         }
         if true {
-            let v = Order::from_i32(self.ordering)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.ordering)))?;
+            let v = Order::try_from(self.ordering)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.ordering)))?;
             struct_ser.serialize_field("ordering", &v)?;
         }
         if let Some(v) = self.counterparty.as_ref() {
@@ -214,7 +215,7 @@ impl<'de> serde::Deserialize<'de> for Channel {
                 formatter.write_str("struct ibc.core.channel.v1.Channel")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Channel, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Channel, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -223,37 +224,37 @@ impl<'de> serde::Deserialize<'de> for Channel {
                 let mut counterparty__ = None;
                 let mut connection_hops__ = None;
                 let mut version__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::State => {
                             if state__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("state"));
                             }
-                            state__ = Some(map.next_value::<State>()? as i32);
+                            state__ = Some(map_.next_value::<State>()? as i32);
                         }
                         GeneratedField::Ordering => {
                             if ordering__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("ordering"));
                             }
-                            ordering__ = Some(map.next_value::<Order>()? as i32);
+                            ordering__ = Some(map_.next_value::<Order>()? as i32);
                         }
                         GeneratedField::Counterparty => {
                             if counterparty__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("counterparty"));
                             }
-                            counterparty__ = map.next_value()?;
+                            counterparty__ = map_.next_value()?;
                         }
                         GeneratedField::ConnectionHops => {
                             if connection_hops__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("connectionHops"));
                             }
-                            connection_hops__ = Some(map.next_value()?);
+                            connection_hops__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Version => {
                             if version__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("version"));
                             }
-                            version__ = Some(map.next_value()?);
+                            version__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -348,25 +349,25 @@ impl<'de> serde::Deserialize<'de> for Counterparty {
                 formatter.write_str("struct ibc.core.channel.v1.Counterparty")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Counterparty, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Counterparty, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut port_id__ = None;
                 let mut channel_id__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -434,6 +435,7 @@ impl serde::Serialize for GenesisState {
             struct_ser.serialize_field("ackSequences", &self.ack_sequences)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("nextChannelSequence", ::alloc::string::ToString::to_string(&self.next_channel_sequence).as_str())?;
         }
         struct_ser.end()
@@ -514,7 +516,7 @@ impl<'de> serde::Deserialize<'de> for GenesisState {
                 formatter.write_str("struct ibc.core.channel.v1.GenesisState")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<GenesisState, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<GenesisState, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -526,56 +528,56 @@ impl<'de> serde::Deserialize<'de> for GenesisState {
                 let mut recv_sequences__ = None;
                 let mut ack_sequences__ = None;
                 let mut next_channel_sequence__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Channels => {
                             if channels__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channels"));
                             }
-                            channels__ = Some(map.next_value()?);
+                            channels__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Acknowledgements => {
                             if acknowledgements__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("acknowledgements"));
                             }
-                            acknowledgements__ = Some(map.next_value()?);
+                            acknowledgements__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Commitments => {
                             if commitments__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("commitments"));
                             }
-                            commitments__ = Some(map.next_value()?);
+                            commitments__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Receipts => {
                             if receipts__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("receipts"));
                             }
-                            receipts__ = Some(map.next_value()?);
+                            receipts__ = Some(map_.next_value()?);
                         }
                         GeneratedField::SendSequences => {
                             if send_sequences__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sendSequences"));
                             }
-                            send_sequences__ = Some(map.next_value()?);
+                            send_sequences__ = Some(map_.next_value()?);
                         }
                         GeneratedField::RecvSequences => {
                             if recv_sequences__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("recvSequences"));
                             }
-                            recv_sequences__ = Some(map.next_value()?);
+                            recv_sequences__ = Some(map_.next_value()?);
                         }
                         GeneratedField::AckSequences => {
                             if ack_sequences__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("ackSequences"));
                             }
-                            ack_sequences__ = Some(map.next_value()?);
+                            ack_sequences__ = Some(map_.next_value()?);
                         }
                         GeneratedField::NextChannelSequence => {
                             if next_channel_sequence__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("nextChannelSequence"));
                             }
                             next_channel_sequence__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -626,13 +628,13 @@ impl serde::Serialize for IdentifiedChannel {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.IdentifiedChannel", len)?;
         if true {
-            let v = State::from_i32(self.state)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.state)))?;
+            let v = State::try_from(self.state)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.state)))?;
             struct_ser.serialize_field("state", &v)?;
         }
         if true {
-            let v = Order::from_i32(self.ordering)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.ordering)))?;
+            let v = Order::try_from(self.ordering)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.ordering)))?;
             struct_ser.serialize_field("ordering", &v)?;
         }
         if let Some(v) = self.counterparty.as_ref() {
@@ -724,7 +726,7 @@ impl<'de> serde::Deserialize<'de> for IdentifiedChannel {
                 formatter.write_str("struct ibc.core.channel.v1.IdentifiedChannel")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<IdentifiedChannel, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<IdentifiedChannel, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -735,49 +737,49 @@ impl<'de> serde::Deserialize<'de> for IdentifiedChannel {
                 let mut version__ = None;
                 let mut port_id__ = None;
                 let mut channel_id__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::State => {
                             if state__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("state"));
                             }
-                            state__ = Some(map.next_value::<State>()? as i32);
+                            state__ = Some(map_.next_value::<State>()? as i32);
                         }
                         GeneratedField::Ordering => {
                             if ordering__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("ordering"));
                             }
-                            ordering__ = Some(map.next_value::<Order>()? as i32);
+                            ordering__ = Some(map_.next_value::<Order>()? as i32);
                         }
                         GeneratedField::Counterparty => {
                             if counterparty__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("counterparty"));
                             }
-                            counterparty__ = map.next_value()?;
+                            counterparty__ = map_.next_value()?;
                         }
                         GeneratedField::ConnectionHops => {
                             if connection_hops__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("connectionHops"));
                             }
-                            connection_hops__ = Some(map.next_value()?);
+                            connection_hops__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Version => {
                             if version__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("version"));
                             }
-                            version__ = Some(map.next_value()?);
+                            version__ = Some(map_.next_value()?);
                         }
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -823,9 +825,11 @@ impl serde::Serialize for MsgAcknowledgement {
             struct_ser.serialize_field("packet", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("acknowledgement", pbjson::private::base64::encode(&self.acknowledgement).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proofAcked", pbjson::private::base64::encode(&self.proof_acked).as_str())?;
         }
         if let Some(v) = self.proof_height.as_ref() {
@@ -901,7 +905,7 @@ impl<'de> serde::Deserialize<'de> for MsgAcknowledgement {
                 formatter.write_str("struct ibc.core.channel.v1.MsgAcknowledgement")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgAcknowledgement, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgAcknowledgement, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -910,20 +914,20 @@ impl<'de> serde::Deserialize<'de> for MsgAcknowledgement {
                 let mut proof_acked__ = None;
                 let mut proof_height__ = None;
                 let mut signer__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Packet => {
                             if packet__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("packet"));
                             }
-                            packet__ = map.next_value()?;
+                            packet__ = map_.next_value()?;
                         }
                         GeneratedField::Acknowledgement => {
                             if acknowledgement__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("acknowledgement"));
                             }
                             acknowledgement__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ProofAcked => {
@@ -931,20 +935,20 @@ impl<'de> serde::Deserialize<'de> for MsgAcknowledgement {
                                 return Err(serde::de::Error::duplicate_field("proofAcked"));
                             }
                             proof_acked__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ProofHeight => {
                             if proof_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofHeight"));
                             }
-                            proof_height__ = map.next_value()?;
+                            proof_height__ = map_.next_value()?;
                         }
                         GeneratedField::Signer => {
                             if signer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signer"));
                             }
-                            signer__ = Some(map.next_value()?);
+                            signer__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -973,8 +977,8 @@ impl serde::Serialize for MsgAcknowledgementResponse {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgAcknowledgementResponse", len)?;
         if true {
-            let v = ResponseResultType::from_i32(self.result)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.result)))?;
+            let v = ResponseResultType::try_from(self.result)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.result)))?;
             struct_ser.serialize_field("result", &v)?;
         }
         struct_ser.end()
@@ -1030,18 +1034,18 @@ impl<'de> serde::Deserialize<'de> for MsgAcknowledgementResponse {
                 formatter.write_str("struct ibc.core.channel.v1.MsgAcknowledgementResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgAcknowledgementResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgAcknowledgementResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut result__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Result => {
                             if result__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("result"));
                             }
-                            result__ = Some(map.next_value::<ResponseResultType>()? as i32);
+                            result__ = Some(map_.next_value::<ResponseResultType>()? as i32);
                         }
                     }
                 }
@@ -1084,6 +1088,7 @@ impl serde::Serialize for MsgChannelCloseConfirm {
             struct_ser.serialize_field("channelId", &self.channel_id)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proofInit", pbjson::private::base64::encode(&self.proof_init).as_str())?;
         }
         if let Some(v) = self.proof_height.as_ref() {
@@ -1161,7 +1166,7 @@ impl<'de> serde::Deserialize<'de> for MsgChannelCloseConfirm {
                 formatter.write_str("struct ibc.core.channel.v1.MsgChannelCloseConfirm")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgChannelCloseConfirm, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgChannelCloseConfirm, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -1170,39 +1175,39 @@ impl<'de> serde::Deserialize<'de> for MsgChannelCloseConfirm {
                 let mut proof_init__ = None;
                 let mut proof_height__ = None;
                 let mut signer__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ProofInit => {
                             if proof_init__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofInit"));
                             }
                             proof_init__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ProofHeight => {
                             if proof_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofHeight"));
                             }
-                            proof_height__ = map.next_value()?;
+                            proof_height__ = map_.next_value()?;
                         }
                         GeneratedField::Signer => {
                             if signer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signer"));
                             }
-                            signer__ = Some(map.next_value()?);
+                            signer__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1275,12 +1280,12 @@ impl<'de> serde::Deserialize<'de> for MsgChannelCloseConfirmResponse {
                 formatter.write_str("struct ibc.core.channel.v1.MsgChannelCloseConfirmResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgChannelCloseConfirmResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgChannelCloseConfirmResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgChannelCloseConfirmResponse {
                 })
@@ -1377,32 +1382,32 @@ impl<'de> serde::Deserialize<'de> for MsgChannelCloseInit {
                 formatter.write_str("struct ibc.core.channel.v1.MsgChannelCloseInit")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgChannelCloseInit, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgChannelCloseInit, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut port_id__ = None;
                 let mut channel_id__ = None;
                 let mut signer__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Signer => {
                             if signer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signer"));
                             }
-                            signer__ = Some(map.next_value()?);
+                            signer__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1473,12 +1478,12 @@ impl<'de> serde::Deserialize<'de> for MsgChannelCloseInitResponse {
                 formatter.write_str("struct ibc.core.channel.v1.MsgChannelCloseInitResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgChannelCloseInitResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgChannelCloseInitResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgChannelCloseInitResponse {
                 })
@@ -1530,6 +1535,7 @@ impl serde::Serialize for MsgChannelOpenAck {
             struct_ser.serialize_field("counterpartyVersion", &self.counterparty_version)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proofTry", pbjson::private::base64::encode(&self.proof_try).as_str())?;
         }
         if let Some(v) = self.proof_height.as_ref() {
@@ -1615,7 +1621,7 @@ impl<'de> serde::Deserialize<'de> for MsgChannelOpenAck {
                 formatter.write_str("struct ibc.core.channel.v1.MsgChannelOpenAck")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgChannelOpenAck, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgChannelOpenAck, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -1626,51 +1632,51 @@ impl<'de> serde::Deserialize<'de> for MsgChannelOpenAck {
                 let mut proof_try__ = None;
                 let mut proof_height__ = None;
                 let mut signer__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::CounterpartyChannelId => {
                             if counterparty_channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("counterpartyChannelId"));
                             }
-                            counterparty_channel_id__ = Some(map.next_value()?);
+                            counterparty_channel_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::CounterpartyVersion => {
                             if counterparty_version__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("counterpartyVersion"));
                             }
-                            counterparty_version__ = Some(map.next_value()?);
+                            counterparty_version__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ProofTry => {
                             if proof_try__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofTry"));
                             }
                             proof_try__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ProofHeight => {
                             if proof_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofHeight"));
                             }
-                            proof_height__ = map.next_value()?;
+                            proof_height__ = map_.next_value()?;
                         }
                         GeneratedField::Signer => {
                             if signer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signer"));
                             }
-                            signer__ = Some(map.next_value()?);
+                            signer__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1745,12 +1751,12 @@ impl<'de> serde::Deserialize<'de> for MsgChannelOpenAckResponse {
                 formatter.write_str("struct ibc.core.channel.v1.MsgChannelOpenAckResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgChannelOpenAckResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgChannelOpenAckResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgChannelOpenAckResponse {
                 })
@@ -1790,6 +1796,7 @@ impl serde::Serialize for MsgChannelOpenConfirm {
             struct_ser.serialize_field("channelId", &self.channel_id)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proofAck", pbjson::private::base64::encode(&self.proof_ack).as_str())?;
         }
         if let Some(v) = self.proof_height.as_ref() {
@@ -1867,7 +1874,7 @@ impl<'de> serde::Deserialize<'de> for MsgChannelOpenConfirm {
                 formatter.write_str("struct ibc.core.channel.v1.MsgChannelOpenConfirm")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgChannelOpenConfirm, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgChannelOpenConfirm, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -1876,39 +1883,39 @@ impl<'de> serde::Deserialize<'de> for MsgChannelOpenConfirm {
                 let mut proof_ack__ = None;
                 let mut proof_height__ = None;
                 let mut signer__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ProofAck => {
                             if proof_ack__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofAck"));
                             }
                             proof_ack__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ProofHeight => {
                             if proof_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofHeight"));
                             }
-                            proof_height__ = map.next_value()?;
+                            proof_height__ = map_.next_value()?;
                         }
                         GeneratedField::Signer => {
                             if signer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signer"));
                             }
-                            signer__ = Some(map.next_value()?);
+                            signer__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1981,12 +1988,12 @@ impl<'de> serde::Deserialize<'de> for MsgChannelOpenConfirmResponse {
                 formatter.write_str("struct ibc.core.channel.v1.MsgChannelOpenConfirmResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgChannelOpenConfirmResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgChannelOpenConfirmResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgChannelOpenConfirmResponse {
                 })
@@ -2082,32 +2089,32 @@ impl<'de> serde::Deserialize<'de> for MsgChannelOpenInit {
                 formatter.write_str("struct ibc.core.channel.v1.MsgChannelOpenInit")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgChannelOpenInit, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgChannelOpenInit, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut port_id__ = None;
                 let mut channel__ = None;
                 let mut signer__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Channel => {
                             if channel__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channel"));
                             }
-                            channel__ = map.next_value()?;
+                            channel__ = map_.next_value()?;
                         }
                         GeneratedField::Signer => {
                             if signer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signer"));
                             }
-                            signer__ = Some(map.next_value()?);
+                            signer__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -2199,25 +2206,25 @@ impl<'de> serde::Deserialize<'de> for MsgChannelOpenInitResponse {
                 formatter.write_str("struct ibc.core.channel.v1.MsgChannelOpenInitResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgChannelOpenInitResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgChannelOpenInitResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut channel_id__ = None;
                 let mut version__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Version => {
                             if version__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("version"));
                             }
-                            version__ = Some(map.next_value()?);
+                            version__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -2273,6 +2280,7 @@ impl serde::Serialize for MsgChannelOpenTry {
             struct_ser.serialize_field("counterpartyVersion", &self.counterparty_version)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proofInit", pbjson::private::base64::encode(&self.proof_init).as_str())?;
         }
         if let Some(v) = self.proof_height.as_ref() {
@@ -2357,7 +2365,7 @@ impl<'de> serde::Deserialize<'de> for MsgChannelOpenTry {
                 formatter.write_str("struct ibc.core.channel.v1.MsgChannelOpenTry")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgChannelOpenTry, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgChannelOpenTry, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -2368,51 +2376,51 @@ impl<'de> serde::Deserialize<'de> for MsgChannelOpenTry {
                 let mut proof_init__ = None;
                 let mut proof_height__ = None;
                 let mut signer__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::PreviousChannelId => {
                             if previous_channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("previousChannelId"));
                             }
-                            previous_channel_id__ = Some(map.next_value()?);
+                            previous_channel_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Channel => {
                             if channel__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channel"));
                             }
-                            channel__ = map.next_value()?;
+                            channel__ = map_.next_value()?;
                         }
                         GeneratedField::CounterpartyVersion => {
                             if counterparty_version__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("counterpartyVersion"));
                             }
-                            counterparty_version__ = Some(map.next_value()?);
+                            counterparty_version__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ProofInit => {
                             if proof_init__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofInit"));
                             }
                             proof_init__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ProofHeight => {
                             if proof_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofHeight"));
                             }
-                            proof_height__ = map.next_value()?;
+                            proof_height__ = map_.next_value()?;
                         }
                         GeneratedField::Signer => {
                             if signer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signer"));
                             }
-                            signer__ = Some(map.next_value()?);
+                            signer__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -2508,25 +2516,25 @@ impl<'de> serde::Deserialize<'de> for MsgChannelOpenTryResponse {
                 formatter.write_str("struct ibc.core.channel.v1.MsgChannelOpenTryResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgChannelOpenTryResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgChannelOpenTryResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut version__ = None;
                 let mut channel_id__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Version => {
                             if version__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("version"));
                             }
-                            version__ = Some(map.next_value()?);
+                            version__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -2564,6 +2572,7 @@ impl serde::Serialize for MsgRecvPacket {
             struct_ser.serialize_field("packet", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proofCommitment", pbjson::private::base64::encode(&self.proof_commitment).as_str())?;
         }
         if let Some(v) = self.proof_height.as_ref() {
@@ -2636,7 +2645,7 @@ impl<'de> serde::Deserialize<'de> for MsgRecvPacket {
                 formatter.write_str("struct ibc.core.channel.v1.MsgRecvPacket")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgRecvPacket, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgRecvPacket, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -2644,33 +2653,33 @@ impl<'de> serde::Deserialize<'de> for MsgRecvPacket {
                 let mut proof_commitment__ = None;
                 let mut proof_height__ = None;
                 let mut signer__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Packet => {
                             if packet__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("packet"));
                             }
-                            packet__ = map.next_value()?;
+                            packet__ = map_.next_value()?;
                         }
                         GeneratedField::ProofCommitment => {
                             if proof_commitment__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofCommitment"));
                             }
                             proof_commitment__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ProofHeight => {
                             if proof_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofHeight"));
                             }
-                            proof_height__ = map.next_value()?;
+                            proof_height__ = map_.next_value()?;
                         }
                         GeneratedField::Signer => {
                             if signer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signer"));
                             }
-                            signer__ = Some(map.next_value()?);
+                            signer__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -2698,8 +2707,8 @@ impl serde::Serialize for MsgRecvPacketResponse {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgRecvPacketResponse", len)?;
         if true {
-            let v = ResponseResultType::from_i32(self.result)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.result)))?;
+            let v = ResponseResultType::try_from(self.result)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.result)))?;
             struct_ser.serialize_field("result", &v)?;
         }
         struct_ser.end()
@@ -2755,18 +2764,18 @@ impl<'de> serde::Deserialize<'de> for MsgRecvPacketResponse {
                 formatter.write_str("struct ibc.core.channel.v1.MsgRecvPacketResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgRecvPacketResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgRecvPacketResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut result__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Result => {
                             if result__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("result"));
                             }
-                            result__ = Some(map.next_value::<ResponseResultType>()? as i32);
+                            result__ = Some(map_.next_value::<ResponseResultType>()? as i32);
                         }
                     }
                 }
@@ -2806,12 +2815,14 @@ impl serde::Serialize for MsgTimeout {
             struct_ser.serialize_field("packet", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proofUnreceived", pbjson::private::base64::encode(&self.proof_unreceived).as_str())?;
         }
         if let Some(v) = self.proof_height.as_ref() {
             struct_ser.serialize_field("proofHeight", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("nextSequenceRecv", ::alloc::string::ToString::to_string(&self.next_sequence_recv).as_str())?;
         }
         if true {
@@ -2885,7 +2896,7 @@ impl<'de> serde::Deserialize<'de> for MsgTimeout {
                 formatter.write_str("struct ibc.core.channel.v1.MsgTimeout")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgTimeout, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgTimeout, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -2894,41 +2905,41 @@ impl<'de> serde::Deserialize<'de> for MsgTimeout {
                 let mut proof_height__ = None;
                 let mut next_sequence_recv__ = None;
                 let mut signer__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Packet => {
                             if packet__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("packet"));
                             }
-                            packet__ = map.next_value()?;
+                            packet__ = map_.next_value()?;
                         }
                         GeneratedField::ProofUnreceived => {
                             if proof_unreceived__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofUnreceived"));
                             }
                             proof_unreceived__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ProofHeight => {
                             if proof_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofHeight"));
                             }
-                            proof_height__ = map.next_value()?;
+                            proof_height__ = map_.next_value()?;
                         }
                         GeneratedField::NextSequenceRecv => {
                             if next_sequence_recv__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("nextSequenceRecv"));
                             }
                             next_sequence_recv__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Signer => {
                             if signer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signer"));
                             }
-                            signer__ = Some(map.next_value()?);
+                            signer__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -2975,15 +2986,18 @@ impl serde::Serialize for MsgTimeoutOnClose {
             struct_ser.serialize_field("packet", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proofUnreceived", pbjson::private::base64::encode(&self.proof_unreceived).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proofClose", pbjson::private::base64::encode(&self.proof_close).as_str())?;
         }
         if let Some(v) = self.proof_height.as_ref() {
             struct_ser.serialize_field("proofHeight", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("nextSequenceRecv", ::alloc::string::ToString::to_string(&self.next_sequence_recv).as_str())?;
         }
         if true {
@@ -3061,7 +3075,7 @@ impl<'de> serde::Deserialize<'de> for MsgTimeoutOnClose {
                 formatter.write_str("struct ibc.core.channel.v1.MsgTimeoutOnClose")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgTimeoutOnClose, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgTimeoutOnClose, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -3071,20 +3085,20 @@ impl<'de> serde::Deserialize<'de> for MsgTimeoutOnClose {
                 let mut proof_height__ = None;
                 let mut next_sequence_recv__ = None;
                 let mut signer__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Packet => {
                             if packet__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("packet"));
                             }
-                            packet__ = map.next_value()?;
+                            packet__ = map_.next_value()?;
                         }
                         GeneratedField::ProofUnreceived => {
                             if proof_unreceived__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofUnreceived"));
                             }
                             proof_unreceived__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ProofClose => {
@@ -3092,28 +3106,28 @@ impl<'de> serde::Deserialize<'de> for MsgTimeoutOnClose {
                                 return Err(serde::de::Error::duplicate_field("proofClose"));
                             }
                             proof_close__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ProofHeight => {
                             if proof_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofHeight"));
                             }
-                            proof_height__ = map.next_value()?;
+                            proof_height__ = map_.next_value()?;
                         }
                         GeneratedField::NextSequenceRecv => {
                             if next_sequence_recv__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("nextSequenceRecv"));
                             }
                             next_sequence_recv__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Signer => {
                             if signer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signer"));
                             }
-                            signer__ = Some(map.next_value()?);
+                            signer__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -3143,8 +3157,8 @@ impl serde::Serialize for MsgTimeoutOnCloseResponse {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgTimeoutOnCloseResponse", len)?;
         if true {
-            let v = ResponseResultType::from_i32(self.result)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.result)))?;
+            let v = ResponseResultType::try_from(self.result)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.result)))?;
             struct_ser.serialize_field("result", &v)?;
         }
         struct_ser.end()
@@ -3200,18 +3214,18 @@ impl<'de> serde::Deserialize<'de> for MsgTimeoutOnCloseResponse {
                 formatter.write_str("struct ibc.core.channel.v1.MsgTimeoutOnCloseResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgTimeoutOnCloseResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgTimeoutOnCloseResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut result__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Result => {
                             if result__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("result"));
                             }
-                            result__ = Some(map.next_value::<ResponseResultType>()? as i32);
+                            result__ = Some(map_.next_value::<ResponseResultType>()? as i32);
                         }
                     }
                 }
@@ -3236,8 +3250,8 @@ impl serde::Serialize for MsgTimeoutResponse {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.MsgTimeoutResponse", len)?;
         if true {
-            let v = ResponseResultType::from_i32(self.result)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.result)))?;
+            let v = ResponseResultType::try_from(self.result)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.result)))?;
             struct_ser.serialize_field("result", &v)?;
         }
         struct_ser.end()
@@ -3293,18 +3307,18 @@ impl<'de> serde::Deserialize<'de> for MsgTimeoutResponse {
                 formatter.write_str("struct ibc.core.channel.v1.MsgTimeoutResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgTimeoutResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgTimeoutResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut result__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Result => {
                             if result__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("result"));
                             }
-                            result__ = Some(map.next_value::<ResponseResultType>()? as i32);
+                            result__ = Some(map_.next_value::<ResponseResultType>()? as i32);
                         }
                     }
                 }
@@ -3355,10 +3369,9 @@ impl<'de> serde::Deserialize<'de> for Order {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(Order::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -3368,10 +3381,9 @@ impl<'de> serde::Deserialize<'de> for Order {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(Order::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
@@ -3426,6 +3438,7 @@ impl serde::Serialize for Packet {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.Packet", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?;
         }
         if true {
@@ -3441,12 +3454,14 @@ impl serde::Serialize for Packet {
             struct_ser.serialize_field("destinationChannel", &self.destination_channel)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("data", pbjson::private::base64::encode(&self.data).as_str())?;
         }
         if let Some(v) = self.timeout_height.as_ref() {
             struct_ser.serialize_field("timeoutHeight", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("timeoutTimestamp", ::alloc::string::ToString::to_string(&self.timeout_timestamp).as_str())?;
         }
         struct_ser.end()
@@ -3529,7 +3544,7 @@ impl<'de> serde::Deserialize<'de> for Packet {
                 formatter.write_str("struct ibc.core.channel.v1.Packet")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Packet, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Packet, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -3541,60 +3556,60 @@ impl<'de> serde::Deserialize<'de> for Packet {
                 let mut data__ = None;
                 let mut timeout_height__ = None;
                 let mut timeout_timestamp__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Sequence => {
                             if sequence__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sequence"));
                             }
                             sequence__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::SourcePort => {
                             if source_port__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sourcePort"));
                             }
-                            source_port__ = Some(map.next_value()?);
+                            source_port__ = Some(map_.next_value()?);
                         }
                         GeneratedField::SourceChannel => {
                             if source_channel__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sourceChannel"));
                             }
-                            source_channel__ = Some(map.next_value()?);
+                            source_channel__ = Some(map_.next_value()?);
                         }
                         GeneratedField::DestinationPort => {
                             if destination_port__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("destinationPort"));
                             }
-                            destination_port__ = Some(map.next_value()?);
+                            destination_port__ = Some(map_.next_value()?);
                         }
                         GeneratedField::DestinationChannel => {
                             if destination_channel__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("destinationChannel"));
                             }
-                            destination_channel__ = Some(map.next_value()?);
+                            destination_channel__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Data => {
                             if data__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("data"));
                             }
                             data__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::TimeoutHeight => {
                             if timeout_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("timeoutHeight"));
                             }
-                            timeout_height__ = map.next_value()?;
+                            timeout_height__ = map_.next_value()?;
                         }
                         GeneratedField::TimeoutTimestamp => {
                             if timeout_timestamp__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("timeoutTimestamp"));
                             }
                             timeout_timestamp__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -3639,6 +3654,7 @@ impl serde::Serialize for PacketId {
             struct_ser.serialize_field("channelId", &self.channel_id)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?;
         }
         struct_ser.end()
@@ -3702,33 +3718,33 @@ impl<'de> serde::Deserialize<'de> for PacketId {
                 formatter.write_str("struct ibc.core.channel.v1.PacketId")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<PacketId, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<PacketId, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut port_id__ = None;
                 let mut channel_id__ = None;
                 let mut sequence__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Sequence => {
                             if sequence__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sequence"));
                             }
                             sequence__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -3768,6 +3784,7 @@ impl serde::Serialize for PacketSequence {
             struct_ser.serialize_field("channelId", &self.channel_id)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?;
         }
         struct_ser.end()
@@ -3831,33 +3848,33 @@ impl<'de> serde::Deserialize<'de> for PacketSequence {
                 formatter.write_str("struct ibc.core.channel.v1.PacketSequence")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<PacketSequence, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<PacketSequence, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut port_id__ = None;
                 let mut channel_id__ = None;
                 let mut sequence__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Sequence => {
                             if sequence__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sequence"));
                             }
                             sequence__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -3900,9 +3917,11 @@ impl serde::Serialize for PacketState {
             struct_ser.serialize_field("channelId", &self.channel_id)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("data", pbjson::private::base64::encode(&self.data).as_str())?;
         }
         struct_ser.end()
@@ -3969,7 +3988,7 @@ impl<'de> serde::Deserialize<'de> for PacketState {
                 formatter.write_str("struct ibc.core.channel.v1.PacketState")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<PacketState, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<PacketState, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -3977,26 +3996,26 @@ impl<'de> serde::Deserialize<'de> for PacketState {
                 let mut channel_id__ = None;
                 let mut sequence__ = None;
                 let mut data__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Sequence => {
                             if sequence__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sequence"));
                             }
                             sequence__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Data => {
@@ -4004,7 +4023,7 @@ impl<'de> serde::Deserialize<'de> for PacketState {
                                 return Err(serde::de::Error::duplicate_field("data"));
                             }
                             data__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -4099,25 +4118,25 @@ impl<'de> serde::Deserialize<'de> for QueryChannelClientStateRequest {
                 formatter.write_str("struct ibc.core.channel.v1.QueryChannelClientStateRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryChannelClientStateRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryChannelClientStateRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut port_id__ = None;
                 let mut channel_id__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -4152,6 +4171,7 @@ impl serde::Serialize for QueryChannelClientStateResponse {
             struct_ser.serialize_field("identifiedClientState", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proof", pbjson::private::base64::encode(&self.proof).as_str())?;
         }
         if let Some(v) = self.proof_height.as_ref() {
@@ -4218,34 +4238,34 @@ impl<'de> serde::Deserialize<'de> for QueryChannelClientStateResponse {
                 formatter.write_str("struct ibc.core.channel.v1.QueryChannelClientStateResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryChannelClientStateResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryChannelClientStateResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut identified_client_state__ = None;
                 let mut proof__ = None;
                 let mut proof_height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::IdentifiedClientState => {
                             if identified_client_state__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("identifiedClientState"));
                             }
-                            identified_client_state__ = map.next_value()?;
+                            identified_client_state__ = map_.next_value()?;
                         }
                         GeneratedField::Proof => {
                             if proof__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proof"));
                             }
                             proof__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ProofHeight => {
                             if proof_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofHeight"));
                             }
-                            proof_height__ = map.next_value()?;
+                            proof_height__ = map_.next_value()?;
                         }
                     }
                 }
@@ -4287,9 +4307,11 @@ impl serde::Serialize for QueryChannelConsensusStateRequest {
             struct_ser.serialize_field("channelId", &self.channel_id)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("revisionNumber", ::alloc::string::ToString::to_string(&self.revision_number).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("revisionHeight", ::alloc::string::ToString::to_string(&self.revision_height).as_str())?;
         }
         struct_ser.end()
@@ -4358,7 +4380,7 @@ impl<'de> serde::Deserialize<'de> for QueryChannelConsensusStateRequest {
                 formatter.write_str("struct ibc.core.channel.v1.QueryChannelConsensusStateRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryChannelConsensusStateRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryChannelConsensusStateRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -4366,26 +4388,26 @@ impl<'de> serde::Deserialize<'de> for QueryChannelConsensusStateRequest {
                 let mut channel_id__ = None;
                 let mut revision_number__ = None;
                 let mut revision_height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::RevisionNumber => {
                             if revision_number__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("revisionNumber"));
                             }
                             revision_number__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::RevisionHeight => {
@@ -4393,7 +4415,7 @@ impl<'de> serde::Deserialize<'de> for QueryChannelConsensusStateRequest {
                                 return Err(serde::de::Error::duplicate_field("revisionHeight"));
                             }
                             revision_height__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -4437,6 +4459,7 @@ impl serde::Serialize for QueryChannelConsensusStateResponse {
             struct_ser.serialize_field("clientId", &self.client_id)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proof", pbjson::private::base64::encode(&self.proof).as_str())?;
         }
         if let Some(v) = self.proof_height.as_ref() {
@@ -4507,7 +4530,7 @@ impl<'de> serde::Deserialize<'de> for QueryChannelConsensusStateResponse {
                 formatter.write_str("struct ibc.core.channel.v1.QueryChannelConsensusStateResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryChannelConsensusStateResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryChannelConsensusStateResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -4515,33 +4538,33 @@ impl<'de> serde::Deserialize<'de> for QueryChannelConsensusStateResponse {
                 let mut client_id__ = None;
                 let mut proof__ = None;
                 let mut proof_height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ConsensusState => {
                             if consensus_state__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("consensusState"));
                             }
-                            consensus_state__ = map.next_value()?;
+                            consensus_state__ = map_.next_value()?;
                         }
                         GeneratedField::ClientId => {
                             if client_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientId"));
                             }
-                            client_id__ = Some(map.next_value()?);
+                            client_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Proof => {
                             if proof__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proof"));
                             }
                             proof__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ProofHeight => {
                             if proof_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofHeight"));
                             }
-                            proof_height__ = map.next_value()?;
+                            proof_height__ = map_.next_value()?;
                         }
                     }
                 }
@@ -4635,25 +4658,25 @@ impl<'de> serde::Deserialize<'de> for QueryChannelRequest {
                 formatter.write_str("struct ibc.core.channel.v1.QueryChannelRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryChannelRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryChannelRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut port_id__ = None;
                 let mut channel_id__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -4688,6 +4711,7 @@ impl serde::Serialize for QueryChannelResponse {
             struct_ser.serialize_field("channel", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proof", pbjson::private::base64::encode(&self.proof).as_str())?;
         }
         if let Some(v) = self.proof_height.as_ref() {
@@ -4753,34 +4777,34 @@ impl<'de> serde::Deserialize<'de> for QueryChannelResponse {
                 formatter.write_str("struct ibc.core.channel.v1.QueryChannelResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryChannelResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryChannelResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut channel__ = None;
                 let mut proof__ = None;
                 let mut proof_height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Channel => {
                             if channel__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channel"));
                             }
-                            channel__ = map.next_value()?;
+                            channel__ = map_.next_value()?;
                         }
                         GeneratedField::Proof => {
                             if proof__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proof"));
                             }
                             proof__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ProofHeight => {
                             if proof_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofHeight"));
                             }
-                            proof_height__ = map.next_value()?;
+                            proof_height__ = map_.next_value()?;
                         }
                     }
                 }
@@ -4862,18 +4886,18 @@ impl<'de> serde::Deserialize<'de> for QueryChannelsRequest {
                 formatter.write_str("struct ibc.core.channel.v1.QueryChannelsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryChannelsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryChannelsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -4971,32 +4995,32 @@ impl<'de> serde::Deserialize<'de> for QueryChannelsResponse {
                 formatter.write_str("struct ibc.core.channel.v1.QueryChannelsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryChannelsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryChannelsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut channels__ = None;
                 let mut pagination__ = None;
                 let mut height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Channels => {
                             if channels__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channels"));
                             }
-                            channels__ = Some(map.next_value()?);
+                            channels__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                         GeneratedField::Height => {
                             if height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("height"));
                             }
-                            height__ = map.next_value()?;
+                            height__ = map_.next_value()?;
                         }
                     }
                 }
@@ -5087,25 +5111,25 @@ impl<'de> serde::Deserialize<'de> for QueryConnectionChannelsRequest {
                 formatter.write_str("struct ibc.core.channel.v1.QueryConnectionChannelsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryConnectionChannelsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryConnectionChannelsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut connection__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Connection => {
                             if connection__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("connection"));
                             }
-                            connection__ = Some(map.next_value()?);
+                            connection__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -5204,32 +5228,32 @@ impl<'de> serde::Deserialize<'de> for QueryConnectionChannelsResponse {
                 formatter.write_str("struct ibc.core.channel.v1.QueryConnectionChannelsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryConnectionChannelsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryConnectionChannelsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut channels__ = None;
                 let mut pagination__ = None;
                 let mut height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Channels => {
                             if channels__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channels"));
                             }
-                            channels__ = Some(map.next_value()?);
+                            channels__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                         GeneratedField::Height => {
                             if height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("height"));
                             }
-                            height__ = map.next_value()?;
+                            height__ = map_.next_value()?;
                         }
                     }
                 }
@@ -5322,25 +5346,25 @@ impl<'de> serde::Deserialize<'de> for QueryNextSequenceReceiveRequest {
                 formatter.write_str("struct ibc.core.channel.v1.QueryNextSequenceReceiveRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryNextSequenceReceiveRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryNextSequenceReceiveRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut port_id__ = None;
                 let mut channel_id__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -5372,9 +5396,11 @@ impl serde::Serialize for QueryNextSequenceReceiveResponse {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryNextSequenceReceiveResponse", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("nextSequenceReceive", ::alloc::string::ToString::to_string(&self.next_sequence_receive).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proof", pbjson::private::base64::encode(&self.proof).as_str())?;
         }
         if let Some(v) = self.proof_height.as_ref() {
@@ -5441,21 +5467,21 @@ impl<'de> serde::Deserialize<'de> for QueryNextSequenceReceiveResponse {
                 formatter.write_str("struct ibc.core.channel.v1.QueryNextSequenceReceiveResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryNextSequenceReceiveResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryNextSequenceReceiveResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut next_sequence_receive__ = None;
                 let mut proof__ = None;
                 let mut proof_height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::NextSequenceReceive => {
                             if next_sequence_receive__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("nextSequenceReceive"));
                             }
                             next_sequence_receive__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Proof => {
@@ -5463,14 +5489,14 @@ impl<'de> serde::Deserialize<'de> for QueryNextSequenceReceiveResponse {
                                 return Err(serde::de::Error::duplicate_field("proof"));
                             }
                             proof__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ProofHeight => {
                             if proof_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofHeight"));
                             }
-                            proof_height__ = map.next_value()?;
+                            proof_height__ = map_.next_value()?;
                         }
                     }
                 }
@@ -5563,25 +5589,25 @@ impl<'de> serde::Deserialize<'de> for QueryNextSequenceSendRequest {
                 formatter.write_str("struct ibc.core.channel.v1.QueryNextSequenceSendRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryNextSequenceSendRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryNextSequenceSendRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut port_id__ = None;
                 let mut channel_id__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -5613,9 +5639,11 @@ impl serde::Serialize for QueryNextSequenceSendResponse {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryNextSequenceSendResponse", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("nextSequenceSend", ::alloc::string::ToString::to_string(&self.next_sequence_send).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proof", pbjson::private::base64::encode(&self.proof).as_str())?;
         }
         if let Some(v) = self.proof_height.as_ref() {
@@ -5682,21 +5710,21 @@ impl<'de> serde::Deserialize<'de> for QueryNextSequenceSendResponse {
                 formatter.write_str("struct ibc.core.channel.v1.QueryNextSequenceSendResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryNextSequenceSendResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryNextSequenceSendResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut next_sequence_send__ = None;
                 let mut proof__ = None;
                 let mut proof_height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::NextSequenceSend => {
                             if next_sequence_send__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("nextSequenceSend"));
                             }
                             next_sequence_send__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Proof => {
@@ -5704,14 +5732,14 @@ impl<'de> serde::Deserialize<'de> for QueryNextSequenceSendResponse {
                                 return Err(serde::de::Error::duplicate_field("proof"));
                             }
                             proof__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ProofHeight => {
                             if proof_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofHeight"));
                             }
-                            proof_height__ = map.next_value()?;
+                            proof_height__ = map_.next_value()?;
                         }
                     }
                 }
@@ -5750,6 +5778,7 @@ impl serde::Serialize for QueryPacketAcknowledgementRequest {
             struct_ser.serialize_field("channelId", &self.channel_id)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?;
         }
         struct_ser.end()
@@ -5813,33 +5842,33 @@ impl<'de> serde::Deserialize<'de> for QueryPacketAcknowledgementRequest {
                 formatter.write_str("struct ibc.core.channel.v1.QueryPacketAcknowledgementRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryPacketAcknowledgementRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryPacketAcknowledgementRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut port_id__ = None;
                 let mut channel_id__ = None;
                 let mut sequence__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Sequence => {
                             if sequence__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sequence"));
                             }
                             sequence__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -5873,9 +5902,11 @@ impl serde::Serialize for QueryPacketAcknowledgementResponse {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryPacketAcknowledgementResponse", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("acknowledgement", pbjson::private::base64::encode(&self.acknowledgement).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proof", pbjson::private::base64::encode(&self.proof).as_str())?;
         }
         if let Some(v) = self.proof_height.as_ref() {
@@ -5941,21 +5972,21 @@ impl<'de> serde::Deserialize<'de> for QueryPacketAcknowledgementResponse {
                 formatter.write_str("struct ibc.core.channel.v1.QueryPacketAcknowledgementResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryPacketAcknowledgementResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryPacketAcknowledgementResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut acknowledgement__ = None;
                 let mut proof__ = None;
                 let mut proof_height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Acknowledgement => {
                             if acknowledgement__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("acknowledgement"));
                             }
                             acknowledgement__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Proof => {
@@ -5963,14 +5994,14 @@ impl<'de> serde::Deserialize<'de> for QueryPacketAcknowledgementResponse {
                                 return Err(serde::de::Error::duplicate_field("proof"));
                             }
                             proof__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ProofHeight => {
                             if proof_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofHeight"));
                             }
-                            proof_height__ = map.next_value()?;
+                            proof_height__ = map_.next_value()?;
                         }
                     }
                 }
@@ -6082,7 +6113,7 @@ impl<'de> serde::Deserialize<'de> for QueryPacketAcknowledgementsRequest {
                 formatter.write_str("struct ibc.core.channel.v1.QueryPacketAcknowledgementsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryPacketAcknowledgementsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryPacketAcknowledgementsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -6090,32 +6121,32 @@ impl<'de> serde::Deserialize<'de> for QueryPacketAcknowledgementsRequest {
                 let mut channel_id__ = None;
                 let mut pagination__ = None;
                 let mut packet_commitment_sequences__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                         GeneratedField::PacketCommitmentSequences => {
                             if packet_commitment_sequences__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("packetCommitmentSequences"));
                             }
                             packet_commitment_sequences__ = 
-                                Some(map.next_value::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()?
+                                Some(map_.next_value::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()?
                                     .into_iter().map(|x| x.0).collect())
                             ;
                         }
@@ -6218,32 +6249,32 @@ impl<'de> serde::Deserialize<'de> for QueryPacketAcknowledgementsResponse {
                 formatter.write_str("struct ibc.core.channel.v1.QueryPacketAcknowledgementsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryPacketAcknowledgementsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryPacketAcknowledgementsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut acknowledgements__ = None;
                 let mut pagination__ = None;
                 let mut height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Acknowledgements => {
                             if acknowledgements__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("acknowledgements"));
                             }
-                            acknowledgements__ = Some(map.next_value()?);
+                            acknowledgements__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                         GeneratedField::Height => {
                             if height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("height"));
                             }
-                            height__ = map.next_value()?;
+                            height__ = map_.next_value()?;
                         }
                     }
                 }
@@ -6282,6 +6313,7 @@ impl serde::Serialize for QueryPacketCommitmentRequest {
             struct_ser.serialize_field("channelId", &self.channel_id)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?;
         }
         struct_ser.end()
@@ -6345,33 +6377,33 @@ impl<'de> serde::Deserialize<'de> for QueryPacketCommitmentRequest {
                 formatter.write_str("struct ibc.core.channel.v1.QueryPacketCommitmentRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryPacketCommitmentRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryPacketCommitmentRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut port_id__ = None;
                 let mut channel_id__ = None;
                 let mut sequence__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Sequence => {
                             if sequence__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sequence"));
                             }
                             sequence__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -6405,9 +6437,11 @@ impl serde::Serialize for QueryPacketCommitmentResponse {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.core.channel.v1.QueryPacketCommitmentResponse", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("commitment", pbjson::private::base64::encode(&self.commitment).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proof", pbjson::private::base64::encode(&self.proof).as_str())?;
         }
         if let Some(v) = self.proof_height.as_ref() {
@@ -6473,21 +6507,21 @@ impl<'de> serde::Deserialize<'de> for QueryPacketCommitmentResponse {
                 formatter.write_str("struct ibc.core.channel.v1.QueryPacketCommitmentResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryPacketCommitmentResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryPacketCommitmentResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut commitment__ = None;
                 let mut proof__ = None;
                 let mut proof_height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Commitment => {
                             if commitment__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("commitment"));
                             }
                             commitment__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Proof => {
@@ -6495,14 +6529,14 @@ impl<'de> serde::Deserialize<'de> for QueryPacketCommitmentResponse {
                                 return Err(serde::de::Error::duplicate_field("proof"));
                             }
                             proof__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ProofHeight => {
                             if proof_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofHeight"));
                             }
-                            proof_height__ = map.next_value()?;
+                            proof_height__ = map_.next_value()?;
                         }
                     }
                 }
@@ -6604,32 +6638,32 @@ impl<'de> serde::Deserialize<'de> for QueryPacketCommitmentsRequest {
                 formatter.write_str("struct ibc.core.channel.v1.QueryPacketCommitmentsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryPacketCommitmentsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryPacketCommitmentsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut port_id__ = None;
                 let mut channel_id__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -6729,32 +6763,32 @@ impl<'de> serde::Deserialize<'de> for QueryPacketCommitmentsResponse {
                 formatter.write_str("struct ibc.core.channel.v1.QueryPacketCommitmentsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryPacketCommitmentsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryPacketCommitmentsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut commitments__ = None;
                 let mut pagination__ = None;
                 let mut height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Commitments => {
                             if commitments__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("commitments"));
                             }
-                            commitments__ = Some(map.next_value()?);
+                            commitments__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                         GeneratedField::Height => {
                             if height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("height"));
                             }
-                            height__ = map.next_value()?;
+                            height__ = map_.next_value()?;
                         }
                     }
                 }
@@ -6793,6 +6827,7 @@ impl serde::Serialize for QueryPacketReceiptRequest {
             struct_ser.serialize_field("channelId", &self.channel_id)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?;
         }
         struct_ser.end()
@@ -6856,33 +6891,33 @@ impl<'de> serde::Deserialize<'de> for QueryPacketReceiptRequest {
                 formatter.write_str("struct ibc.core.channel.v1.QueryPacketReceiptRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryPacketReceiptRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryPacketReceiptRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut port_id__ = None;
                 let mut channel_id__ = None;
                 let mut sequence__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Sequence => {
                             if sequence__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sequence"));
                             }
                             sequence__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -6919,6 +6954,7 @@ impl serde::Serialize for QueryPacketReceiptResponse {
             struct_ser.serialize_field("received", &self.received)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proof", pbjson::private::base64::encode(&self.proof).as_str())?;
         }
         if let Some(v) = self.proof_height.as_ref() {
@@ -6984,34 +7020,34 @@ impl<'de> serde::Deserialize<'de> for QueryPacketReceiptResponse {
                 formatter.write_str("struct ibc.core.channel.v1.QueryPacketReceiptResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryPacketReceiptResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryPacketReceiptResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut received__ = None;
                 let mut proof__ = None;
                 let mut proof_height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Received => {
                             if received__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("received"));
                             }
-                            received__ = Some(map.next_value()?);
+                            received__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Proof => {
                             if proof__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proof"));
                             }
                             proof__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ProofHeight => {
                             if proof_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofHeight"));
                             }
-                            proof_height__ = map.next_value()?;
+                            proof_height__ = map_.next_value()?;
                         }
                     }
                 }
@@ -7114,33 +7150,33 @@ impl<'de> serde::Deserialize<'de> for QueryUnreceivedAcksRequest {
                 formatter.write_str("struct ibc.core.channel.v1.QueryUnreceivedAcksRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryUnreceivedAcksRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryUnreceivedAcksRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut port_id__ = None;
                 let mut channel_id__ = None;
                 let mut packet_ack_sequences__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::PacketAckSequences => {
                             if packet_ack_sequences__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("packetAckSequences"));
                             }
                             packet_ack_sequences__ = 
-                                Some(map.next_value::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()?
+                                Some(map_.next_value::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()?
                                     .into_iter().map(|x| x.0).collect())
                             ;
                         }
@@ -7233,20 +7269,20 @@ impl<'de> serde::Deserialize<'de> for QueryUnreceivedAcksResponse {
                 formatter.write_str("struct ibc.core.channel.v1.QueryUnreceivedAcksResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryUnreceivedAcksResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryUnreceivedAcksResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut sequences__ = None;
                 let mut height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Sequences => {
                             if sequences__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sequences"));
                             }
                             sequences__ = 
-                                Some(map.next_value::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()?
+                                Some(map_.next_value::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()?
                                     .into_iter().map(|x| x.0).collect())
                             ;
                         }
@@ -7254,7 +7290,7 @@ impl<'de> serde::Deserialize<'de> for QueryUnreceivedAcksResponse {
                             if height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("height"));
                             }
-                            height__ = map.next_value()?;
+                            height__ = map_.next_value()?;
                         }
                     }
                 }
@@ -7356,33 +7392,33 @@ impl<'de> serde::Deserialize<'de> for QueryUnreceivedPacketsRequest {
                 formatter.write_str("struct ibc.core.channel.v1.QueryUnreceivedPacketsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryUnreceivedPacketsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryUnreceivedPacketsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut port_id__ = None;
                 let mut channel_id__ = None;
                 let mut packet_commitment_sequences__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PortId => {
                             if port_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("portId"));
                             }
-                            port_id__ = Some(map.next_value()?);
+                            port_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ChannelId => {
                             if channel_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelId"));
                             }
-                            channel_id__ = Some(map.next_value()?);
+                            channel_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::PacketCommitmentSequences => {
                             if packet_commitment_sequences__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("packetCommitmentSequences"));
                             }
                             packet_commitment_sequences__ = 
-                                Some(map.next_value::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()?
+                                Some(map_.next_value::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()?
                                     .into_iter().map(|x| x.0).collect())
                             ;
                         }
@@ -7475,20 +7511,20 @@ impl<'de> serde::Deserialize<'de> for QueryUnreceivedPacketsResponse {
                 formatter.write_str("struct ibc.core.channel.v1.QueryUnreceivedPacketsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryUnreceivedPacketsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryUnreceivedPacketsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut sequences__ = None;
                 let mut height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Sequences => {
                             if sequences__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sequences"));
                             }
                             sequences__ = 
-                                Some(map.next_value::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()?
+                                Some(map_.next_value::<::alloc::vec::Vec<::pbjson::private::NumberDeserialize<_>>>()?
                                     .into_iter().map(|x| x.0).collect())
                             ;
                         }
@@ -7496,7 +7532,7 @@ impl<'de> serde::Deserialize<'de> for QueryUnreceivedPacketsResponse {
                             if height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("height"));
                             }
-                            height__ = map.next_value()?;
+                            height__ = map_.next_value()?;
                         }
                     }
                 }
@@ -7548,10 +7584,9 @@ impl<'de> serde::Deserialize<'de> for ResponseResultType {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(ResponseResultType::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -7561,10 +7596,9 @@ impl<'de> serde::Deserialize<'de> for ResponseResultType {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(ResponseResultType::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
@@ -7628,10 +7662,9 @@ impl<'de> serde::Deserialize<'de> for State {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(State::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -7641,10 +7674,9 @@ impl<'de> serde::Deserialize<'de> for State {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(State::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
@@ -7686,6 +7718,7 @@ impl serde::Serialize for Timeout {
             struct_ser.serialize_field("height", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("timestamp", ::alloc::string::ToString::to_string(&self.timestamp).as_str())?;
         }
         struct_ser.end()
@@ -7744,26 +7777,26 @@ impl<'de> serde::Deserialize<'de> for Timeout {
                 formatter.write_str("struct ibc.core.channel.v1.Timeout")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Timeout, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Timeout, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut height__ = None;
                 let mut timestamp__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Height => {
                             if height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("height"));
                             }
-                            height__ = map.next_value()?;
+                            height__ = map_.next_value()?;
                         }
                         GeneratedField::Timestamp => {
                             if timestamp__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("timestamp"));
                             }
                             timestamp__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
diff --git a/src/prost/ibc.core.client.v1.serde.rs b/src/prost/ibc.core.client.v1.serde.rs
index 2de34110..f3491f56 100644
--- a/src/prost/ibc.core.client.v1.serde.rs
+++ b/src/prost/ibc.core.client.v1.serde.rs
@@ -77,25 +77,25 @@ impl<'de> serde::Deserialize<'de> for ClientConsensusStates {
                 formatter.write_str("struct ibc.core.client.v1.ClientConsensusStates")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ClientConsensusStates, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ClientConsensusStates, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut client_id__ = None;
                 let mut consensus_states__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ClientId => {
                             if client_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientId"));
                             }
-                            client_id__ = Some(map.next_value()?);
+                            client_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ConsensusStates => {
                             if consensus_states__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("consensusStates"));
                             }
-                            consensus_states__ = Some(map.next_value()?);
+                            consensus_states__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -205,7 +205,7 @@ impl<'de> serde::Deserialize<'de> for ClientUpdateProposal {
                 formatter.write_str("struct ibc.core.client.v1.ClientUpdateProposal")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ClientUpdateProposal, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ClientUpdateProposal, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -213,31 +213,31 @@ impl<'de> serde::Deserialize<'de> for ClientUpdateProposal {
                 let mut description__ = None;
                 let mut subject_client_id__ = None;
                 let mut substitute_client_id__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Title => {
                             if title__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("title"));
                             }
-                            title__ = Some(map.next_value()?);
+                            title__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Description => {
                             if description__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("description"));
                             }
-                            description__ = Some(map.next_value()?);
+                            description__ = Some(map_.next_value()?);
                         }
                         GeneratedField::SubjectClientId => {
                             if subject_client_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("subjectClientId"));
                             }
-                            subject_client_id__ = Some(map.next_value()?);
+                            subject_client_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::SubstituteClientId => {
                             if substitute_client_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("substituteClientId"));
                             }
-                            substitute_client_id__ = Some(map.next_value()?);
+                            substitute_client_id__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -330,25 +330,25 @@ impl<'de> serde::Deserialize<'de> for ConsensusStateWithHeight {
                 formatter.write_str("struct ibc.core.client.v1.ConsensusStateWithHeight")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ConsensusStateWithHeight, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ConsensusStateWithHeight, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut height__ = None;
                 let mut consensus_state__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Height => {
                             if height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("height"));
                             }
-                            height__ = map.next_value()?;
+                            height__ = map_.next_value()?;
                         }
                         GeneratedField::ConsensusState => {
                             if consensus_state__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("consensusState"));
                             }
-                            consensus_state__ = map.next_value()?;
+                            consensus_state__ = map_.next_value()?;
                         }
                     }
                 }
@@ -377,9 +377,11 @@ impl serde::Serialize for GenesisMetadata {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.core.client.v1.GenesisMetadata", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("key", pbjson::private::base64::encode(&self.key).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("value", pbjson::private::base64::encode(&self.value).as_str())?;
         }
         struct_ser.end()
@@ -438,20 +440,20 @@ impl<'de> serde::Deserialize<'de> for GenesisMetadata {
                 formatter.write_str("struct ibc.core.client.v1.GenesisMetadata")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<GenesisMetadata, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<GenesisMetadata, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut key__ = None;
                 let mut value__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Key => {
                             if key__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("key"));
                             }
                             key__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Value => {
@@ -459,7 +461,7 @@ impl<'de> serde::Deserialize<'de> for GenesisMetadata {
                                 return Err(serde::de::Error::duplicate_field("value"));
                             }
                             value__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -516,6 +518,7 @@ impl serde::Serialize for GenesisState {
             struct_ser.serialize_field("createLocalhost", &self.create_localhost)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("nextClientSequence", ::alloc::string::ToString::to_string(&self.next_client_sequence).as_str())?;
         }
         struct_ser.end()
@@ -590,7 +593,7 @@ impl<'de> serde::Deserialize<'de> for GenesisState {
                 formatter.write_str("struct ibc.core.client.v1.GenesisState")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<GenesisState, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<GenesisState, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -600,44 +603,44 @@ impl<'de> serde::Deserialize<'de> for GenesisState {
                 let mut params__ = None;
                 let mut create_localhost__ = None;
                 let mut next_client_sequence__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Clients => {
                             if clients__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clients"));
                             }
-                            clients__ = Some(map.next_value()?);
+                            clients__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ClientsConsensus => {
                             if clients_consensus__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientsConsensus"));
                             }
-                            clients_consensus__ = Some(map.next_value()?);
+                            clients_consensus__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ClientsMetadata => {
                             if clients_metadata__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientsMetadata"));
                             }
-                            clients_metadata__ = Some(map.next_value()?);
+                            clients_metadata__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Params => {
                             if params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("params"));
                             }
-                            params__ = map.next_value()?;
+                            params__ = map_.next_value()?;
                         }
                         GeneratedField::CreateLocalhost => {
                             if create_localhost__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("createLocalhost"));
                             }
-                            create_localhost__ = Some(map.next_value()?);
+                            create_localhost__ = Some(map_.next_value()?);
                         }
                         GeneratedField::NextClientSequence => {
                             if next_client_sequence__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("nextClientSequence"));
                             }
                             next_client_sequence__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -671,9 +674,11 @@ impl serde::Serialize for Height {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.core.client.v1.Height", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("revisionNumber", ::alloc::string::ToString::to_string(&self.revision_number).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("revisionHeight", ::alloc::string::ToString::to_string(&self.revision_height).as_str())?;
         }
         struct_ser.end()
@@ -734,20 +739,20 @@ impl<'de> serde::Deserialize<'de> for Height {
                 formatter.write_str("struct ibc.core.client.v1.Height")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Height, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Height, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut revision_number__ = None;
                 let mut revision_height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::RevisionNumber => {
                             if revision_number__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("revisionNumber"));
                             }
                             revision_number__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::RevisionHeight => {
@@ -755,7 +760,7 @@ impl<'de> serde::Deserialize<'de> for Height {
                                 return Err(serde::de::Error::duplicate_field("revisionHeight"));
                             }
                             revision_height__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -848,25 +853,25 @@ impl<'de> serde::Deserialize<'de> for IdentifiedClientState {
                 formatter.write_str("struct ibc.core.client.v1.IdentifiedClientState")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<IdentifiedClientState, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<IdentifiedClientState, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut client_id__ = None;
                 let mut client_state__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ClientId => {
                             if client_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientId"));
                             }
-                            client_id__ = Some(map.next_value()?);
+                            client_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ClientState => {
                             if client_state__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientState"));
                             }
-                            client_state__ = map.next_value()?;
+                            client_state__ = map_.next_value()?;
                         }
                     }
                 }
@@ -958,25 +963,25 @@ impl<'de> serde::Deserialize<'de> for IdentifiedGenesisMetadata {
                 formatter.write_str("struct ibc.core.client.v1.IdentifiedGenesisMetadata")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<IdentifiedGenesisMetadata, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<IdentifiedGenesisMetadata, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut client_id__ = None;
                 let mut client_metadata__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ClientId => {
                             if client_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientId"));
                             }
-                            client_id__ = Some(map.next_value()?);
+                            client_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ClientMetadata => {
                             if client_metadata__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientMetadata"));
                             }
-                            client_metadata__ = Some(map.next_value()?);
+                            client_metadata__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1077,32 +1082,32 @@ impl<'de> serde::Deserialize<'de> for MsgCreateClient {
                 formatter.write_str("struct ibc.core.client.v1.MsgCreateClient")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgCreateClient, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgCreateClient, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut client_state__ = None;
                 let mut consensus_state__ = None;
                 let mut signer__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ClientState => {
                             if client_state__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientState"));
                             }
-                            client_state__ = map.next_value()?;
+                            client_state__ = map_.next_value()?;
                         }
                         GeneratedField::ConsensusState => {
                             if consensus_state__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("consensusState"));
                             }
-                            consensus_state__ = map.next_value()?;
+                            consensus_state__ = map_.next_value()?;
                         }
                         GeneratedField::Signer => {
                             if signer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signer"));
                             }
-                            signer__ = Some(map.next_value()?);
+                            signer__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1173,12 +1178,12 @@ impl<'de> serde::Deserialize<'de> for MsgCreateClientResponse {
                 formatter.write_str("struct ibc.core.client.v1.MsgCreateClientResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgCreateClientResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgCreateClientResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgCreateClientResponse {
                 })
@@ -1274,32 +1279,32 @@ impl<'de> serde::Deserialize<'de> for MsgIbcSoftwareUpgrade {
                 formatter.write_str("struct ibc.core.client.v1.MsgIBCSoftwareUpgrade")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgIbcSoftwareUpgrade, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgIbcSoftwareUpgrade, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut plan__ = None;
                 let mut upgraded_client_state__ = None;
                 let mut signer__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Plan => {
                             if plan__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("plan"));
                             }
-                            plan__ = map.next_value()?;
+                            plan__ = map_.next_value()?;
                         }
                         GeneratedField::UpgradedClientState => {
                             if upgraded_client_state__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("upgradedClientState"));
                             }
-                            upgraded_client_state__ = map.next_value()?;
+                            upgraded_client_state__ = map_.next_value()?;
                         }
                         GeneratedField::Signer => {
                             if signer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signer"));
                             }
-                            signer__ = Some(map.next_value()?);
+                            signer__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1370,12 +1375,12 @@ impl<'de> serde::Deserialize<'de> for MsgIbcSoftwareUpgradeResponse {
                 formatter.write_str("struct ibc.core.client.v1.MsgIBCSoftwareUpgradeResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgIbcSoftwareUpgradeResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgIbcSoftwareUpgradeResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgIbcSoftwareUpgradeResponse {
                 })
@@ -1472,32 +1477,32 @@ impl<'de> serde::Deserialize<'de> for MsgRecoverClient {
                 formatter.write_str("struct ibc.core.client.v1.MsgRecoverClient")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgRecoverClient, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgRecoverClient, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut subject_client_id__ = None;
                 let mut substitute_client_id__ = None;
                 let mut signer__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::SubjectClientId => {
                             if subject_client_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("subjectClientId"));
                             }
-                            subject_client_id__ = Some(map.next_value()?);
+                            subject_client_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::SubstituteClientId => {
                             if substitute_client_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("substituteClientId"));
                             }
-                            substitute_client_id__ = Some(map.next_value()?);
+                            substitute_client_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Signer => {
                             if signer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signer"));
                             }
-                            signer__ = Some(map.next_value()?);
+                            signer__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1568,12 +1573,12 @@ impl<'de> serde::Deserialize<'de> for MsgRecoverClientResponse {
                 formatter.write_str("struct ibc.core.client.v1.MsgRecoverClientResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgRecoverClientResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgRecoverClientResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgRecoverClientResponse {
                 })
@@ -1669,32 +1674,32 @@ impl<'de> serde::Deserialize<'de> for MsgSubmitMisbehaviour {
                 formatter.write_str("struct ibc.core.client.v1.MsgSubmitMisbehaviour")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgSubmitMisbehaviour, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgSubmitMisbehaviour, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut client_id__ = None;
                 let mut misbehaviour__ = None;
                 let mut signer__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ClientId => {
                             if client_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientId"));
                             }
-                            client_id__ = Some(map.next_value()?);
+                            client_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Misbehaviour => {
                             if misbehaviour__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("misbehaviour"));
                             }
-                            misbehaviour__ = map.next_value()?;
+                            misbehaviour__ = map_.next_value()?;
                         }
                         GeneratedField::Signer => {
                             if signer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signer"));
                             }
-                            signer__ = Some(map.next_value()?);
+                            signer__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1765,12 +1770,12 @@ impl<'de> serde::Deserialize<'de> for MsgSubmitMisbehaviourResponse {
                 formatter.write_str("struct ibc.core.client.v1.MsgSubmitMisbehaviourResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgSubmitMisbehaviourResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgSubmitMisbehaviourResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgSubmitMisbehaviourResponse {
                 })
@@ -1867,32 +1872,32 @@ impl<'de> serde::Deserialize<'de> for MsgUpdateClient {
                 formatter.write_str("struct ibc.core.client.v1.MsgUpdateClient")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgUpdateClient, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgUpdateClient, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut client_id__ = None;
                 let mut client_message__ = None;
                 let mut signer__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ClientId => {
                             if client_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientId"));
                             }
-                            client_id__ = Some(map.next_value()?);
+                            client_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ClientMessage => {
                             if client_message__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientMessage"));
                             }
-                            client_message__ = map.next_value()?;
+                            client_message__ = map_.next_value()?;
                         }
                         GeneratedField::Signer => {
                             if signer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signer"));
                             }
-                            signer__ = Some(map.next_value()?);
+                            signer__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1963,12 +1968,12 @@ impl<'de> serde::Deserialize<'de> for MsgUpdateClientResponse {
                 formatter.write_str("struct ibc.core.client.v1.MsgUpdateClientResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgUpdateClientResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgUpdateClientResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgUpdateClientResponse {
                 })
@@ -2054,25 +2059,25 @@ impl<'de> serde::Deserialize<'de> for MsgUpdateParams {
                 formatter.write_str("struct ibc.core.client.v1.MsgUpdateParams")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgUpdateParams, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgUpdateParams, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut signer__ = None;
                 let mut params__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Signer => {
                             if signer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signer"));
                             }
-                            signer__ = Some(map.next_value()?);
+                            signer__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Params => {
                             if params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("params"));
                             }
-                            params__ = map.next_value()?;
+                            params__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2142,12 +2147,12 @@ impl<'de> serde::Deserialize<'de> for MsgUpdateParamsResponse {
                 formatter.write_str("struct ibc.core.client.v1.MsgUpdateParamsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgUpdateParamsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgUpdateParamsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgUpdateParamsResponse {
                 })
@@ -2193,9 +2198,11 @@ impl serde::Serialize for MsgUpgradeClient {
             struct_ser.serialize_field("consensusState", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proofUpgradeClient", pbjson::private::base64::encode(&self.proof_upgrade_client).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proofUpgradeConsensusState", pbjson::private::base64::encode(&self.proof_upgrade_consensus_state).as_str())?;
         }
         if true {
@@ -2274,7 +2281,7 @@ impl<'de> serde::Deserialize<'de> for MsgUpgradeClient {
                 formatter.write_str("struct ibc.core.client.v1.MsgUpgradeClient")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgUpgradeClient, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgUpgradeClient, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -2284,32 +2291,32 @@ impl<'de> serde::Deserialize<'de> for MsgUpgradeClient {
                 let mut proof_upgrade_client__ = None;
                 let mut proof_upgrade_consensus_state__ = None;
                 let mut signer__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ClientId => {
                             if client_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientId"));
                             }
-                            client_id__ = Some(map.next_value()?);
+                            client_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ClientState => {
                             if client_state__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientState"));
                             }
-                            client_state__ = map.next_value()?;
+                            client_state__ = map_.next_value()?;
                         }
                         GeneratedField::ConsensusState => {
                             if consensus_state__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("consensusState"));
                             }
-                            consensus_state__ = map.next_value()?;
+                            consensus_state__ = map_.next_value()?;
                         }
                         GeneratedField::ProofUpgradeClient => {
                             if proof_upgrade_client__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofUpgradeClient"));
                             }
                             proof_upgrade_client__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ProofUpgradeConsensusState => {
@@ -2317,14 +2324,14 @@ impl<'de> serde::Deserialize<'de> for MsgUpgradeClient {
                                 return Err(serde::de::Error::duplicate_field("proofUpgradeConsensusState"));
                             }
                             proof_upgrade_consensus_state__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Signer => {
                             if signer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signer"));
                             }
-                            signer__ = Some(map.next_value()?);
+                            signer__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -2398,12 +2405,12 @@ impl<'de> serde::Deserialize<'de> for MsgUpgradeClientResponse {
                 formatter.write_str("struct ibc.core.client.v1.MsgUpgradeClientResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgUpgradeClientResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgUpgradeClientResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgUpgradeClientResponse {
                 })
@@ -2481,18 +2488,18 @@ impl<'de> serde::Deserialize<'de> for Params {
                 formatter.write_str("struct ibc.core.client.v1.Params")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Params, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Params, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut allowed_clients__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::AllowedClients => {
                             if allowed_clients__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("allowedClients"));
                             }
-                            allowed_clients__ = Some(map.next_value()?);
+                            allowed_clients__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -2561,12 +2568,12 @@ impl<'de> serde::Deserialize<'de> for QueryClientParamsRequest {
                 formatter.write_str("struct ibc.core.client.v1.QueryClientParamsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryClientParamsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryClientParamsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(QueryClientParamsRequest {
                 })
@@ -2643,18 +2650,18 @@ impl<'de> serde::Deserialize<'de> for QueryClientParamsResponse {
                 formatter.write_str("struct ibc.core.client.v1.QueryClientParamsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryClientParamsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryClientParamsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut params__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Params => {
                             if params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("params"));
                             }
-                            params__ = map.next_value()?;
+                            params__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2735,18 +2742,18 @@ impl<'de> serde::Deserialize<'de> for QueryClientStateRequest {
                 formatter.write_str("struct ibc.core.client.v1.QueryClientStateRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryClientStateRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryClientStateRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut client_id__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ClientId => {
                             if client_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientId"));
                             }
-                            client_id__ = Some(map.next_value()?);
+                            client_id__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -2780,6 +2787,7 @@ impl serde::Serialize for QueryClientStateResponse {
             struct_ser.serialize_field("clientState", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proof", pbjson::private::base64::encode(&self.proof).as_str())?;
         }
         if let Some(v) = self.proof_height.as_ref() {
@@ -2846,34 +2854,34 @@ impl<'de> serde::Deserialize<'de> for QueryClientStateResponse {
                 formatter.write_str("struct ibc.core.client.v1.QueryClientStateResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryClientStateResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryClientStateResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut client_state__ = None;
                 let mut proof__ = None;
                 let mut proof_height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ClientState => {
                             if client_state__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientState"));
                             }
-                            client_state__ = map.next_value()?;
+                            client_state__ = map_.next_value()?;
                         }
                         GeneratedField::Proof => {
                             if proof__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proof"));
                             }
                             proof__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ProofHeight => {
                             if proof_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofHeight"));
                             }
-                            proof_height__ = map.next_value()?;
+                            proof_height__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2955,18 +2963,18 @@ impl<'de> serde::Deserialize<'de> for QueryClientStatesRequest {
                 formatter.write_str("struct ibc.core.client.v1.QueryClientStatesRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryClientStatesRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryClientStatesRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3056,25 +3064,25 @@ impl<'de> serde::Deserialize<'de> for QueryClientStatesResponse {
                 formatter.write_str("struct ibc.core.client.v1.QueryClientStatesResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryClientStatesResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryClientStatesResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut client_states__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ClientStates => {
                             if client_states__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientStates"));
                             }
-                            client_states__ = Some(map.next_value()?);
+                            client_states__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3156,18 +3164,18 @@ impl<'de> serde::Deserialize<'de> for QueryClientStatusRequest {
                 formatter.write_str("struct ibc.core.client.v1.QueryClientStatusRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryClientStatusRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryClientStatusRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut client_id__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ClientId => {
                             if client_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientId"));
                             }
-                            client_id__ = Some(map.next_value()?);
+                            client_id__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -3247,18 +3255,18 @@ impl<'de> serde::Deserialize<'de> for QueryClientStatusResponse {
                 formatter.write_str("struct ibc.core.client.v1.QueryClientStatusResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryClientStatusResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryClientStatusResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut status__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Status => {
                             if status__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("status"));
                             }
-                            status__ = Some(map.next_value()?);
+                            status__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -3348,25 +3356,25 @@ impl<'de> serde::Deserialize<'de> for QueryConsensusStateHeightsRequest {
                 formatter.write_str("struct ibc.core.client.v1.QueryConsensusStateHeightsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryConsensusStateHeightsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryConsensusStateHeightsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut client_id__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ClientId => {
                             if client_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientId"));
                             }
-                            client_id__ = Some(map.next_value()?);
+                            client_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3457,25 +3465,25 @@ impl<'de> serde::Deserialize<'de> for QueryConsensusStateHeightsResponse {
                 formatter.write_str("struct ibc.core.client.v1.QueryConsensusStateHeightsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryConsensusStateHeightsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryConsensusStateHeightsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut consensus_state_heights__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ConsensusStateHeights => {
                             if consensus_state_heights__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("consensusStateHeights"));
                             }
-                            consensus_state_heights__ = Some(map.next_value()?);
+                            consensus_state_heights__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3513,9 +3521,11 @@ impl serde::Serialize for QueryConsensusStateRequest {
             struct_ser.serialize_field("clientId", &self.client_id)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("revisionNumber", ::alloc::string::ToString::to_string(&self.revision_number).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("revisionHeight", ::alloc::string::ToString::to_string(&self.revision_height).as_str())?;
         }
         if true {
@@ -3587,7 +3597,7 @@ impl<'de> serde::Deserialize<'de> for QueryConsensusStateRequest {
                 formatter.write_str("struct ibc.core.client.v1.QueryConsensusStateRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryConsensusStateRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryConsensusStateRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -3595,20 +3605,20 @@ impl<'de> serde::Deserialize<'de> for QueryConsensusStateRequest {
                 let mut revision_number__ = None;
                 let mut revision_height__ = None;
                 let mut latest_height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ClientId => {
                             if client_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientId"));
                             }
-                            client_id__ = Some(map.next_value()?);
+                            client_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::RevisionNumber => {
                             if revision_number__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("revisionNumber"));
                             }
                             revision_number__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::RevisionHeight => {
@@ -3616,14 +3626,14 @@ impl<'de> serde::Deserialize<'de> for QueryConsensusStateRequest {
                                 return Err(serde::de::Error::duplicate_field("revisionHeight"));
                             }
                             revision_height__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::LatestHeight => {
                             if latest_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("latestHeight"));
                             }
-                            latest_height__ = Some(map.next_value()?);
+                            latest_height__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -3660,6 +3670,7 @@ impl serde::Serialize for QueryConsensusStateResponse {
             struct_ser.serialize_field("consensusState", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proof", pbjson::private::base64::encode(&self.proof).as_str())?;
         }
         if let Some(v) = self.proof_height.as_ref() {
@@ -3726,34 +3737,34 @@ impl<'de> serde::Deserialize<'de> for QueryConsensusStateResponse {
                 formatter.write_str("struct ibc.core.client.v1.QueryConsensusStateResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryConsensusStateResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryConsensusStateResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut consensus_state__ = None;
                 let mut proof__ = None;
                 let mut proof_height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ConsensusState => {
                             if consensus_state__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("consensusState"));
                             }
-                            consensus_state__ = map.next_value()?;
+                            consensus_state__ = map_.next_value()?;
                         }
                         GeneratedField::Proof => {
                             if proof__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proof"));
                             }
                             proof__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ProofHeight => {
                             if proof_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofHeight"));
                             }
-                            proof_height__ = map.next_value()?;
+                            proof_height__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3845,25 +3856,25 @@ impl<'de> serde::Deserialize<'de> for QueryConsensusStatesRequest {
                 formatter.write_str("struct ibc.core.client.v1.QueryConsensusStatesRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryConsensusStatesRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryConsensusStatesRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut client_id__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ClientId => {
                             if client_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientId"));
                             }
-                            client_id__ = Some(map.next_value()?);
+                            client_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3954,25 +3965,25 @@ impl<'de> serde::Deserialize<'de> for QueryConsensusStatesResponse {
                 formatter.write_str("struct ibc.core.client.v1.QueryConsensusStatesResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryConsensusStatesResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryConsensusStatesResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut consensus_states__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ConsensusStates => {
                             if consensus_states__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("consensusStates"));
                             }
-                            consensus_states__ = Some(map.next_value()?);
+                            consensus_states__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -4042,12 +4053,12 @@ impl<'de> serde::Deserialize<'de> for QueryUpgradedClientStateRequest {
                 formatter.write_str("struct ibc.core.client.v1.QueryUpgradedClientStateRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryUpgradedClientStateRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryUpgradedClientStateRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(QueryUpgradedClientStateRequest {
                 })
@@ -4125,18 +4136,18 @@ impl<'de> serde::Deserialize<'de> for QueryUpgradedClientStateResponse {
                 formatter.write_str("struct ibc.core.client.v1.QueryUpgradedClientStateResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryUpgradedClientStateResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryUpgradedClientStateResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut upgraded_client_state__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::UpgradedClientState => {
                             if upgraded_client_state__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("upgradedClientState"));
                             }
-                            upgraded_client_state__ = map.next_value()?;
+                            upgraded_client_state__ = map_.next_value()?;
                         }
                     }
                 }
@@ -4205,12 +4216,12 @@ impl<'de> serde::Deserialize<'de> for QueryUpgradedConsensusStateRequest {
                 formatter.write_str("struct ibc.core.client.v1.QueryUpgradedConsensusStateRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryUpgradedConsensusStateRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryUpgradedConsensusStateRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(QueryUpgradedConsensusStateRequest {
                 })
@@ -4288,18 +4299,18 @@ impl<'de> serde::Deserialize<'de> for QueryUpgradedConsensusStateResponse {
                 formatter.write_str("struct ibc.core.client.v1.QueryUpgradedConsensusStateResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryUpgradedConsensusStateResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryUpgradedConsensusStateResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut upgraded_consensus_state__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::UpgradedConsensusState => {
                             if upgraded_consensus_state__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("upgradedConsensusState"));
                             }
-                            upgraded_consensus_state__ = map.next_value()?;
+                            upgraded_consensus_state__ = map_.next_value()?;
                         }
                     }
                 }
@@ -4407,7 +4418,7 @@ impl<'de> serde::Deserialize<'de> for UpgradeProposal {
                 formatter.write_str("struct ibc.core.client.v1.UpgradeProposal")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<UpgradeProposal, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<UpgradeProposal, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -4415,31 +4426,31 @@ impl<'de> serde::Deserialize<'de> for UpgradeProposal {
                 let mut description__ = None;
                 let mut plan__ = None;
                 let mut upgraded_client_state__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Title => {
                             if title__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("title"));
                             }
-                            title__ = Some(map.next_value()?);
+                            title__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Description => {
                             if description__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("description"));
                             }
-                            description__ = Some(map.next_value()?);
+                            description__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Plan => {
                             if plan__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("plan"));
                             }
-                            plan__ = map.next_value()?;
+                            plan__ = map_.next_value()?;
                         }
                         GeneratedField::UpgradedClientState => {
                             if upgraded_client_state__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("upgradedClientState"));
                             }
-                            upgraded_client_state__ = map.next_value()?;
+                            upgraded_client_state__ = map_.next_value()?;
                         }
                     }
                 }
diff --git a/src/prost/ibc.core.commitment.v1.serde.rs b/src/prost/ibc.core.commitment.v1.serde.rs
index 845674d6..9173f7e8 100644
--- a/src/prost/ibc.core.commitment.v1.serde.rs
+++ b/src/prost/ibc.core.commitment.v1.serde.rs
@@ -67,18 +67,18 @@ impl<'de> serde::Deserialize<'de> for MerklePath {
                 formatter.write_str("struct ibc.core.commitment.v1.MerklePath")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MerklePath, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MerklePath, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut key_path__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::KeyPath => {
                             if key_path__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("keyPath"));
                             }
-                            key_path__ = Some(map.next_value()?);
+                            key_path__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -103,6 +103,7 @@ impl serde::Serialize for MerklePrefix {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.core.commitment.v1.MerklePrefix", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("keyPrefix", pbjson::private::base64::encode(&self.key_prefix).as_str())?;
         }
         struct_ser.end()
@@ -159,19 +160,19 @@ impl<'de> serde::Deserialize<'de> for MerklePrefix {
                 formatter.write_str("struct ibc.core.commitment.v1.MerklePrefix")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MerklePrefix, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MerklePrefix, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut key_prefix__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::KeyPrefix => {
                             if key_prefix__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("keyPrefix"));
                             }
                             key_prefix__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -252,18 +253,18 @@ impl<'de> serde::Deserialize<'de> for MerkleProof {
                 formatter.write_str("struct ibc.core.commitment.v1.MerkleProof")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MerkleProof, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MerkleProof, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut proofs__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Proofs => {
                             if proofs__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofs"));
                             }
-                            proofs__ = Some(map.next_value()?);
+                            proofs__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -288,6 +289,7 @@ impl serde::Serialize for MerkleRoot {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.core.commitment.v1.MerkleRoot", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("hash", pbjson::private::base64::encode(&self.hash).as_str())?;
         }
         struct_ser.end()
@@ -343,19 +345,19 @@ impl<'de> serde::Deserialize<'de> for MerkleRoot {
                 formatter.write_str("struct ibc.core.commitment.v1.MerkleRoot")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MerkleRoot, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MerkleRoot, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut hash__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Hash => {
                             if hash__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("hash"));
                             }
                             hash__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
diff --git a/src/prost/ibc.core.connection.v1.serde.rs b/src/prost/ibc.core.connection.v1.serde.rs
index 34a80641..8f45f9be 100644
--- a/src/prost/ibc.core.connection.v1.serde.rs
+++ b/src/prost/ibc.core.connection.v1.serde.rs
@@ -66,18 +66,18 @@ impl<'de> serde::Deserialize<'de> for ClientPaths {
                 formatter.write_str("struct ibc.core.connection.v1.ClientPaths")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ClientPaths, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ClientPaths, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut paths__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Paths => {
                             if paths__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("paths"));
                             }
-                            paths__ = Some(map.next_value()?);
+                            paths__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -120,14 +120,15 @@ impl serde::Serialize for ConnectionEnd {
             struct_ser.serialize_field("versions", &self.versions)?;
         }
         if true {
-            let v = State::from_i32(self.state)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.state)))?;
+            let v = State::try_from(self.state)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.state)))?;
             struct_ser.serialize_field("state", &v)?;
         }
         if let Some(v) = self.counterparty.as_ref() {
             struct_ser.serialize_field("counterparty", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("delayPeriod", ::alloc::string::ToString::to_string(&self.delay_period).as_str())?;
         }
         struct_ser.end()
@@ -197,7 +198,7 @@ impl<'de> serde::Deserialize<'de> for ConnectionEnd {
                 formatter.write_str("struct ibc.core.connection.v1.ConnectionEnd")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ConnectionEnd, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ConnectionEnd, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -206,38 +207,38 @@ impl<'de> serde::Deserialize<'de> for ConnectionEnd {
                 let mut state__ = None;
                 let mut counterparty__ = None;
                 let mut delay_period__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ClientId => {
                             if client_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientId"));
                             }
-                            client_id__ = Some(map.next_value()?);
+                            client_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Versions => {
                             if versions__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("versions"));
                             }
-                            versions__ = Some(map.next_value()?);
+                            versions__ = Some(map_.next_value()?);
                         }
                         GeneratedField::State => {
                             if state__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("state"));
                             }
-                            state__ = Some(map.next_value::<State>()? as i32);
+                            state__ = Some(map_.next_value::<State>()? as i32);
                         }
                         GeneratedField::Counterparty => {
                             if counterparty__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("counterparty"));
                             }
-                            counterparty__ = map.next_value()?;
+                            counterparty__ = map_.next_value()?;
                         }
                         GeneratedField::DelayPeriod => {
                             if delay_period__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("delayPeriod"));
                             }
                             delay_period__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -332,25 +333,25 @@ impl<'de> serde::Deserialize<'de> for ConnectionPaths {
                 formatter.write_str("struct ibc.core.connection.v1.ConnectionPaths")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ConnectionPaths, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ConnectionPaths, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut client_id__ = None;
                 let mut paths__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ClientId => {
                             if client_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientId"));
                             }
-                            client_id__ = Some(map.next_value()?);
+                            client_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Paths => {
                             if paths__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("paths"));
                             }
-                            paths__ = Some(map.next_value()?);
+                            paths__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -451,32 +452,32 @@ impl<'de> serde::Deserialize<'de> for Counterparty {
                 formatter.write_str("struct ibc.core.connection.v1.Counterparty")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Counterparty, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Counterparty, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut client_id__ = None;
                 let mut connection_id__ = None;
                 let mut prefix__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ClientId => {
                             if client_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientId"));
                             }
-                            client_id__ = Some(map.next_value()?);
+                            client_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ConnectionId => {
                             if connection_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("connectionId"));
                             }
-                            connection_id__ = Some(map.next_value()?);
+                            connection_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Prefix => {
                             if prefix__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("prefix"));
                             }
-                            prefix__ = map.next_value()?;
+                            prefix__ = map_.next_value()?;
                         }
                     }
                 }
@@ -518,6 +519,7 @@ impl serde::Serialize for GenesisState {
             struct_ser.serialize_field("clientConnectionPaths", &self.client_connection_paths)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("nextConnectionSequence", ::alloc::string::ToString::to_string(&self.next_connection_sequence).as_str())?;
         }
         if let Some(v) = self.params.as_ref() {
@@ -587,7 +589,7 @@ impl<'de> serde::Deserialize<'de> for GenesisState {
                 formatter.write_str("struct ibc.core.connection.v1.GenesisState")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<GenesisState, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<GenesisState, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -595,33 +597,33 @@ impl<'de> serde::Deserialize<'de> for GenesisState {
                 let mut client_connection_paths__ = None;
                 let mut next_connection_sequence__ = None;
                 let mut params__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Connections => {
                             if connections__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("connections"));
                             }
-                            connections__ = Some(map.next_value()?);
+                            connections__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ClientConnectionPaths => {
                             if client_connection_paths__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientConnectionPaths"));
                             }
-                            client_connection_paths__ = Some(map.next_value()?);
+                            client_connection_paths__ = Some(map_.next_value()?);
                         }
                         GeneratedField::NextConnectionSequence => {
                             if next_connection_sequence__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("nextConnectionSequence"));
                             }
                             next_connection_sequence__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Params => {
                             if params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("params"));
                             }
-                            params__ = map.next_value()?;
+                            params__ = map_.next_value()?;
                         }
                     }
                 }
@@ -673,14 +675,15 @@ impl serde::Serialize for IdentifiedConnection {
             struct_ser.serialize_field("versions", &self.versions)?;
         }
         if true {
-            let v = State::from_i32(self.state)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.state)))?;
+            let v = State::try_from(self.state)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.state)))?;
             struct_ser.serialize_field("state", &v)?;
         }
         if let Some(v) = self.counterparty.as_ref() {
             struct_ser.serialize_field("counterparty", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("delayPeriod", ::alloc::string::ToString::to_string(&self.delay_period).as_str())?;
         }
         struct_ser.end()
@@ -753,7 +756,7 @@ impl<'de> serde::Deserialize<'de> for IdentifiedConnection {
                 formatter.write_str("struct ibc.core.connection.v1.IdentifiedConnection")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<IdentifiedConnection, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<IdentifiedConnection, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -763,44 +766,44 @@ impl<'de> serde::Deserialize<'de> for IdentifiedConnection {
                 let mut state__ = None;
                 let mut counterparty__ = None;
                 let mut delay_period__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Id => {
                             if id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("id"));
                             }
-                            id__ = Some(map.next_value()?);
+                            id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ClientId => {
                             if client_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientId"));
                             }
-                            client_id__ = Some(map.next_value()?);
+                            client_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Versions => {
                             if versions__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("versions"));
                             }
-                            versions__ = Some(map.next_value()?);
+                            versions__ = Some(map_.next_value()?);
                         }
                         GeneratedField::State => {
                             if state__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("state"));
                             }
-                            state__ = Some(map.next_value::<State>()? as i32);
+                            state__ = Some(map_.next_value::<State>()? as i32);
                         }
                         GeneratedField::Counterparty => {
                             if counterparty__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("counterparty"));
                             }
-                            counterparty__ = map.next_value()?;
+                            counterparty__ = map_.next_value()?;
                         }
                         GeneratedField::DelayPeriod => {
                             if delay_period__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("delayPeriod"));
                             }
                             delay_period__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -876,12 +879,15 @@ impl serde::Serialize for MsgConnectionOpenAck {
             struct_ser.serialize_field("proofHeight", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proofTry", pbjson::private::base64::encode(&self.proof_try).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proofClient", pbjson::private::base64::encode(&self.proof_client).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proofConsensus", pbjson::private::base64::encode(&self.proof_consensus).as_str())?;
         }
         if let Some(v) = self.consensus_height.as_ref() {
@@ -891,6 +897,7 @@ impl serde::Serialize for MsgConnectionOpenAck {
             struct_ser.serialize_field("signer", &self.signer)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("hostConsensusStateProof", pbjson::private::base64::encode(&self.host_consensus_state_proof).as_str())?;
         }
         struct_ser.end()
@@ -985,7 +992,7 @@ impl<'de> serde::Deserialize<'de> for MsgConnectionOpenAck {
                 formatter.write_str("struct ibc.core.connection.v1.MsgConnectionOpenAck")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgConnectionOpenAck, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgConnectionOpenAck, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -1000,44 +1007,44 @@ impl<'de> serde::Deserialize<'de> for MsgConnectionOpenAck {
                 let mut consensus_height__ = None;
                 let mut signer__ = None;
                 let mut host_consensus_state_proof__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ConnectionId => {
                             if connection_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("connectionId"));
                             }
-                            connection_id__ = Some(map.next_value()?);
+                            connection_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::CounterpartyConnectionId => {
                             if counterparty_connection_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("counterpartyConnectionId"));
                             }
-                            counterparty_connection_id__ = Some(map.next_value()?);
+                            counterparty_connection_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Version => {
                             if version__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("version"));
                             }
-                            version__ = map.next_value()?;
+                            version__ = map_.next_value()?;
                         }
                         GeneratedField::ClientState => {
                             if client_state__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientState"));
                             }
-                            client_state__ = map.next_value()?;
+                            client_state__ = map_.next_value()?;
                         }
                         GeneratedField::ProofHeight => {
                             if proof_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofHeight"));
                             }
-                            proof_height__ = map.next_value()?;
+                            proof_height__ = map_.next_value()?;
                         }
                         GeneratedField::ProofTry => {
                             if proof_try__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofTry"));
                             }
                             proof_try__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ProofClient => {
@@ -1045,7 +1052,7 @@ impl<'de> serde::Deserialize<'de> for MsgConnectionOpenAck {
                                 return Err(serde::de::Error::duplicate_field("proofClient"));
                             }
                             proof_client__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ProofConsensus => {
@@ -1053,27 +1060,27 @@ impl<'de> serde::Deserialize<'de> for MsgConnectionOpenAck {
                                 return Err(serde::de::Error::duplicate_field("proofConsensus"));
                             }
                             proof_consensus__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ConsensusHeight => {
                             if consensus_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("consensusHeight"));
                             }
-                            consensus_height__ = map.next_value()?;
+                            consensus_height__ = map_.next_value()?;
                         }
                         GeneratedField::Signer => {
                             if signer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signer"));
                             }
-                            signer__ = Some(map.next_value()?);
+                            signer__ = Some(map_.next_value()?);
                         }
                         GeneratedField::HostConsensusStateProof => {
                             if host_consensus_state_proof__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("hostConsensusStateProof"));
                             }
                             host_consensus_state_proof__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -1153,12 +1160,12 @@ impl<'de> serde::Deserialize<'de> for MsgConnectionOpenAckResponse {
                 formatter.write_str("struct ibc.core.connection.v1.MsgConnectionOpenAckResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgConnectionOpenAckResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgConnectionOpenAckResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgConnectionOpenAckResponse {
                 })
@@ -1192,6 +1199,7 @@ impl serde::Serialize for MsgConnectionOpenConfirm {
             struct_ser.serialize_field("connectionId", &self.connection_id)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proofAck", pbjson::private::base64::encode(&self.proof_ack).as_str())?;
         }
         if let Some(v) = self.proof_height.as_ref() {
@@ -1265,7 +1273,7 @@ impl<'de> serde::Deserialize<'de> for MsgConnectionOpenConfirm {
                 formatter.write_str("struct ibc.core.connection.v1.MsgConnectionOpenConfirm")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgConnectionOpenConfirm, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgConnectionOpenConfirm, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -1273,33 +1281,33 @@ impl<'de> serde::Deserialize<'de> for MsgConnectionOpenConfirm {
                 let mut proof_ack__ = None;
                 let mut proof_height__ = None;
                 let mut signer__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ConnectionId => {
                             if connection_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("connectionId"));
                             }
-                            connection_id__ = Some(map.next_value()?);
+                            connection_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ProofAck => {
                             if proof_ack__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofAck"));
                             }
                             proof_ack__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ProofHeight => {
                             if proof_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofHeight"));
                             }
-                            proof_height__ = map.next_value()?;
+                            proof_height__ = map_.next_value()?;
                         }
                         GeneratedField::Signer => {
                             if signer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signer"));
                             }
-                            signer__ = Some(map.next_value()?);
+                            signer__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1371,12 +1379,12 @@ impl<'de> serde::Deserialize<'de> for MsgConnectionOpenConfirmResponse {
                 formatter.write_str("struct ibc.core.connection.v1.MsgConnectionOpenConfirmResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgConnectionOpenConfirmResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgConnectionOpenConfirmResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgConnectionOpenConfirmResponse {
                 })
@@ -1419,6 +1427,7 @@ impl serde::Serialize for MsgConnectionOpenInit {
             struct_ser.serialize_field("version", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("delayPeriod", ::alloc::string::ToString::to_string(&self.delay_period).as_str())?;
         }
         if true {
@@ -1491,7 +1500,7 @@ impl<'de> serde::Deserialize<'de> for MsgConnectionOpenInit {
                 formatter.write_str("struct ibc.core.connection.v1.MsgConnectionOpenInit")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgConnectionOpenInit, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgConnectionOpenInit, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -1500,39 +1509,39 @@ impl<'de> serde::Deserialize<'de> for MsgConnectionOpenInit {
                 let mut version__ = None;
                 let mut delay_period__ = None;
                 let mut signer__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ClientId => {
                             if client_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientId"));
                             }
-                            client_id__ = Some(map.next_value()?);
+                            client_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Counterparty => {
                             if counterparty__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("counterparty"));
                             }
-                            counterparty__ = map.next_value()?;
+                            counterparty__ = map_.next_value()?;
                         }
                         GeneratedField::Version => {
                             if version__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("version"));
                             }
-                            version__ = map.next_value()?;
+                            version__ = map_.next_value()?;
                         }
                         GeneratedField::DelayPeriod => {
                             if delay_period__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("delayPeriod"));
                             }
                             delay_period__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Signer => {
                             if signer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signer"));
                             }
-                            signer__ = Some(map.next_value()?);
+                            signer__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1605,12 +1614,12 @@ impl<'de> serde::Deserialize<'de> for MsgConnectionOpenInitResponse {
                 formatter.write_str("struct ibc.core.connection.v1.MsgConnectionOpenInitResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgConnectionOpenInitResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgConnectionOpenInitResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgConnectionOpenInitResponse {
                 })
@@ -1680,6 +1689,7 @@ impl serde::Serialize for MsgConnectionOpenTry {
             struct_ser.serialize_field("counterparty", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("delayPeriod", ::alloc::string::ToString::to_string(&self.delay_period).as_str())?;
         }
         if true {
@@ -1689,12 +1699,15 @@ impl serde::Serialize for MsgConnectionOpenTry {
             struct_ser.serialize_field("proofHeight", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proofInit", pbjson::private::base64::encode(&self.proof_init).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proofClient", pbjson::private::base64::encode(&self.proof_client).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proofConsensus", pbjson::private::base64::encode(&self.proof_consensus).as_str())?;
         }
         if let Some(v) = self.consensus_height.as_ref() {
@@ -1704,6 +1717,7 @@ impl serde::Serialize for MsgConnectionOpenTry {
             struct_ser.serialize_field("signer", &self.signer)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("hostConsensusStateProof", pbjson::private::base64::encode(&self.host_consensus_state_proof).as_str())?;
         }
         struct_ser.end()
@@ -1806,7 +1820,7 @@ impl<'de> serde::Deserialize<'de> for MsgConnectionOpenTry {
                 formatter.write_str("struct ibc.core.connection.v1.MsgConnectionOpenTry")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgConnectionOpenTry, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgConnectionOpenTry, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -1823,58 +1837,58 @@ impl<'de> serde::Deserialize<'de> for MsgConnectionOpenTry {
                 let mut consensus_height__ = None;
                 let mut signer__ = None;
                 let mut host_consensus_state_proof__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ClientId => {
                             if client_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientId"));
                             }
-                            client_id__ = Some(map.next_value()?);
+                            client_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::PreviousConnectionId => {
                             if previous_connection_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("previousConnectionId"));
                             }
-                            previous_connection_id__ = Some(map.next_value()?);
+                            previous_connection_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ClientState => {
                             if client_state__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientState"));
                             }
-                            client_state__ = map.next_value()?;
+                            client_state__ = map_.next_value()?;
                         }
                         GeneratedField::Counterparty => {
                             if counterparty__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("counterparty"));
                             }
-                            counterparty__ = map.next_value()?;
+                            counterparty__ = map_.next_value()?;
                         }
                         GeneratedField::DelayPeriod => {
                             if delay_period__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("delayPeriod"));
                             }
                             delay_period__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::CounterpartyVersions => {
                             if counterparty_versions__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("counterpartyVersions"));
                             }
-                            counterparty_versions__ = Some(map.next_value()?);
+                            counterparty_versions__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ProofHeight => {
                             if proof_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofHeight"));
                             }
-                            proof_height__ = map.next_value()?;
+                            proof_height__ = map_.next_value()?;
                         }
                         GeneratedField::ProofInit => {
                             if proof_init__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofInit"));
                             }
                             proof_init__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ProofClient => {
@@ -1882,7 +1896,7 @@ impl<'de> serde::Deserialize<'de> for MsgConnectionOpenTry {
                                 return Err(serde::de::Error::duplicate_field("proofClient"));
                             }
                             proof_client__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ProofConsensus => {
@@ -1890,27 +1904,27 @@ impl<'de> serde::Deserialize<'de> for MsgConnectionOpenTry {
                                 return Err(serde::de::Error::duplicate_field("proofConsensus"));
                             }
                             proof_consensus__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ConsensusHeight => {
                             if consensus_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("consensusHeight"));
                             }
-                            consensus_height__ = map.next_value()?;
+                            consensus_height__ = map_.next_value()?;
                         }
                         GeneratedField::Signer => {
                             if signer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signer"));
                             }
-                            signer__ = Some(map.next_value()?);
+                            signer__ = Some(map_.next_value()?);
                         }
                         GeneratedField::HostConsensusStateProof => {
                             if host_consensus_state_proof__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("hostConsensusStateProof"));
                             }
                             host_consensus_state_proof__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -1992,12 +2006,12 @@ impl<'de> serde::Deserialize<'de> for MsgConnectionOpenTryResponse {
                 formatter.write_str("struct ibc.core.connection.v1.MsgConnectionOpenTryResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgConnectionOpenTryResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgConnectionOpenTryResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgConnectionOpenTryResponse {
                 })
@@ -2083,25 +2097,25 @@ impl<'de> serde::Deserialize<'de> for MsgUpdateParams {
                 formatter.write_str("struct ibc.core.connection.v1.MsgUpdateParams")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgUpdateParams, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgUpdateParams, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut signer__ = None;
                 let mut params__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Signer => {
                             if signer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signer"));
                             }
-                            signer__ = Some(map.next_value()?);
+                            signer__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Params => {
                             if params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("params"));
                             }
-                            params__ = map.next_value()?;
+                            params__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2171,12 +2185,12 @@ impl<'de> serde::Deserialize<'de> for MsgUpdateParamsResponse {
                 formatter.write_str("struct ibc.core.connection.v1.MsgUpdateParamsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgUpdateParamsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgUpdateParamsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgUpdateParamsResponse {
                 })
@@ -2198,6 +2212,7 @@ impl serde::Serialize for Params {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.core.connection.v1.Params", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("maxExpectedTimePerBlock", ::alloc::string::ToString::to_string(&self.max_expected_time_per_block).as_str())?;
         }
         struct_ser.end()
@@ -2254,19 +2269,19 @@ impl<'de> serde::Deserialize<'de> for Params {
                 formatter.write_str("struct ibc.core.connection.v1.Params")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Params, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Params, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut max_expected_time_per_block__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::MaxExpectedTimePerBlock => {
                             if max_expected_time_per_block__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("maxExpectedTimePerBlock"));
                             }
                             max_expected_time_per_block__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -2348,18 +2363,18 @@ impl<'de> serde::Deserialize<'de> for QueryClientConnectionsRequest {
                 formatter.write_str("struct ibc.core.connection.v1.QueryClientConnectionsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryClientConnectionsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryClientConnectionsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut client_id__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ClientId => {
                             if client_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientId"));
                             }
-                            client_id__ = Some(map.next_value()?);
+                            client_id__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -2393,6 +2408,7 @@ impl serde::Serialize for QueryClientConnectionsResponse {
             struct_ser.serialize_field("connectionPaths", &self.connection_paths)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proof", pbjson::private::base64::encode(&self.proof).as_str())?;
         }
         if let Some(v) = self.proof_height.as_ref() {
@@ -2459,34 +2475,34 @@ impl<'de> serde::Deserialize<'de> for QueryClientConnectionsResponse {
                 formatter.write_str("struct ibc.core.connection.v1.QueryClientConnectionsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryClientConnectionsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryClientConnectionsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut connection_paths__ = None;
                 let mut proof__ = None;
                 let mut proof_height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ConnectionPaths => {
                             if connection_paths__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("connectionPaths"));
                             }
-                            connection_paths__ = Some(map.next_value()?);
+                            connection_paths__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Proof => {
                             if proof__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proof"));
                             }
                             proof__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ProofHeight => {
                             if proof_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofHeight"));
                             }
-                            proof_height__ = map.next_value()?;
+                            proof_height__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2569,18 +2585,18 @@ impl<'de> serde::Deserialize<'de> for QueryConnectionClientStateRequest {
                 formatter.write_str("struct ibc.core.connection.v1.QueryConnectionClientStateRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryConnectionClientStateRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryConnectionClientStateRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut connection_id__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ConnectionId => {
                             if connection_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("connectionId"));
                             }
-                            connection_id__ = Some(map.next_value()?);
+                            connection_id__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -2614,6 +2630,7 @@ impl serde::Serialize for QueryConnectionClientStateResponse {
             struct_ser.serialize_field("identifiedClientState", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proof", pbjson::private::base64::encode(&self.proof).as_str())?;
         }
         if let Some(v) = self.proof_height.as_ref() {
@@ -2680,34 +2697,34 @@ impl<'de> serde::Deserialize<'de> for QueryConnectionClientStateResponse {
                 formatter.write_str("struct ibc.core.connection.v1.QueryConnectionClientStateResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryConnectionClientStateResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryConnectionClientStateResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut identified_client_state__ = None;
                 let mut proof__ = None;
                 let mut proof_height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::IdentifiedClientState => {
                             if identified_client_state__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("identifiedClientState"));
                             }
-                            identified_client_state__ = map.next_value()?;
+                            identified_client_state__ = map_.next_value()?;
                         }
                         GeneratedField::Proof => {
                             if proof__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proof"));
                             }
                             proof__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ProofHeight => {
                             if proof_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofHeight"));
                             }
-                            proof_height__ = map.next_value()?;
+                            proof_height__ = map_.next_value()?;
                         }
                     }
                 }
@@ -2743,9 +2760,11 @@ impl serde::Serialize for QueryConnectionConsensusStateRequest {
             struct_ser.serialize_field("connectionId", &self.connection_id)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("revisionNumber", ::alloc::string::ToString::to_string(&self.revision_number).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("revisionHeight", ::alloc::string::ToString::to_string(&self.revision_height).as_str())?;
         }
         struct_ser.end()
@@ -2810,27 +2829,27 @@ impl<'de> serde::Deserialize<'de> for QueryConnectionConsensusStateRequest {
                 formatter.write_str("struct ibc.core.connection.v1.QueryConnectionConsensusStateRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryConnectionConsensusStateRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryConnectionConsensusStateRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut connection_id__ = None;
                 let mut revision_number__ = None;
                 let mut revision_height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ConnectionId => {
                             if connection_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("connectionId"));
                             }
-                            connection_id__ = Some(map.next_value()?);
+                            connection_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::RevisionNumber => {
                             if revision_number__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("revisionNumber"));
                             }
                             revision_number__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::RevisionHeight => {
@@ -2838,7 +2857,7 @@ impl<'de> serde::Deserialize<'de> for QueryConnectionConsensusStateRequest {
                                 return Err(serde::de::Error::duplicate_field("revisionHeight"));
                             }
                             revision_height__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -2881,6 +2900,7 @@ impl serde::Serialize for QueryConnectionConsensusStateResponse {
             struct_ser.serialize_field("clientId", &self.client_id)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proof", pbjson::private::base64::encode(&self.proof).as_str())?;
         }
         if let Some(v) = self.proof_height.as_ref() {
@@ -2951,7 +2971,7 @@ impl<'de> serde::Deserialize<'de> for QueryConnectionConsensusStateResponse {
                 formatter.write_str("struct ibc.core.connection.v1.QueryConnectionConsensusStateResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryConnectionConsensusStateResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryConnectionConsensusStateResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -2959,33 +2979,33 @@ impl<'de> serde::Deserialize<'de> for QueryConnectionConsensusStateResponse {
                 let mut client_id__ = None;
                 let mut proof__ = None;
                 let mut proof_height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ConsensusState => {
                             if consensus_state__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("consensusState"));
                             }
-                            consensus_state__ = map.next_value()?;
+                            consensus_state__ = map_.next_value()?;
                         }
                         GeneratedField::ClientId => {
                             if client_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientId"));
                             }
-                            client_id__ = Some(map.next_value()?);
+                            client_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Proof => {
                             if proof__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proof"));
                             }
                             proof__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ProofHeight => {
                             if proof_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofHeight"));
                             }
-                            proof_height__ = map.next_value()?;
+                            proof_height__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3057,12 +3077,12 @@ impl<'de> serde::Deserialize<'de> for QueryConnectionParamsRequest {
                 formatter.write_str("struct ibc.core.connection.v1.QueryConnectionParamsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryConnectionParamsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryConnectionParamsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(QueryConnectionParamsRequest {
                 })
@@ -3139,18 +3159,18 @@ impl<'de> serde::Deserialize<'de> for QueryConnectionParamsResponse {
                 formatter.write_str("struct ibc.core.connection.v1.QueryConnectionParamsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryConnectionParamsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryConnectionParamsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut params__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Params => {
                             if params__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("params"));
                             }
-                            params__ = map.next_value()?;
+                            params__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3231,18 +3251,18 @@ impl<'de> serde::Deserialize<'de> for QueryConnectionRequest {
                 formatter.write_str("struct ibc.core.connection.v1.QueryConnectionRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryConnectionRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryConnectionRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut connection_id__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ConnectionId => {
                             if connection_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("connectionId"));
                             }
-                            connection_id__ = Some(map.next_value()?);
+                            connection_id__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -3276,6 +3296,7 @@ impl serde::Serialize for QueryConnectionResponse {
             struct_ser.serialize_field("connection", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("proof", pbjson::private::base64::encode(&self.proof).as_str())?;
         }
         if let Some(v) = self.proof_height.as_ref() {
@@ -3341,34 +3362,34 @@ impl<'de> serde::Deserialize<'de> for QueryConnectionResponse {
                 formatter.write_str("struct ibc.core.connection.v1.QueryConnectionResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryConnectionResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryConnectionResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut connection__ = None;
                 let mut proof__ = None;
                 let mut proof_height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Connection => {
                             if connection__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("connection"));
                             }
-                            connection__ = map.next_value()?;
+                            connection__ = map_.next_value()?;
                         }
                         GeneratedField::Proof => {
                             if proof__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proof"));
                             }
                             proof__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ProofHeight => {
                             if proof_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofHeight"));
                             }
-                            proof_height__ = map.next_value()?;
+                            proof_height__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3450,18 +3471,18 @@ impl<'de> serde::Deserialize<'de> for QueryConnectionsRequest {
                 formatter.write_str("struct ibc.core.connection.v1.QueryConnectionsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryConnectionsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryConnectionsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3559,32 +3580,32 @@ impl<'de> serde::Deserialize<'de> for QueryConnectionsResponse {
                 formatter.write_str("struct ibc.core.connection.v1.QueryConnectionsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryConnectionsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryConnectionsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut connections__ = None;
                 let mut pagination__ = None;
                 let mut height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Connections => {
                             if connections__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("connections"));
                             }
-                            connections__ = Some(map.next_value()?);
+                            connections__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                         GeneratedField::Height => {
                             if height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("height"));
                             }
-                            height__ = map.next_value()?;
+                            height__ = map_.next_value()?;
                         }
                     }
                 }
@@ -3639,10 +3660,9 @@ impl<'de> serde::Deserialize<'de> for State {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(State::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -3652,10 +3672,9 @@ impl<'de> serde::Deserialize<'de> for State {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(State::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
@@ -3754,25 +3773,25 @@ impl<'de> serde::Deserialize<'de> for Version {
                 formatter.write_str("struct ibc.core.connection.v1.Version")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Version, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Version, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut identifier__ = None;
                 let mut features__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Identifier => {
                             if identifier__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("identifier"));
                             }
-                            identifier__ = Some(map.next_value()?);
+                            identifier__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Features => {
                             if features__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("features"));
                             }
-                            features__ = Some(map.next_value()?);
+                            features__ = Some(map_.next_value()?);
                         }
                     }
                 }
diff --git a/src/prost/ibc.core.types.v1.serde.rs b/src/prost/ibc.core.types.v1.serde.rs
index d7464c83..dec29a4f 100644
--- a/src/prost/ibc.core.types.v1.serde.rs
+++ b/src/prost/ibc.core.types.v1.serde.rs
@@ -87,32 +87,32 @@ impl<'de> serde::Deserialize<'de> for GenesisState {
                 formatter.write_str("struct ibc.core.types.v1.GenesisState")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<GenesisState, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<GenesisState, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut client_genesis__ = None;
                 let mut connection_genesis__ = None;
                 let mut channel_genesis__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ClientGenesis => {
                             if client_genesis__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientGenesis"));
                             }
-                            client_genesis__ = map.next_value()?;
+                            client_genesis__ = map_.next_value()?;
                         }
                         GeneratedField::ConnectionGenesis => {
                             if connection_genesis__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("connectionGenesis"));
                             }
-                            connection_genesis__ = map.next_value()?;
+                            connection_genesis__ = map_.next_value()?;
                         }
                         GeneratedField::ChannelGenesis => {
                             if channel_genesis__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channelGenesis"));
                             }
-                            channel_genesis__ = map.next_value()?;
+                            channel_genesis__ = map_.next_value()?;
                         }
                     }
                 }
diff --git a/src/prost/ibc.lightclients.localhost.v1.serde.rs b/src/prost/ibc.lightclients.localhost.v1.serde.rs
index 18d291f0..8036e7ca 100644
--- a/src/prost/ibc.lightclients.localhost.v1.serde.rs
+++ b/src/prost/ibc.lightclients.localhost.v1.serde.rs
@@ -76,25 +76,25 @@ impl<'de> serde::Deserialize<'de> for ClientState {
                 formatter.write_str("struct ibc.lightclients.localhost.v1.ClientState")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ClientState, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ClientState, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut chain_id__ = None;
                 let mut height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ChainId => {
                             if chain_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("chainId"));
                             }
-                            chain_id__ = Some(map.next_value()?);
+                            chain_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Height => {
                             if height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("height"));
                             }
-                            height__ = map.next_value()?;
+                            height__ = map_.next_value()?;
                         }
                     }
                 }
diff --git a/src/prost/ibc.lightclients.localhost.v2.serde.rs b/src/prost/ibc.lightclients.localhost.v2.serde.rs
index 4ba8c043..b3e462e0 100644
--- a/src/prost/ibc.lightclients.localhost.v2.serde.rs
+++ b/src/prost/ibc.lightclients.localhost.v2.serde.rs
@@ -67,18 +67,18 @@ impl<'de> serde::Deserialize<'de> for ClientState {
                 formatter.write_str("struct ibc.lightclients.localhost.v2.ClientState")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ClientState, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ClientState, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut latest_height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::LatestHeight => {
                             if latest_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("latestHeight"));
                             }
-                            latest_height__ = map.next_value()?;
+                            latest_height__ = map_.next_value()?;
                         }
                     }
                 }
diff --git a/src/prost/ibc.lightclients.solomachine.v2.serde.rs b/src/prost/ibc.lightclients.solomachine.v2.serde.rs
index 471b0cb6..6bb4f9d7 100644
--- a/src/prost/ibc.lightclients.solomachine.v2.serde.rs
+++ b/src/prost/ibc.lightclients.solomachine.v2.serde.rs
@@ -14,6 +14,7 @@ impl serde::Serialize for ChannelStateData {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.lightclients.solomachine.v2.ChannelStateData", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("path", pbjson::private::base64::encode(&self.path).as_str())?;
         }
         if let Some(v) = self.channel.as_ref() {
@@ -75,27 +76,27 @@ impl<'de> serde::Deserialize<'de> for ChannelStateData {
                 formatter.write_str("struct ibc.lightclients.solomachine.v2.ChannelStateData")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ChannelStateData, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ChannelStateData, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut path__ = None;
                 let mut channel__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Path => {
                             if path__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("path"));
                             }
                             path__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Channel => {
                             if channel__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("channel"));
                             }
-                            channel__ = map.next_value()?;
+                            channel__ = map_.next_value()?;
                         }
                     }
                 }
@@ -130,6 +131,7 @@ impl serde::Serialize for ClientState {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.lightclients.solomachine.v2.ClientState", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?;
         }
         if true {
@@ -206,7 +208,7 @@ impl<'de> serde::Deserialize<'de> for ClientState {
                 formatter.write_str("struct ibc.lightclients.solomachine.v2.ClientState")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ClientState, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ClientState, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -214,33 +216,33 @@ impl<'de> serde::Deserialize<'de> for ClientState {
                 let mut is_frozen__ = None;
                 let mut consensus_state__ = None;
                 let mut allow_update_after_proposal__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Sequence => {
                             if sequence__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sequence"));
                             }
                             sequence__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::IsFrozen => {
                             if is_frozen__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("isFrozen"));
                             }
-                            is_frozen__ = Some(map.next_value()?);
+                            is_frozen__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ConsensusState => {
                             if consensus_state__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("consensusState"));
                             }
-                            consensus_state__ = map.next_value()?;
+                            consensus_state__ = map_.next_value()?;
                         }
                         GeneratedField::AllowUpdateAfterProposal => {
                             if allow_update_after_proposal__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("allowUpdateAfterProposal"));
                             }
-                            allow_update_after_proposal__ = Some(map.next_value()?);
+                            allow_update_after_proposal__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -271,6 +273,7 @@ impl serde::Serialize for ClientStateData {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.lightclients.solomachine.v2.ClientStateData", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("path", pbjson::private::base64::encode(&self.path).as_str())?;
         }
         if let Some(v) = self.client_state.as_ref() {
@@ -333,27 +336,27 @@ impl<'de> serde::Deserialize<'de> for ClientStateData {
                 formatter.write_str("struct ibc.lightclients.solomachine.v2.ClientStateData")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ClientStateData, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ClientStateData, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut path__ = None;
                 let mut client_state__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Path => {
                             if path__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("path"));
                             }
                             path__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ClientState => {
                             if client_state__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientState"));
                             }
-                            client_state__ = map.next_value()?;
+                            client_state__ = map_.next_value()?;
                         }
                     }
                 }
@@ -382,6 +385,7 @@ impl serde::Serialize for ConnectionStateData {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.lightclients.solomachine.v2.ConnectionStateData", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("path", pbjson::private::base64::encode(&self.path).as_str())?;
         }
         if let Some(v) = self.connection.as_ref() {
@@ -443,27 +447,27 @@ impl<'de> serde::Deserialize<'de> for ConnectionStateData {
                 formatter.write_str("struct ibc.lightclients.solomachine.v2.ConnectionStateData")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ConnectionStateData, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ConnectionStateData, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut path__ = None;
                 let mut connection__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Path => {
                             if path__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("path"));
                             }
                             path__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Connection => {
                             if connection__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("connection"));
                             }
-                            connection__ = map.next_value()?;
+                            connection__ = map_.next_value()?;
                         }
                     }
                 }
@@ -501,6 +505,7 @@ impl serde::Serialize for ConsensusState {
             struct_ser.serialize_field("diversifier", &self.diversifier)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("timestamp", ::alloc::string::ToString::to_string(&self.timestamp).as_str())?;
         }
         struct_ser.end()
@@ -563,33 +568,33 @@ impl<'de> serde::Deserialize<'de> for ConsensusState {
                 formatter.write_str("struct ibc.lightclients.solomachine.v2.ConsensusState")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ConsensusState, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ConsensusState, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut public_key__ = None;
                 let mut diversifier__ = None;
                 let mut timestamp__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PublicKey => {
                             if public_key__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("publicKey"));
                             }
-                            public_key__ = map.next_value()?;
+                            public_key__ = map_.next_value()?;
                         }
                         GeneratedField::Diversifier => {
                             if diversifier__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("diversifier"));
                             }
-                            diversifier__ = Some(map.next_value()?);
+                            diversifier__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Timestamp => {
                             if timestamp__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("timestamp"));
                             }
                             timestamp__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -620,6 +625,7 @@ impl serde::Serialize for ConsensusStateData {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.lightclients.solomachine.v2.ConsensusStateData", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("path", pbjson::private::base64::encode(&self.path).as_str())?;
         }
         if let Some(v) = self.consensus_state.as_ref() {
@@ -682,27 +688,27 @@ impl<'de> serde::Deserialize<'de> for ConsensusStateData {
                 formatter.write_str("struct ibc.lightclients.solomachine.v2.ConsensusStateData")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ConsensusStateData, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ConsensusStateData, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut path__ = None;
                 let mut consensus_state__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Path => {
                             if path__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("path"));
                             }
                             path__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::ConsensusState => {
                             if consensus_state__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("consensusState"));
                             }
-                            consensus_state__ = map.next_value()?;
+                            consensus_state__ = map_.next_value()?;
                         }
                     }
                 }
@@ -768,10 +774,9 @@ impl<'de> serde::Deserialize<'de> for DataType {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(DataType::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Signed(v), &self)
                     })
@@ -781,10 +786,9 @@ impl<'de> serde::Deserialize<'de> for DataType {
             where
                 E: serde::de::Error,
             {
-                use core::convert::TryFrom;
                 i32::try_from(v)
                     .ok()
-                    .and_then(DataType::from_i32)
+                    .and_then(|x| x.try_into().ok())
                     .ok_or_else(|| {
                         serde::de::Error::invalid_value(serde::de::Unexpected::Unsigned(v), &self)
                     })
@@ -837,12 +841,15 @@ impl serde::Serialize for Header {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.lightclients.solomachine.v2.Header", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("timestamp", ::alloc::string::ToString::to_string(&self.timestamp).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("signature", pbjson::private::base64::encode(&self.signature).as_str())?;
         }
         if let Some(v) = self.new_public_key.as_ref() {
@@ -918,7 +925,7 @@ impl<'de> serde::Deserialize<'de> for Header {
                 formatter.write_str("struct ibc.lightclients.solomachine.v2.Header")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Header, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Header, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -927,14 +934,14 @@ impl<'de> serde::Deserialize<'de> for Header {
                 let mut signature__ = None;
                 let mut new_public_key__ = None;
                 let mut new_diversifier__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Sequence => {
                             if sequence__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sequence"));
                             }
                             sequence__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Timestamp => {
@@ -942,7 +949,7 @@ impl<'de> serde::Deserialize<'de> for Header {
                                 return Err(serde::de::Error::duplicate_field("timestamp"));
                             }
                             timestamp__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Signature => {
@@ -950,20 +957,20 @@ impl<'de> serde::Deserialize<'de> for Header {
                                 return Err(serde::de::Error::duplicate_field("signature"));
                             }
                             signature__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::NewPublicKey => {
                             if new_public_key__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("newPublicKey"));
                             }
-                            new_public_key__ = map.next_value()?;
+                            new_public_key__ = map_.next_value()?;
                         }
                         GeneratedField::NewDiversifier => {
                             if new_diversifier__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("newDiversifier"));
                             }
-                            new_diversifier__ = Some(map.next_value()?);
+                            new_diversifier__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1058,25 +1065,25 @@ impl<'de> serde::Deserialize<'de> for HeaderData {
                 formatter.write_str("struct ibc.lightclients.solomachine.v2.HeaderData")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<HeaderData, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<HeaderData, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut new_pub_key__ = None;
                 let mut new_diversifier__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::NewPubKey => {
                             if new_pub_key__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("newPubKey"));
                             }
-                            new_pub_key__ = map.next_value()?;
+                            new_pub_key__ = map_.next_value()?;
                         }
                         GeneratedField::NewDiversifier => {
                             if new_diversifier__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("newDiversifier"));
                             }
-                            new_diversifier__ = Some(map.next_value()?);
+                            new_diversifier__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1114,6 +1121,7 @@ impl serde::Serialize for Misbehaviour {
             struct_ser.serialize_field("clientId", &self.client_id)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?;
         }
         if let Some(v) = self.signature_one.as_ref() {
@@ -1187,7 +1195,7 @@ impl<'de> serde::Deserialize<'de> for Misbehaviour {
                 formatter.write_str("struct ibc.lightclients.solomachine.v2.Misbehaviour")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Misbehaviour, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Misbehaviour, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -1195,33 +1203,33 @@ impl<'de> serde::Deserialize<'de> for Misbehaviour {
                 let mut sequence__ = None;
                 let mut signature_one__ = None;
                 let mut signature_two__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ClientId => {
                             if client_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientId"));
                             }
-                            client_id__ = Some(map.next_value()?);
+                            client_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Sequence => {
                             if sequence__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sequence"));
                             }
                             sequence__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::SignatureOne => {
                             if signature_one__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signatureOne"));
                             }
-                            signature_one__ = map.next_value()?;
+                            signature_one__ = map_.next_value()?;
                         }
                         GeneratedField::SignatureTwo => {
                             if signature_two__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signatureTwo"));
                             }
-                            signature_two__ = map.next_value()?;
+                            signature_two__ = map_.next_value()?;
                         }
                     }
                 }
@@ -1252,9 +1260,11 @@ impl serde::Serialize for NextSequenceRecvData {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.lightclients.solomachine.v2.NextSequenceRecvData", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("path", pbjson::private::base64::encode(&self.path).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("nextSeqRecv", ::alloc::string::ToString::to_string(&self.next_seq_recv).as_str())?;
         }
         struct_ser.end()
@@ -1314,20 +1324,20 @@ impl<'de> serde::Deserialize<'de> for NextSequenceRecvData {
                 formatter.write_str("struct ibc.lightclients.solomachine.v2.NextSequenceRecvData")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<NextSequenceRecvData, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<NextSequenceRecvData, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut path__ = None;
                 let mut next_seq_recv__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Path => {
                             if path__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("path"));
                             }
                             path__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::NextSeqRecv => {
@@ -1335,7 +1345,7 @@ impl<'de> serde::Deserialize<'de> for NextSequenceRecvData {
                                 return Err(serde::de::Error::duplicate_field("nextSeqRecv"));
                             }
                             next_seq_recv__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -1365,9 +1375,11 @@ impl serde::Serialize for PacketAcknowledgementData {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.lightclients.solomachine.v2.PacketAcknowledgementData", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("path", pbjson::private::base64::encode(&self.path).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("acknowledgement", pbjson::private::base64::encode(&self.acknowledgement).as_str())?;
         }
         struct_ser.end()
@@ -1426,20 +1438,20 @@ impl<'de> serde::Deserialize<'de> for PacketAcknowledgementData {
                 formatter.write_str("struct ibc.lightclients.solomachine.v2.PacketAcknowledgementData")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<PacketAcknowledgementData, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<PacketAcknowledgementData, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut path__ = None;
                 let mut acknowledgement__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Path => {
                             if path__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("path"));
                             }
                             path__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Acknowledgement => {
@@ -1447,7 +1459,7 @@ impl<'de> serde::Deserialize<'de> for PacketAcknowledgementData {
                                 return Err(serde::de::Error::duplicate_field("acknowledgement"));
                             }
                             acknowledgement__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -1477,9 +1489,11 @@ impl serde::Serialize for PacketCommitmentData {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.lightclients.solomachine.v2.PacketCommitmentData", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("path", pbjson::private::base64::encode(&self.path).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("commitment", pbjson::private::base64::encode(&self.commitment).as_str())?;
         }
         struct_ser.end()
@@ -1538,20 +1552,20 @@ impl<'de> serde::Deserialize<'de> for PacketCommitmentData {
                 formatter.write_str("struct ibc.lightclients.solomachine.v2.PacketCommitmentData")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<PacketCommitmentData, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<PacketCommitmentData, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut path__ = None;
                 let mut commitment__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Path => {
                             if path__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("path"));
                             }
                             path__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Commitment => {
@@ -1559,7 +1573,7 @@ impl<'de> serde::Deserialize<'de> for PacketCommitmentData {
                                 return Err(serde::de::Error::duplicate_field("commitment"));
                             }
                             commitment__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -1586,6 +1600,7 @@ impl serde::Serialize for PacketReceiptAbsenceData {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.lightclients.solomachine.v2.PacketReceiptAbsenceData", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("path", pbjson::private::base64::encode(&self.path).as_str())?;
         }
         struct_ser.end()
@@ -1641,19 +1656,19 @@ impl<'de> serde::Deserialize<'de> for PacketReceiptAbsenceData {
                 formatter.write_str("struct ibc.lightclients.solomachine.v2.PacketReceiptAbsenceData")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<PacketReceiptAbsenceData, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<PacketReceiptAbsenceData, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut path__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Path => {
                             if path__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("path"));
                             }
                             path__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -1691,20 +1706,23 @@ impl serde::Serialize for SignBytes {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.lightclients.solomachine.v2.SignBytes", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("timestamp", ::alloc::string::ToString::to_string(&self.timestamp).as_str())?;
         }
         if true {
             struct_ser.serialize_field("diversifier", &self.diversifier)?;
         }
         if true {
-            let v = DataType::from_i32(self.data_type)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.data_type)))?;
+            let v = DataType::try_from(self.data_type)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.data_type)))?;
             struct_ser.serialize_field("dataType", &v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("data", pbjson::private::base64::encode(&self.data).as_str())?;
         }
         struct_ser.end()
@@ -1773,7 +1791,7 @@ impl<'de> serde::Deserialize<'de> for SignBytes {
                 formatter.write_str("struct ibc.lightclients.solomachine.v2.SignBytes")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<SignBytes, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<SignBytes, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -1782,14 +1800,14 @@ impl<'de> serde::Deserialize<'de> for SignBytes {
                 let mut diversifier__ = None;
                 let mut data_type__ = None;
                 let mut data__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Sequence => {
                             if sequence__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sequence"));
                             }
                             sequence__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Timestamp => {
@@ -1797,27 +1815,27 @@ impl<'de> serde::Deserialize<'de> for SignBytes {
                                 return Err(serde::de::Error::duplicate_field("timestamp"));
                             }
                             timestamp__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Diversifier => {
                             if diversifier__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("diversifier"));
                             }
-                            diversifier__ = Some(map.next_value()?);
+                            diversifier__ = Some(map_.next_value()?);
                         }
                         GeneratedField::DataType => {
                             if data_type__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("dataType"));
                             }
-                            data_type__ = Some(map.next_value::<DataType>()? as i32);
+                            data_type__ = Some(map_.next_value::<DataType>()? as i32);
                         }
                         GeneratedField::Data => {
                             if data__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("data"));
                             }
                             data__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -1856,17 +1874,20 @@ impl serde::Serialize for SignatureAndData {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.lightclients.solomachine.v2.SignatureAndData", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("signature", pbjson::private::base64::encode(&self.signature).as_str())?;
         }
         if true {
-            let v = DataType::from_i32(self.data_type)
-                .ok_or_else(|| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.data_type)))?;
+            let v = DataType::try_from(self.data_type)
+                .map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.data_type)))?;
             struct_ser.serialize_field("dataType", &v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("data", pbjson::private::base64::encode(&self.data).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("timestamp", ::alloc::string::ToString::to_string(&self.timestamp).as_str())?;
         }
         struct_ser.end()
@@ -1932,7 +1953,7 @@ impl<'de> serde::Deserialize<'de> for SignatureAndData {
                 formatter.write_str("struct ibc.lightclients.solomachine.v2.SignatureAndData")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<SignatureAndData, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<SignatureAndData, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -1940,28 +1961,28 @@ impl<'de> serde::Deserialize<'de> for SignatureAndData {
                 let mut data_type__ = None;
                 let mut data__ = None;
                 let mut timestamp__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Signature => {
                             if signature__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signature"));
                             }
                             signature__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::DataType => {
                             if data_type__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("dataType"));
                             }
-                            data_type__ = Some(map.next_value::<DataType>()? as i32);
+                            data_type__ = Some(map_.next_value::<DataType>()? as i32);
                         }
                         GeneratedField::Data => {
                             if data__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("data"));
                             }
                             data__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Timestamp => {
@@ -1969,7 +1990,7 @@ impl<'de> serde::Deserialize<'de> for SignatureAndData {
                                 return Err(serde::de::Error::duplicate_field("timestamp"));
                             }
                             timestamp__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -2001,9 +2022,11 @@ impl serde::Serialize for TimestampedSignatureData {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.lightclients.solomachine.v2.TimestampedSignatureData", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("signatureData", pbjson::private::base64::encode(&self.signature_data).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("timestamp", ::alloc::string::ToString::to_string(&self.timestamp).as_str())?;
         }
         struct_ser.end()
@@ -2063,20 +2086,20 @@ impl<'de> serde::Deserialize<'de> for TimestampedSignatureData {
                 formatter.write_str("struct ibc.lightclients.solomachine.v2.TimestampedSignatureData")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<TimestampedSignatureData, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<TimestampedSignatureData, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut signature_data__ = None;
                 let mut timestamp__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::SignatureData => {
                             if signature_data__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signatureData"));
                             }
                             signature_data__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Timestamp => {
@@ -2084,7 +2107,7 @@ impl<'de> serde::Deserialize<'de> for TimestampedSignatureData {
                                 return Err(serde::de::Error::duplicate_field("timestamp"));
                             }
                             timestamp__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
diff --git a/src/prost/ibc.lightclients.solomachine.v3.serde.rs b/src/prost/ibc.lightclients.solomachine.v3.serde.rs
index 3f1b5c23..aab33f1d 100644
--- a/src/prost/ibc.lightclients.solomachine.v3.serde.rs
+++ b/src/prost/ibc.lightclients.solomachine.v3.serde.rs
@@ -17,6 +17,7 @@ impl serde::Serialize for ClientState {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.lightclients.solomachine.v3.ClientState", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?;
         }
         if true {
@@ -86,34 +87,34 @@ impl<'de> serde::Deserialize<'de> for ClientState {
                 formatter.write_str("struct ibc.lightclients.solomachine.v3.ClientState")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ClientState, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ClientState, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut sequence__ = None;
                 let mut is_frozen__ = None;
                 let mut consensus_state__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Sequence => {
                             if sequence__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sequence"));
                             }
                             sequence__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::IsFrozen => {
                             if is_frozen__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("isFrozen"));
                             }
-                            is_frozen__ = Some(map.next_value()?);
+                            is_frozen__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ConsensusState => {
                             if consensus_state__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("consensusState"));
                             }
-                            consensus_state__ = map.next_value()?;
+                            consensus_state__ = map_.next_value()?;
                         }
                     }
                 }
@@ -152,6 +153,7 @@ impl serde::Serialize for ConsensusState {
             struct_ser.serialize_field("diversifier", &self.diversifier)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("timestamp", ::alloc::string::ToString::to_string(&self.timestamp).as_str())?;
         }
         struct_ser.end()
@@ -214,33 +216,33 @@ impl<'de> serde::Deserialize<'de> for ConsensusState {
                 formatter.write_str("struct ibc.lightclients.solomachine.v3.ConsensusState")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ConsensusState, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ConsensusState, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut public_key__ = None;
                 let mut diversifier__ = None;
                 let mut timestamp__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::PublicKey => {
                             if public_key__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("publicKey"));
                             }
-                            public_key__ = map.next_value()?;
+                            public_key__ = map_.next_value()?;
                         }
                         GeneratedField::Diversifier => {
                             if diversifier__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("diversifier"));
                             }
-                            diversifier__ = Some(map.next_value()?);
+                            diversifier__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Timestamp => {
                             if timestamp__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("timestamp"));
                             }
                             timestamp__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -277,9 +279,11 @@ impl serde::Serialize for Header {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.lightclients.solomachine.v3.Header", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("timestamp", ::alloc::string::ToString::to_string(&self.timestamp).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("signature", pbjson::private::base64::encode(&self.signature).as_str())?;
         }
         if let Some(v) = self.new_public_key.as_ref() {
@@ -352,7 +356,7 @@ impl<'de> serde::Deserialize<'de> for Header {
                 formatter.write_str("struct ibc.lightclients.solomachine.v3.Header")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Header, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Header, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -360,14 +364,14 @@ impl<'de> serde::Deserialize<'de> for Header {
                 let mut signature__ = None;
                 let mut new_public_key__ = None;
                 let mut new_diversifier__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Timestamp => {
                             if timestamp__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("timestamp"));
                             }
                             timestamp__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Signature => {
@@ -375,20 +379,20 @@ impl<'de> serde::Deserialize<'de> for Header {
                                 return Err(serde::de::Error::duplicate_field("signature"));
                             }
                             signature__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::NewPublicKey => {
                             if new_public_key__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("newPublicKey"));
                             }
-                            new_public_key__ = map.next_value()?;
+                            new_public_key__ = map_.next_value()?;
                         }
                         GeneratedField::NewDiversifier => {
                             if new_diversifier__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("newDiversifier"));
                             }
-                            new_diversifier__ = Some(map.next_value()?);
+                            new_diversifier__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -482,25 +486,25 @@ impl<'de> serde::Deserialize<'de> for HeaderData {
                 formatter.write_str("struct ibc.lightclients.solomachine.v3.HeaderData")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<HeaderData, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<HeaderData, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut new_pub_key__ = None;
                 let mut new_diversifier__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::NewPubKey => {
                             if new_pub_key__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("newPubKey"));
                             }
-                            new_pub_key__ = map.next_value()?;
+                            new_pub_key__ = map_.next_value()?;
                         }
                         GeneratedField::NewDiversifier => {
                             if new_diversifier__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("newDiversifier"));
                             }
-                            new_diversifier__ = Some(map.next_value()?);
+                            new_diversifier__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -532,6 +536,7 @@ impl serde::Serialize for Misbehaviour {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.lightclients.solomachine.v3.Misbehaviour", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?;
         }
         if let Some(v) = self.signature_one.as_ref() {
@@ -601,34 +606,34 @@ impl<'de> serde::Deserialize<'de> for Misbehaviour {
                 formatter.write_str("struct ibc.lightclients.solomachine.v3.Misbehaviour")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Misbehaviour, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Misbehaviour, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut sequence__ = None;
                 let mut signature_one__ = None;
                 let mut signature_two__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Sequence => {
                             if sequence__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sequence"));
                             }
                             sequence__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::SignatureOne => {
                             if signature_one__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signatureOne"));
                             }
-                            signature_one__ = map.next_value()?;
+                            signature_one__ = map_.next_value()?;
                         }
                         GeneratedField::SignatureTwo => {
                             if signature_two__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signatureTwo"));
                             }
-                            signature_two__ = map.next_value()?;
+                            signature_two__ = map_.next_value()?;
                         }
                     }
                 }
@@ -667,18 +672,22 @@ impl serde::Serialize for SignBytes {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.lightclients.solomachine.v3.SignBytes", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("sequence", ::alloc::string::ToString::to_string(&self.sequence).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("timestamp", ::alloc::string::ToString::to_string(&self.timestamp).as_str())?;
         }
         if true {
             struct_ser.serialize_field("diversifier", &self.diversifier)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("path", pbjson::private::base64::encode(&self.path).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("data", pbjson::private::base64::encode(&self.data).as_str())?;
         }
         struct_ser.end()
@@ -746,7 +755,7 @@ impl<'de> serde::Deserialize<'de> for SignBytes {
                 formatter.write_str("struct ibc.lightclients.solomachine.v3.SignBytes")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<SignBytes, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<SignBytes, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -755,14 +764,14 @@ impl<'de> serde::Deserialize<'de> for SignBytes {
                 let mut diversifier__ = None;
                 let mut path__ = None;
                 let mut data__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Sequence => {
                             if sequence__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("sequence"));
                             }
                             sequence__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Timestamp => {
@@ -770,21 +779,21 @@ impl<'de> serde::Deserialize<'de> for SignBytes {
                                 return Err(serde::de::Error::duplicate_field("timestamp"));
                             }
                             timestamp__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Diversifier => {
                             if diversifier__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("diversifier"));
                             }
-                            diversifier__ = Some(map.next_value()?);
+                            diversifier__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Path => {
                             if path__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("path"));
                             }
                             path__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Data => {
@@ -792,7 +801,7 @@ impl<'de> serde::Deserialize<'de> for SignBytes {
                                 return Err(serde::de::Error::duplicate_field("data"));
                             }
                             data__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -831,15 +840,19 @@ impl serde::Serialize for SignatureAndData {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.lightclients.solomachine.v3.SignatureAndData", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("signature", pbjson::private::base64::encode(&self.signature).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("path", pbjson::private::base64::encode(&self.path).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("data", pbjson::private::base64::encode(&self.data).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("timestamp", ::alloc::string::ToString::to_string(&self.timestamp).as_str())?;
         }
         struct_ser.end()
@@ -904,7 +917,7 @@ impl<'de> serde::Deserialize<'de> for SignatureAndData {
                 formatter.write_str("struct ibc.lightclients.solomachine.v3.SignatureAndData")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<SignatureAndData, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<SignatureAndData, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -912,14 +925,14 @@ impl<'de> serde::Deserialize<'de> for SignatureAndData {
                 let mut path__ = None;
                 let mut data__ = None;
                 let mut timestamp__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Signature => {
                             if signature__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signature"));
                             }
                             signature__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Path => {
@@ -927,7 +940,7 @@ impl<'de> serde::Deserialize<'de> for SignatureAndData {
                                 return Err(serde::de::Error::duplicate_field("path"));
                             }
                             path__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Data => {
@@ -935,7 +948,7 @@ impl<'de> serde::Deserialize<'de> for SignatureAndData {
                                 return Err(serde::de::Error::duplicate_field("data"));
                             }
                             data__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Timestamp => {
@@ -943,7 +956,7 @@ impl<'de> serde::Deserialize<'de> for SignatureAndData {
                                 return Err(serde::de::Error::duplicate_field("timestamp"));
                             }
                             timestamp__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -975,9 +988,11 @@ impl serde::Serialize for TimestampedSignatureData {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.lightclients.solomachine.v3.TimestampedSignatureData", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("signatureData", pbjson::private::base64::encode(&self.signature_data).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("timestamp", ::alloc::string::ToString::to_string(&self.timestamp).as_str())?;
         }
         struct_ser.end()
@@ -1037,20 +1052,20 @@ impl<'de> serde::Deserialize<'de> for TimestampedSignatureData {
                 formatter.write_str("struct ibc.lightclients.solomachine.v3.TimestampedSignatureData")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<TimestampedSignatureData, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<TimestampedSignatureData, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut signature_data__ = None;
                 let mut timestamp__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::SignatureData => {
                             if signature_data__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signatureData"));
                             }
                             signature_data__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Timestamp => {
@@ -1058,7 +1073,7 @@ impl<'de> serde::Deserialize<'de> for TimestampedSignatureData {
                                 return Err(serde::de::Error::duplicate_field("timestamp"));
                             }
                             timestamp__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
diff --git a/src/prost/ibc.lightclients.tendermint.v1.serde.rs b/src/prost/ibc.lightclients.tendermint.v1.serde.rs
index 02b4b24e..e17df3cf 100644
--- a/src/prost/ibc.lightclients.tendermint.v1.serde.rs
+++ b/src/prost/ibc.lightclients.tendermint.v1.serde.rs
@@ -167,7 +167,7 @@ impl<'de> serde::Deserialize<'de> for ClientState {
                 formatter.write_str("struct ibc.lightclients.tendermint.v1.ClientState")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ClientState, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ClientState, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -182,73 +182,73 @@ impl<'de> serde::Deserialize<'de> for ClientState {
                 let mut upgrade_path__ = None;
                 let mut allow_update_after_expiry__ = None;
                 let mut allow_update_after_misbehaviour__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ChainId => {
                             if chain_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("chainId"));
                             }
-                            chain_id__ = Some(map.next_value()?);
+                            chain_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::TrustLevel => {
                             if trust_level__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("trustLevel"));
                             }
-                            trust_level__ = map.next_value()?;
+                            trust_level__ = map_.next_value()?;
                         }
                         GeneratedField::TrustingPeriod => {
                             if trusting_period__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("trustingPeriod"));
                             }
-                            trusting_period__ = map.next_value()?;
+                            trusting_period__ = map_.next_value()?;
                         }
                         GeneratedField::UnbondingPeriod => {
                             if unbonding_period__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("unbondingPeriod"));
                             }
-                            unbonding_period__ = map.next_value()?;
+                            unbonding_period__ = map_.next_value()?;
                         }
                         GeneratedField::MaxClockDrift => {
                             if max_clock_drift__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("maxClockDrift"));
                             }
-                            max_clock_drift__ = map.next_value()?;
+                            max_clock_drift__ = map_.next_value()?;
                         }
                         GeneratedField::FrozenHeight => {
                             if frozen_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("frozenHeight"));
                             }
-                            frozen_height__ = map.next_value()?;
+                            frozen_height__ = map_.next_value()?;
                         }
                         GeneratedField::LatestHeight => {
                             if latest_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("latestHeight"));
                             }
-                            latest_height__ = map.next_value()?;
+                            latest_height__ = map_.next_value()?;
                         }
                         GeneratedField::ProofSpecs => {
                             if proof_specs__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("proofSpecs"));
                             }
-                            proof_specs__ = Some(map.next_value()?);
+                            proof_specs__ = Some(map_.next_value()?);
                         }
                         GeneratedField::UpgradePath => {
                             if upgrade_path__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("upgradePath"));
                             }
-                            upgrade_path__ = Some(map.next_value()?);
+                            upgrade_path__ = Some(map_.next_value()?);
                         }
                         GeneratedField::AllowUpdateAfterExpiry => {
                             if allow_update_after_expiry__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("allowUpdateAfterExpiry"));
                             }
-                            allow_update_after_expiry__ = Some(map.next_value()?);
+                            allow_update_after_expiry__ = Some(map_.next_value()?);
                         }
                         GeneratedField::AllowUpdateAfterMisbehaviour => {
                             if allow_update_after_misbehaviour__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("allowUpdateAfterMisbehaviour"));
                             }
-                            allow_update_after_misbehaviour__ = Some(map.next_value()?);
+                            allow_update_after_misbehaviour__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -295,6 +295,7 @@ impl serde::Serialize for ConsensusState {
             struct_ser.serialize_field("root", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("nextValidatorsHash", pbjson::private::base64::encode(&self.next_validators_hash).as_str())?;
         }
         struct_ser.end()
@@ -357,33 +358,33 @@ impl<'de> serde::Deserialize<'de> for ConsensusState {
                 formatter.write_str("struct ibc.lightclients.tendermint.v1.ConsensusState")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ConsensusState, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ConsensusState, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut timestamp__ = None;
                 let mut root__ = None;
                 let mut next_validators_hash__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Timestamp => {
                             if timestamp__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("timestamp"));
                             }
-                            timestamp__ = map.next_value()?;
+                            timestamp__ = map_.next_value()?;
                         }
                         GeneratedField::Root => {
                             if root__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("root"));
                             }
-                            root__ = map.next_value()?;
+                            root__ = map_.next_value()?;
                         }
                         GeneratedField::NextValidatorsHash => {
                             if next_validators_hash__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("nextValidatorsHash"));
                             }
                             next_validators_hash__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -414,9 +415,11 @@ impl serde::Serialize for Fraction {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.lightclients.tendermint.v1.Fraction", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("numerator", ::alloc::string::ToString::to_string(&self.numerator).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("denominator", ::alloc::string::ToString::to_string(&self.denominator).as_str())?;
         }
         struct_ser.end()
@@ -475,20 +478,20 @@ impl<'de> serde::Deserialize<'de> for Fraction {
                 formatter.write_str("struct ibc.lightclients.tendermint.v1.Fraction")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Fraction, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Fraction, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut numerator__ = None;
                 let mut denominator__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Numerator => {
                             if numerator__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("numerator"));
                             }
                             numerator__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Denominator => {
@@ -496,7 +499,7 @@ impl<'de> serde::Deserialize<'de> for Fraction {
                                 return Err(serde::de::Error::duplicate_field("denominator"));
                             }
                             denominator__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -609,7 +612,7 @@ impl<'de> serde::Deserialize<'de> for Header {
                 formatter.write_str("struct ibc.lightclients.tendermint.v1.Header")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Header, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Header, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -617,31 +620,31 @@ impl<'de> serde::Deserialize<'de> for Header {
                 let mut validator_set__ = None;
                 let mut trusted_height__ = None;
                 let mut trusted_validators__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::SignedHeader => {
                             if signed_header__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signedHeader"));
                             }
-                            signed_header__ = map.next_value()?;
+                            signed_header__ = map_.next_value()?;
                         }
                         GeneratedField::ValidatorSet => {
                             if validator_set__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("validatorSet"));
                             }
-                            validator_set__ = map.next_value()?;
+                            validator_set__ = map_.next_value()?;
                         }
                         GeneratedField::TrustedHeight => {
                             if trusted_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("trustedHeight"));
                             }
-                            trusted_height__ = map.next_value()?;
+                            trusted_height__ = map_.next_value()?;
                         }
                         GeneratedField::TrustedValidators => {
                             if trusted_validators__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("trustedValidators"));
                             }
-                            trusted_validators__ = map.next_value()?;
+                            trusted_validators__ = map_.next_value()?;
                         }
                     }
                 }
@@ -745,32 +748,32 @@ impl<'de> serde::Deserialize<'de> for Misbehaviour {
                 formatter.write_str("struct ibc.lightclients.tendermint.v1.Misbehaviour")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Misbehaviour, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Misbehaviour, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut client_id__ = None;
                 let mut header_1__ = None;
                 let mut header_2__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ClientId => {
                             if client_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientId"));
                             }
-                            client_id__ = Some(map.next_value()?);
+                            client_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Header1 => {
                             if header_1__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("header1"));
                             }
-                            header_1__ = map.next_value()?;
+                            header_1__ = map_.next_value()?;
                         }
                         GeneratedField::Header2 => {
                             if header_2__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("header2"));
                             }
-                            header_2__ = map.next_value()?;
+                            header_2__ = map_.next_value()?;
                         }
                     }
                 }
diff --git a/src/prost/ibc.lightclients.wasm.v1.serde.rs b/src/prost/ibc.lightclients.wasm.v1.serde.rs
index 7eadd637..1cb03d5a 100644
--- a/src/prost/ibc.lightclients.wasm.v1.serde.rs
+++ b/src/prost/ibc.lightclients.wasm.v1.serde.rs
@@ -66,19 +66,19 @@ impl<'de> serde::Deserialize<'de> for Checksums {
                 formatter.write_str("struct ibc.lightclients.wasm.v1.Checksums")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Checksums, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Checksums, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut checksums__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Checksums => {
                             if checksums__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("checksums"));
                             }
                             checksums__ = 
-                                Some(map.next_value::<::alloc::vec::Vec<::pbjson::private::BytesDeserialize<_>>>()?
+                                Some(map_.next_value::<::alloc::vec::Vec<::pbjson::private::BytesDeserialize<_>>>()?
                                     .into_iter().map(|x| x.0).collect())
                             ;
                         }
@@ -105,6 +105,7 @@ impl serde::Serialize for ClientMessage {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.lightclients.wasm.v1.ClientMessage", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("data", pbjson::private::base64::encode(&self.data).as_str())?;
         }
         struct_ser.end()
@@ -160,19 +161,19 @@ impl<'de> serde::Deserialize<'de> for ClientMessage {
                 formatter.write_str("struct ibc.lightclients.wasm.v1.ClientMessage")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ClientMessage, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ClientMessage, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut data__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Data => {
                             if data__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("data"));
                             }
                             data__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -204,9 +205,11 @@ impl serde::Serialize for ClientState {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.lightclients.wasm.v1.ClientState", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("data", pbjson::private::base64::encode(&self.data).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("checksum", pbjson::private::base64::encode(&self.checksum).as_str())?;
         }
         if let Some(v) = self.latest_height.as_ref() {
@@ -272,21 +275,21 @@ impl<'de> serde::Deserialize<'de> for ClientState {
                 formatter.write_str("struct ibc.lightclients.wasm.v1.ClientState")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ClientState, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ClientState, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut data__ = None;
                 let mut checksum__ = None;
                 let mut latest_height__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Data => {
                             if data__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("data"));
                             }
                             data__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Checksum => {
@@ -294,14 +297,14 @@ impl<'de> serde::Deserialize<'de> for ClientState {
                                 return Err(serde::de::Error::duplicate_field("checksum"));
                             }
                             checksum__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::LatestHeight => {
                             if latest_height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("latestHeight"));
                             }
-                            latest_height__ = map.next_value()?;
+                            latest_height__ = map_.next_value()?;
                         }
                     }
                 }
@@ -328,6 +331,7 @@ impl serde::Serialize for ConsensusState {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.lightclients.wasm.v1.ConsensusState", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("data", pbjson::private::base64::encode(&self.data).as_str())?;
         }
         struct_ser.end()
@@ -383,19 +387,19 @@ impl<'de> serde::Deserialize<'de> for ConsensusState {
                 formatter.write_str("struct ibc.lightclients.wasm.v1.ConsensusState")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ConsensusState, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ConsensusState, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut data__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Data => {
                             if data__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("data"));
                             }
                             data__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -421,6 +425,7 @@ impl serde::Serialize for Contract {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.lightclients.wasm.v1.Contract", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("codeBytes", pbjson::private::base64::encode(&self.code_bytes).as_str())?;
         }
         struct_ser.end()
@@ -477,19 +482,19 @@ impl<'de> serde::Deserialize<'de> for Contract {
                 formatter.write_str("struct ibc.lightclients.wasm.v1.Contract")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Contract, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Contract, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut code_bytes__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::CodeBytes => {
                             if code_bytes__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("codeBytes"));
                             }
                             code_bytes__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -570,18 +575,18 @@ impl<'de> serde::Deserialize<'de> for GenesisState {
                 formatter.write_str("struct ibc.lightclients.wasm.v1.GenesisState")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<GenesisState, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<GenesisState, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut contracts__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Contracts => {
                             if contracts__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("contracts"));
                             }
-                            contracts__ = Some(map.next_value()?);
+                            contracts__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -621,9 +626,11 @@ impl serde::Serialize for MsgMigrateContract {
             struct_ser.serialize_field("clientId", &self.client_id)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("checksum", pbjson::private::base64::encode(&self.checksum).as_str())?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("msg", pbjson::private::base64::encode(&self.msg).as_str())?;
         }
         struct_ser.end()
@@ -689,7 +696,7 @@ impl<'de> serde::Deserialize<'de> for MsgMigrateContract {
                 formatter.write_str("struct ibc.lightclients.wasm.v1.MsgMigrateContract")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgMigrateContract, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgMigrateContract, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
@@ -697,26 +704,26 @@ impl<'de> serde::Deserialize<'de> for MsgMigrateContract {
                 let mut client_id__ = None;
                 let mut checksum__ = None;
                 let mut msg__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Signer => {
                             if signer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signer"));
                             }
-                            signer__ = Some(map.next_value()?);
+                            signer__ = Some(map_.next_value()?);
                         }
                         GeneratedField::ClientId => {
                             if client_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientId"));
                             }
-                            client_id__ = Some(map.next_value()?);
+                            client_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Checksum => {
                             if checksum__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("checksum"));
                             }
                             checksum__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                         GeneratedField::Msg => {
@@ -724,7 +731,7 @@ impl<'de> serde::Deserialize<'de> for MsgMigrateContract {
                                 return Err(serde::de::Error::duplicate_field("msg"));
                             }
                             msg__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -797,12 +804,12 @@ impl<'de> serde::Deserialize<'de> for MsgMigrateContractResponse {
                 formatter.write_str("struct ibc.lightclients.wasm.v1.MsgMigrateContractResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgMigrateContractResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgMigrateContractResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgMigrateContractResponse {
                 })
@@ -830,6 +837,7 @@ impl serde::Serialize for MsgRemoveChecksum {
             struct_ser.serialize_field("signer", &self.signer)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("checksum", pbjson::private::base64::encode(&self.checksum).as_str())?;
         }
         struct_ser.end()
@@ -888,26 +896,26 @@ impl<'de> serde::Deserialize<'de> for MsgRemoveChecksum {
                 formatter.write_str("struct ibc.lightclients.wasm.v1.MsgRemoveChecksum")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgRemoveChecksum, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgRemoveChecksum, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut signer__ = None;
                 let mut checksum__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Signer => {
                             if signer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signer"));
                             }
-                            signer__ = Some(map.next_value()?);
+                            signer__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Checksum => {
                             if checksum__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("checksum"));
                             }
                             checksum__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -978,12 +986,12 @@ impl<'de> serde::Deserialize<'de> for MsgRemoveChecksumResponse {
                 formatter.write_str("struct ibc.lightclients.wasm.v1.MsgRemoveChecksumResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgRemoveChecksumResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgRemoveChecksumResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
-                while map.next_key::<GeneratedField>()?.is_some() {
-                    let _ = map.next_value::<serde::de::IgnoredAny>()?;
+                while map_.next_key::<GeneratedField>()?.is_some() {
+                    let _ = map_.next_value::<serde::de::IgnoredAny>()?;
                 }
                 Ok(MsgRemoveChecksumResponse {
                 })
@@ -1011,6 +1019,7 @@ impl serde::Serialize for MsgStoreCode {
             struct_ser.serialize_field("signer", &self.signer)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("wasmByteCode", pbjson::private::base64::encode(&self.wasm_byte_code).as_str())?;
         }
         struct_ser.end()
@@ -1070,26 +1079,26 @@ impl<'de> serde::Deserialize<'de> for MsgStoreCode {
                 formatter.write_str("struct ibc.lightclients.wasm.v1.MsgStoreCode")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgStoreCode, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgStoreCode, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut signer__ = None;
                 let mut wasm_byte_code__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Signer => {
                             if signer__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("signer"));
                             }
-                            signer__ = Some(map.next_value()?);
+                            signer__ = Some(map_.next_value()?);
                         }
                         GeneratedField::WasmByteCode => {
                             if wasm_byte_code__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("wasmByteCode"));
                             }
                             wasm_byte_code__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -1116,6 +1125,7 @@ impl serde::Serialize for MsgStoreCodeResponse {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.lightclients.wasm.v1.MsgStoreCodeResponse", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("checksum", pbjson::private::base64::encode(&self.checksum).as_str())?;
         }
         struct_ser.end()
@@ -1171,19 +1181,19 @@ impl<'de> serde::Deserialize<'de> for MsgStoreCodeResponse {
                 formatter.write_str("struct ibc.lightclients.wasm.v1.MsgStoreCodeResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<MsgStoreCodeResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgStoreCodeResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut checksum__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Checksum => {
                             if checksum__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("checksum"));
                             }
                             checksum__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -1264,18 +1274,18 @@ impl<'de> serde::Deserialize<'de> for QueryChecksumsRequest {
                 formatter.write_str("struct ibc.lightclients.wasm.v1.QueryChecksumsRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryChecksumsRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryChecksumsRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -1364,25 +1374,25 @@ impl<'de> serde::Deserialize<'de> for QueryChecksumsResponse {
                 formatter.write_str("struct ibc.lightclients.wasm.v1.QueryChecksumsResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryChecksumsResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryChecksumsResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut checksums__ = None;
                 let mut pagination__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Checksums => {
                             if checksums__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("checksums"));
                             }
-                            checksums__ = Some(map.next_value()?);
+                            checksums__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Pagination => {
                             if pagination__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("pagination"));
                             }
-                            pagination__ = map.next_value()?;
+                            pagination__ = map_.next_value()?;
                         }
                     }
                 }
@@ -1463,18 +1473,18 @@ impl<'de> serde::Deserialize<'de> for QueryCodeRequest {
                 formatter.write_str("struct ibc.lightclients.wasm.v1.QueryCodeRequest")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryCodeRequest, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryCodeRequest, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut checksum__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Checksum => {
                             if checksum__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("checksum"));
                             }
-                            checksum__ = Some(map.next_value()?);
+                            checksum__ = Some(map_.next_value()?);
                         }
                     }
                 }
@@ -1499,6 +1509,7 @@ impl serde::Serialize for QueryCodeResponse {
         }
         let mut struct_ser = serializer.serialize_struct("ibc.lightclients.wasm.v1.QueryCodeResponse", len)?;
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("data", pbjson::private::base64::encode(&self.data).as_str())?;
         }
         struct_ser.end()
@@ -1554,19 +1565,19 @@ impl<'de> serde::Deserialize<'de> for QueryCodeResponse {
                 formatter.write_str("struct ibc.lightclients.wasm.v1.QueryCodeResponse")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<QueryCodeResponse, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<QueryCodeResponse, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut data__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Data => {
                             if data__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("data"));
                             }
                             data__ = 
-                                Some(map.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
                             ;
                         }
                     }
diff --git a/src/prost/ibc.mock.serde.rs b/src/prost/ibc.mock.serde.rs
index b2d4822c..0e279efd 100644
--- a/src/prost/ibc.mock.serde.rs
+++ b/src/prost/ibc.mock.serde.rs
@@ -66,18 +66,18 @@ impl<'de> serde::Deserialize<'de> for ClientState {
                 formatter.write_str("struct ibc.mock.ClientState")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ClientState, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ClientState, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut header__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Header => {
                             if header__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("header"));
                             }
-                            header__ = map.next_value()?;
+                            header__ = map_.next_value()?;
                         }
                     }
                 }
@@ -157,18 +157,18 @@ impl<'de> serde::Deserialize<'de> for ConsensusState {
                 formatter.write_str("struct ibc.mock.ConsensusState")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<ConsensusState, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<ConsensusState, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut header__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Header => {
                             if header__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("header"));
                             }
-                            header__ = map.next_value()?;
+                            header__ = map_.next_value()?;
                         }
                     }
                 }
@@ -199,6 +199,7 @@ impl serde::Serialize for Header {
             struct_ser.serialize_field("height", v)?;
         }
         if true {
+            #[allow(clippy::needless_borrow)]
             struct_ser.serialize_field("timestamp", ::alloc::string::ToString::to_string(&self.timestamp).as_str())?;
         }
         struct_ser.end()
@@ -257,26 +258,26 @@ impl<'de> serde::Deserialize<'de> for Header {
                 formatter.write_str("struct ibc.mock.Header")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Header, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Header, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut height__ = None;
                 let mut timestamp__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::Height => {
                             if height__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("height"));
                             }
-                            height__ = map.next_value()?;
+                            height__ = map_.next_value()?;
                         }
                         GeneratedField::Timestamp => {
                             if timestamp__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("timestamp"));
                             }
                             timestamp__ = 
-                                Some(map.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
+                                Some(map_.next_value::<::pbjson::private::NumberDeserialize<_>>()?.0)
                             ;
                         }
                     }
@@ -377,32 +378,32 @@ impl<'de> serde::Deserialize<'de> for Misbehaviour {
                 formatter.write_str("struct ibc.mock.Misbehaviour")
             }
 
-            fn visit_map<V>(self, mut map: V) -> core::result::Result<Misbehaviour, V::Error>
+            fn visit_map<V>(self, mut map_: V) -> core::result::Result<Misbehaviour, V::Error>
                 where
                     V: serde::de::MapAccess<'de>,
             {
                 let mut client_id__ = None;
                 let mut header1__ = None;
                 let mut header2__ = None;
-                while let Some(k) = map.next_key()? {
+                while let Some(k) = map_.next_key()? {
                     match k {
                         GeneratedField::ClientId => {
                             if client_id__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("clientId"));
                             }
-                            client_id__ = Some(map.next_value()?);
+                            client_id__ = Some(map_.next_value()?);
                         }
                         GeneratedField::Header1 => {
                             if header1__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("header1"));
                             }
-                            header1__ = map.next_value()?;
+                            header1__ = map_.next_value()?;
                         }
                         GeneratedField::Header2 => {
                             if header2__.is_some() {
                                 return Err(serde::de::Error::duplicate_field("header2"));
                             }
-                            header2__ = map.next_value()?;
+                            header2__ = map_.next_value()?;
                         }
                     }
                 }