impl serde::Serialize for MsgRegisterInterchainAccount {
#[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.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccount", len)?;
if true {
struct_ser.serialize_field("owner", &self.owner)?;
}
if true {
struct_ser.serialize_field("connectionId", &self.connection_id)?;
}
if true {
struct_ser.serialize_field("version", &self.version)?;
}
if true {
let v = super::super::super::super::core::channel::v1::Order::try_from(self.ordering)
.map_err(|_| serde::ser::Error::custom(::alloc::format!("Invalid variant {}", self.ordering)))?;
struct_ser.serialize_field("ordering", &v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for MsgRegisterInterchainAccount {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"owner",
"connection_id",
"connectionId",
"version",
"ordering",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Owner,
ConnectionId,
Version,
Ordering,
}
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 {
"owner" => Ok(GeneratedField::Owner),
"connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
"version" => Ok(GeneratedField::Version),
"ordering" => Ok(GeneratedField::Ordering),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = MsgRegisterInterchainAccount;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
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>
where
V: serde::de::MapAccess<'de>,
{
let mut owner__ = None;
let mut connection_id__ = None;
let mut version__ = None;
let mut ordering__ = None;
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()?);
}
GeneratedField::ConnectionId => {
if connection_id__.is_some() {
return Err(serde::de::Error::duplicate_field("connectionId"));
}
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()?);
}
GeneratedField::Ordering => {
if ordering__.is_some() {
return Err(serde::de::Error::duplicate_field("ordering"));
}
ordering__ = Some(map_.next_value::<super::super::super::super::core::channel::v1::Order>()? as i32);
}
}
}
Ok(MsgRegisterInterchainAccount {
owner: owner__.unwrap_or_default(),
connection_id: connection_id__.unwrap_or_default(),
version: version__.unwrap_or_default(),
ordering: ordering__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("ibc.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccount", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for MsgRegisterInterchainAccountResponse {
#[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.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccountResponse", len)?;
if true {
struct_ser.serialize_field("channelId", &self.channel_id)?;
}
if true {
struct_ser.serialize_field("portId", &self.port_id)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for MsgRegisterInterchainAccountResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"channel_id",
"channelId",
"port_id",
"portId",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
ChannelId,
PortId,
}
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 {
"channelId" | "channel_id" => Ok(GeneratedField::ChannelId),
"portId" | "port_id" => Ok(GeneratedField::PortId),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = MsgRegisterInterchainAccountResponse;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
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>
where
V: serde::de::MapAccess<'de>,
{
let mut channel_id__ = None;
let mut port_id__ = None;
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()?);
}
GeneratedField::PortId => {
if port_id__.is_some() {
return Err(serde::de::Error::duplicate_field("portId"));
}
port_id__ = Some(map_.next_value()?);
}
}
}
Ok(MsgRegisterInterchainAccountResponse {
channel_id: channel_id__.unwrap_or_default(),
port_id: port_id__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("ibc.applications.interchain_accounts.controller.v1.MsgRegisterInterchainAccountResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for MsgSendTx {
#[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.applications.interchain_accounts.controller.v1.MsgSendTx", len)?;
if true {
struct_ser.serialize_field("owner", &self.owner)?;
}
if true {
struct_ser.serialize_field("connectionId", &self.connection_id)?;
}
if let Some(v) = self.packet_data.as_ref() {
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()
}
}
impl<'de> serde::Deserialize<'de> for MsgSendTx {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"owner",
"connection_id",
"connectionId",
"packet_data",
"packetData",
"relative_timeout",
"relativeTimeout",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Owner,
ConnectionId,
PacketData,
RelativeTimeout,
}
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 {
"owner" => Ok(GeneratedField::Owner),
"connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
"packetData" | "packet_data" => Ok(GeneratedField::PacketData),
"relativeTimeout" | "relative_timeout" => Ok(GeneratedField::RelativeTimeout),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = MsgSendTx;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
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>
where
V: serde::de::MapAccess<'de>,
{
let mut owner__ = None;
let mut connection_id__ = None;
let mut packet_data__ = None;
let mut relative_timeout__ = None;
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()?);
}
GeneratedField::ConnectionId => {
if connection_id__.is_some() {
return Err(serde::de::Error::duplicate_field("connectionId"));
}
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()?;
}
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)
;
}
}
}
Ok(MsgSendTx {
owner: owner__.unwrap_or_default(),
connection_id: connection_id__.unwrap_or_default(),
packet_data: packet_data__,
relative_timeout: relative_timeout__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("ibc.applications.interchain_accounts.controller.v1.MsgSendTx", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for MsgSendTxResponse {
#[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.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()
}
}
impl<'de> serde::Deserialize<'de> for MsgSendTxResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"sequence",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Sequence,
}
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 {
"sequence" => Ok(GeneratedField::Sequence),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = MsgSendTxResponse;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
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>
where
V: serde::de::MapAccess<'de>,
{
let mut sequence__ = None;
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)
;
}
}
}
Ok(MsgSendTxResponse {
sequence: sequence__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("ibc.applications.interchain_accounts.controller.v1.MsgSendTxResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for MsgUpdateParams {
#[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.applications.interchain_accounts.controller.v1.MsgUpdateParams", len)?;
if true {
struct_ser.serialize_field("signer", &self.signer)?;
}
if let Some(v) = self.params.as_ref() {
struct_ser.serialize_field("params", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for MsgUpdateParams {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"signer",
"params",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Signer,
Params,
}
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),
"params" => Ok(GeneratedField::Params),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = MsgUpdateParams;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
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>
where
V: serde::de::MapAccess<'de>,
{
let mut signer__ = None;
let mut params__ = 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::Params => {
if params__.is_some() {
return Err(serde::de::Error::duplicate_field("params"));
}
params__ = map_.next_value()?;
}
}
}
Ok(MsgUpdateParams {
signer: signer__.unwrap_or_default(),
params: params__,
})
}
}
deserializer.deserialize_struct("ibc.applications.interchain_accounts.controller.v1.MsgUpdateParams", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for MsgUpdateParamsResponse {
#[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.applications.interchain_accounts.controller.v1.MsgUpdateParamsResponse", len)?;
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for MsgUpdateParamsResponse {
#[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 = MsgUpdateParamsResponse;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
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>
where
V: serde::de::MapAccess<'de>,
{
while map_.next_key::<GeneratedField>()?.is_some() {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
Ok(MsgUpdateParamsResponse {
})
}
}
deserializer.deserialize_struct("ibc.applications.interchain_accounts.controller.v1.MsgUpdateParamsResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for Params {
#[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.applications.interchain_accounts.controller.v1.Params", len)?;
if true {
struct_ser.serialize_field("controllerEnabled", &self.controller_enabled)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for Params {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"controller_enabled",
"controllerEnabled",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
ControllerEnabled,
}
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 {
"controllerEnabled" | "controller_enabled" => Ok(GeneratedField::ControllerEnabled),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = Params;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
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>
where
V: serde::de::MapAccess<'de>,
{
let mut controller_enabled__ = None;
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()?);
}
}
}
Ok(Params {
controller_enabled: controller_enabled__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("ibc.applications.interchain_accounts.controller.v1.Params", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for QueryInterchainAccountRequest {
#[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.applications.interchain_accounts.controller.v1.QueryInterchainAccountRequest", len)?;
if true {
struct_ser.serialize_field("owner", &self.owner)?;
}
if true {
struct_ser.serialize_field("connectionId", &self.connection_id)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for QueryInterchainAccountRequest {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"owner",
"connection_id",
"connectionId",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Owner,
ConnectionId,
}
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 {
"owner" => Ok(GeneratedField::Owner),
"connectionId" | "connection_id" => Ok(GeneratedField::ConnectionId),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = QueryInterchainAccountRequest;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
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>
where
V: serde::de::MapAccess<'de>,
{
let mut owner__ = None;
let mut connection_id__ = None;
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()?);
}
GeneratedField::ConnectionId => {
if connection_id__.is_some() {
return Err(serde::de::Error::duplicate_field("connectionId"));
}
connection_id__ = Some(map_.next_value()?);
}
}
}
Ok(QueryInterchainAccountRequest {
owner: owner__.unwrap_or_default(),
connection_id: connection_id__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("ibc.applications.interchain_accounts.controller.v1.QueryInterchainAccountRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for QueryInterchainAccountResponse {
#[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.applications.interchain_accounts.controller.v1.QueryInterchainAccountResponse", len)?;
if true {
struct_ser.serialize_field("address", &self.address)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for QueryInterchainAccountResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"address",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Address,
}
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 {
"address" => Ok(GeneratedField::Address),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = QueryInterchainAccountResponse;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
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>
where
V: serde::de::MapAccess<'de>,
{
let mut address__ = None;
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()?);
}
}
}
Ok(QueryInterchainAccountResponse {
address: address__.unwrap_or_default(),
})
}
}
deserializer.deserialize_struct("ibc.applications.interchain_accounts.controller.v1.QueryInterchainAccountResponse", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for QueryParamsRequest {
#[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.applications.interchain_accounts.controller.v1.QueryParamsRequest", len)?;
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for QueryParamsRequest {
#[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 = QueryParamsRequest;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
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>
where
V: serde::de::MapAccess<'de>,
{
while map_.next_key::<GeneratedField>()?.is_some() {
let _ = map_.next_value::<serde::de::IgnoredAny>()?;
}
Ok(QueryParamsRequest {
})
}
}
deserializer.deserialize_struct("ibc.applications.interchain_accounts.controller.v1.QueryParamsRequest", FIELDS, GeneratedVisitor)
}
}
impl serde::Serialize for QueryParamsResponse {
#[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.applications.interchain_accounts.controller.v1.QueryParamsResponse", len)?;
if let Some(v) = self.params.as_ref() {
struct_ser.serialize_field("params", v)?;
}
struct_ser.end()
}
}
impl<'de> serde::Deserialize<'de> for QueryParamsResponse {
#[allow(deprecated)]
fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
where
D: serde::Deserializer<'de>,
{
const FIELDS: &[&str] = &[
"params",
];
#[allow(clippy::enum_variant_names)]
enum GeneratedField {
Params,
}
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 {
"params" => Ok(GeneratedField::Params),
_ => Err(serde::de::Error::unknown_field(value, FIELDS)),
}
}
}
deserializer.deserialize_identifier(GeneratedVisitor)
}
}
struct GeneratedVisitor;
impl<'de> serde::de::Visitor<'de> for GeneratedVisitor {
type Value = QueryParamsResponse;
fn expecting(&self, formatter: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
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>
where
V: serde::de::MapAccess<'de>,
{
let mut params__ = None;
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()?;
}
}
}
Ok(QueryParamsResponse {
params: params__,
})
}
}
deserializer.deserialize_struct("ibc.applications.interchain_accounts.controller.v1.QueryParamsResponse", FIELDS, GeneratedVisitor)
}
}