impl serde::Serialize for Checksums {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("ibc.lightclients.wasm.v1.Checksums", len)?;
if true {
struct_ser.serialize_field("checksums", &self.checksums.iter().map(pbjson::private::base64::encode).collect::<::alloc::vec::Vec<_>>())?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for Checksums {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"checksums",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Checksums,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"checksums" => Ok(GeneratedField::Checksums),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = Checksums;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct ibc.lightclients.wasm.v1.Checksums")
}
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()? {
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<_>>>()?
.into_iter().map(|x| x.0).collect())
;
}
}
}
Ok(Checksums {
checksums: checksums__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("ibc.lightclients.wasm.v1.Checksums", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ClientMessage {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if true {
len += 1;
}
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()
}
}
impl<'de> serde::Deserialize<'de> for ClientMessage {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"data",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Data,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"data" => Ok(GeneratedField::Data),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ClientMessage;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct ibc.lightclients.wasm.v1.ClientMessage")
}
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()? {
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)
;
}
}
}
Ok(ClientMessage {
data: data__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("ibc.lightclients.wasm.v1.ClientMessage", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ClientState {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
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() {
struct_ser.serialize_field("latestHeight", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for ClientState {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"data",
"checksum",
"latest_height",
"latestHeight",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Data,
Checksum,
LatestHeight,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"data" => Ok(GeneratedField::Data),
"checksum" => Ok(GeneratedField::Checksum),
"latestHeight" | "latest_height" => Ok(GeneratedField::LatestHeight),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ClientState;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct ibc.lightclients.wasm.v1.ClientState")
}
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()? {
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)
;
}
GeneratedField::Checksum => {
if checksum__.is_some() {
return Err(serde::de::Error::duplicate_field("checksum"));
}
checksum__ =
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()?;
}
}
}
Ok(ClientState {
data: data__.unwrap_or_default(),
checksum: checksum__.unwrap_or_default(),
latest_height: latest_height__,
})
}
}
deserializer.deserialize_struct("ibc.lightclients.wasm.v1.ClientState", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for ConsensusState {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if true {
len += 1;
}
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()
}
}
impl<'de> serde::Deserialize<'de> for ConsensusState {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"data",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Data,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"data" => Ok(GeneratedField::Data),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = ConsensusState;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct ibc.lightclients.wasm.v1.ConsensusState")
}
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()? {
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)
;
}
}
}
Ok(ConsensusState {
data: data__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("ibc.lightclients.wasm.v1.ConsensusState", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for Contract {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if true {
len += 1;
}
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()
}
}
impl<'de> serde::Deserialize<'de> for Contract {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"code_bytes",
"codeBytes",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
CodeBytes,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"codeBytes" | "code_bytes" => Ok(GeneratedField::CodeBytes),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = Contract;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct ibc.lightclients.wasm.v1.Contract")
}
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()? {
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)
;
}
}
}
Ok(Contract {
code_bytes: code_bytes__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("ibc.lightclients.wasm.v1.Contract", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for GenesisState {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("ibc.lightclients.wasm.v1.GenesisState", len)?;
if true {
struct_ser.serialize_field("contracts", &self.contracts)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for GenesisState {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"contracts",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Contracts,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"contracts" => Ok(GeneratedField::Contracts),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GenesisState;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct ibc.lightclients.wasm.v1.GenesisState")
}
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()? {
match k {
GeneratedField::Contracts => {
if contracts__.is_some() {
return Err(serde::de::Error::duplicate_field("contracts"));
}
contracts__ = Some(map_.next_value()?);
}
}
}
Ok(GenesisState {
contracts: contracts__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("ibc.lightclients.wasm.v1.GenesisState", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for MsgMigrateContract {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("ibc.lightclients.wasm.v1.MsgMigrateContract", len)?;
if true {
struct_ser.serialize_field("signer", &self.signer)?;
}
if true {
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()
}
}
impl<'de> serde::Deserialize<'de> for MsgMigrateContract {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"signer",
"client_id",
"clientId",
"checksum",
"msg",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Signer,
ClientId,
Checksum,
Msg,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"signer" => Ok(GeneratedField::Signer),
"clientId" | "client_id" => Ok(GeneratedField::ClientId),
"checksum" => Ok(GeneratedField::Checksum),
"msg" => Ok(GeneratedField::Msg),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = MsgMigrateContract;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct ibc.lightclients.wasm.v1.MsgMigrateContract")
}
fn visit_map<V>(self, mut map_: V) -> core::result::Result<MsgMigrateContract, V::Error>
where
V: serde::de::MapAccess<'de>,
{
let mut signer__ = None;
let mut client_id__ = None;
let mut checksum__ = None;
let mut msg__ = None;
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()?);
}
GeneratedField::ClientId => {
if client_id__.is_some() {
return Err(serde::de::Error::duplicate_field("clientId"));
}
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)
;
}
GeneratedField::Msg => {
if msg__.is_some() {
return Err(serde::de::Error::duplicate_field("msg"));
}
msg__ =
Some(map_.next_value::<::pbjson::private::BytesDeserialize<_>>()?.0)
;
}
}
}
Ok(MsgMigrateContract {
signer: signer__.unwrap_or_default(),
client_id: client_id__.unwrap_or_default(),
checksum: checksum__.unwrap_or_default(),
msg: msg__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("ibc.lightclients.wasm.v1.MsgMigrateContract", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for MsgMigrateContractResponse {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let len = 0;
let struct_ser = serializer.serialize_struct("ibc.lightclients.wasm.v1.MsgMigrateContractResponse", len)?;
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for MsgMigrateContractResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
Err(serde::de::Error::unknown_field(value, FIELDS))
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = MsgMigrateContractResponse;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct ibc.lightclients.wasm.v1.MsgMigrateContractResponse")
}
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>()?;
}
Ok(MsgMigrateContractResponse {
})
}
}
deserializer.deserialize_struct("ibc.lightclients.wasm.v1.MsgMigrateContractResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for MsgRemoveChecksum {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("ibc.lightclients.wasm.v1.MsgRemoveChecksum", len)?;
if true {
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()
}
}
impl<'de> serde::Deserialize<'de> for MsgRemoveChecksum {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"signer",
"checksum",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Signer,
Checksum,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"signer" => Ok(GeneratedField::Signer),
"checksum" => Ok(GeneratedField::Checksum),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = MsgRemoveChecksum;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct ibc.lightclients.wasm.v1.MsgRemoveChecksum")
}
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()? {
match k {
GeneratedField::Signer => {
if signer__.is_some() {
return Err(serde::de::Error::duplicate_field("signer"));
}
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)
;
}
}
}
Ok(MsgRemoveChecksum {
signer: signer__.unwrap_or_default(),
checksum: checksum__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("ibc.lightclients.wasm.v1.MsgRemoveChecksum", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for MsgRemoveChecksumResponse {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let len = 0;
let struct_ser = serializer.serialize_struct("ibc.lightclients.wasm.v1.MsgRemoveChecksumResponse", len)?;
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for MsgRemoveChecksumResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
Err(serde::de::Error::unknown_field(value, FIELDS))
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = MsgRemoveChecksumResponse;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct ibc.lightclients.wasm.v1.MsgRemoveChecksumResponse")
}
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>()?;
}
Ok(MsgRemoveChecksumResponse {
})
}
}
deserializer.deserialize_struct("ibc.lightclients.wasm.v1.MsgRemoveChecksumResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for MsgStoreCode {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("ibc.lightclients.wasm.v1.MsgStoreCode", len)?;
if true {
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()
}
}
impl<'de> serde::Deserialize<'de> for MsgStoreCode {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"signer",
"wasm_byte_code",
"wasmByteCode",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Signer,
WasmByteCode,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"signer" => Ok(GeneratedField::Signer),
"wasmByteCode" | "wasm_byte_code" => Ok(GeneratedField::WasmByteCode),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = MsgStoreCode;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct ibc.lightclients.wasm.v1.MsgStoreCode")
}
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()? {
match k {
GeneratedField::Signer => {
if signer__.is_some() {
return Err(serde::de::Error::duplicate_field("signer"));
}
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)
;
}
}
}
Ok(MsgStoreCode {
signer: signer__.unwrap_or_default(),
wasm_byte_code: wasm_byte_code__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("ibc.lightclients.wasm.v1.MsgStoreCode", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for MsgStoreCodeResponse {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if true {
len += 1;
}
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()
}
}
impl<'de> serde::Deserialize<'de> for MsgStoreCodeResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"checksum",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Checksum,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"checksum" => Ok(GeneratedField::Checksum),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = MsgStoreCodeResponse;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct ibc.lightclients.wasm.v1.MsgStoreCodeResponse")
}
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()? {
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)
;
}
}
}
Ok(MsgStoreCodeResponse {
checksum: checksum__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("ibc.lightclients.wasm.v1.MsgStoreCodeResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for QueryChecksumsRequest {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("ibc.lightclients.wasm.v1.QueryChecksumsRequest", len)?;
if let Some(v) = self.pagination.as_ref() {
struct_ser.serialize_field("pagination", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for QueryChecksumsRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"pagination",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Pagination,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"pagination" => Ok(GeneratedField::Pagination),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = QueryChecksumsRequest;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct ibc.lightclients.wasm.v1.QueryChecksumsRequest")
}
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()? {
match k {
GeneratedField::Pagination => {
if pagination__.is_some() {
return Err(serde::de::Error::duplicate_field("pagination"));
}
pagination__ = map_.next_value()?;
}
}
}
Ok(QueryChecksumsRequest {
pagination: pagination__,
})
}
}
deserializer.deserialize_struct("ibc.lightclients.wasm.v1.QueryChecksumsRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for QueryChecksumsResponse {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if true {
len += 1;
}
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("ibc.lightclients.wasm.v1.QueryChecksumsResponse", len)?;
if true {
struct_ser.serialize_field("checksums", &self.checksums)?;
}
if let Some(v) = self.pagination.as_ref() {
struct_ser.serialize_field("pagination", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for QueryChecksumsResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"checksums",
"pagination",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Checksums,
Pagination,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"checksums" => Ok(GeneratedField::Checksums),
"pagination" => Ok(GeneratedField::Pagination),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = QueryChecksumsResponse;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct ibc.lightclients.wasm.v1.QueryChecksumsResponse")
}
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()? {
match k {
GeneratedField::Checksums => {
if checksums__.is_some() {
return Err(serde::de::Error::duplicate_field("checksums"));
}
checksums__ = Some(map_.next_value()?);
}
GeneratedField::Pagination => {
if pagination__.is_some() {
return Err(serde::de::Error::duplicate_field("pagination"));
}
pagination__ = map_.next_value()?;
}
}
}
Ok(QueryChecksumsResponse {
checksums: checksums__.unwrap_or_default(),
pagination: pagination__,
})
}
}
deserializer.deserialize_struct("ibc.lightclients.wasm.v1.QueryChecksumsResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for QueryCodeRequest {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if true {
len += 1;
}
let mut struct_ser = serializer.serialize_struct("ibc.lightclients.wasm.v1.QueryCodeRequest", len)?;
if true {
struct_ser.serialize_field("checksum", &self.checksum)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for QueryCodeRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"checksum",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Checksum,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"checksum" => Ok(GeneratedField::Checksum),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = QueryCodeRequest;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct ibc.lightclients.wasm.v1.QueryCodeRequest")
}
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()? {
match k {
GeneratedField::Checksum => {
if checksum__.is_some() {
return Err(serde::de::Error::duplicate_field("checksum"));
}
checksum__ = Some(map_.next_value()?);
}
}
}
Ok(QueryCodeRequest {
checksum: checksum__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("ibc.lightclients.wasm.v1.QueryCodeRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for QueryCodeResponse {
#[allow(deprecated)]
fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
where
S: serde::Serializer,
{
use serde::ser::SerializeStruct;
let mut len = 0;
if true {
len += 1;
}
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()
}
}
impl<'de> serde::Deserialize<'de> for QueryCodeResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"data",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Data,
}
impl<'de> serde::Deserialize<'de> for GeneratedField {
fn deserialize<D>(deserializer: D) -> core::result::Result<GeneratedField, D::Error>
where
D: serde::Deserializer<'de>,
{
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = GeneratedField;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
write!(formatter, "expected one of: {:?}", &FIELDS)
}
#[allow(unused_variables)]
fn visit_str<E>(self, value: &str) -> core::result::Result<GeneratedField, E>
where
E: serde::de::Error,
{
match value {
"data" => Ok(GeneratedField::Data),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = QueryCodeResponse;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
formatter.write_str("struct ibc.lightclients.wasm.v1.QueryCodeResponse")
}
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()? {
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)
;
}
}
}
Ok(QueryCodeResponse {
data: data__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("ibc.lightclients.wasm.v1.QueryCodeResponse", FIELDS, GeneratedVisitor)
}
}