mod msg {
    use crate::logo::Logo;
    use cw_orch::ExecuteFns;
    use cosmwasm_schema::cw_serde;
    use cosmwasm_std::{Binary, Uint128};
    use cw_utils::Expiration;
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[serde(
        deny_unknown_fields,
        rename_all = "snake_case",
        crate = "::cosmwasm_schema::serde"
    )]
    #[schemars(crate = "::cosmwasm_schema::schemars")]
    pub enum Cw20ExecuteMsg {
        /// Transfer is a base message to move tokens to another account without triggering actions
        Transfer { recipient: String, amount: Uint128 },
        /// Burn is a base message to destroy tokens forever
        Burn { amount: Uint128 },
        /// Send is a base message to transfer tokens to a contract and trigger an action
        /// on the receiving contract.
        Send { contract: String, amount: Uint128, msg: Binary },
        /// Only with "approval" extension. Allows spender to access an additional amount tokens
        /// from the owner's (env.sender) account. If expires is Some(), overwrites current allowance
        /// expiration with this one.
        IncreaseAllowance {
            spender: String,
            amount: Uint128,
            expires: Option<Expiration>,
        },
        /// Only with "approval" extension. Lowers the spender's access of tokens
        /// from the owner's (env.sender) account by amount. If expires is Some(), overwrites current
        /// allowance expiration with this one.
        DecreaseAllowance {
            spender: String,
            amount: Uint128,
            expires: Option<Expiration>,
        },
        /// Only with "approval" extension. Transfers amount tokens from owner -> recipient
        /// if `env.sender` has sufficient pre-approval.
        TransferFrom { owner: String, recipient: String, amount: Uint128 },
        /// Only with "approval" extension. Sends amount tokens from owner -> contract
        /// if `env.sender` has sufficient pre-approval.
        SendFrom { owner: String, contract: String, amount: Uint128, msg: Binary },
        /// Only with "approval" extension. Destroys tokens forever
        BurnFrom { owner: String, amount: Uint128 },
        /// Only with the "mintable" extension. If authorized, creates amount new tokens
        /// and adds to the recipient balance.
        Mint { recipient: String, amount: Uint128 },
        /// Only with the "mintable" extension. The current minter may set
        /// a new minter. Setting the minter to None will remove the
        /// token's minter forever.
        UpdateMinter { new_minter: Option<String> },
        /// Only with the "marketing" extension. If authorized, updates marketing metadata.
        /// Setting None/null for any of these will leave it unchanged.
        /// Setting Some("") will clear this field on the contract storage
        UpdateMarketing {
            /// A URL pointing to the project behind this token.
            project: Option<String>,
            /// A longer description of the token and it's utility. Designed for tooltips or such
            description: Option<String>,
            /// The address (if any) who can update this data structure
            marketing: Option<String>,
        },
        /// If set as the "marketing" role on the contract, upload a new URL, SVG, or PNG for the token
        UploadLogo(Logo),
    }
    pub trait Cw20ExecuteMsgFns<
        Chain: ::cw_orch::CwEnv,
    >: ::cw_orch::BootExecute<Chain, ExecuteMsg = Cw20ExecuteMsg> {
        #[allow(clippy::too_many_arguments)]
        fn transfer(
            &self,
            amount: Uint128,
            recipient: String,
        ) -> Result<::cw_orch::TxResponse<Chain>, ::cw_orch::BootError> {
            let msg = Cw20ExecuteMsg::Transfer {
                amount,
                recipient,
            };
            self.execute(&msg, None)
        }
        #[allow(clippy::too_many_arguments)]
        fn burn(
            &self,
            amount: Uint128,
        ) -> Result<::cw_orch::TxResponse<Chain>, ::cw_orch::BootError> {
            let msg = Cw20ExecuteMsg::Burn { amount };
            self.execute(&msg, None)
        }
        #[allow(clippy::too_many_arguments)]
        fn send(
            &self,
            amount: Uint128,
            contract: String,
            msg: Binary,
        ) -> Result<::cw_orch::TxResponse<Chain>, ::cw_orch::BootError> {
            let msg = Cw20ExecuteMsg::Send {
                amount,
                contract,
                msg,
            };
            self.execute(&msg, None)
        }
        #[allow(clippy::too_many_arguments)]
        fn increase_allowance(
            &self,
            amount: Uint128,
            spender: String,
            expires: Option<Expiration>,
        ) -> Result<::cw_orch::TxResponse<Chain>, ::cw_orch::BootError> {
            let msg = Cw20ExecuteMsg::IncreaseAllowance {
                amount,
                spender,
                expires,
            };
            self.execute(&msg, None)
        }
        #[allow(clippy::too_many_arguments)]
        fn decrease_allowance(
            &self,
            amount: Uint128,
            spender: String,
            expires: Option<Expiration>,
        ) -> Result<::cw_orch::TxResponse<Chain>, ::cw_orch::BootError> {
            let msg = Cw20ExecuteMsg::DecreaseAllowance {
                amount,
                spender,
                expires,
            };
            self.execute(&msg, None)
        }
        #[allow(clippy::too_many_arguments)]
        fn transfer_from(
            &self,
            amount: Uint128,
            owner: String,
            recipient: String,
        ) -> Result<::cw_orch::TxResponse<Chain>, ::cw_orch::BootError> {
            let msg = Cw20ExecuteMsg::TransferFrom {
                amount,
                owner,
                recipient,
            };
            self.execute(&msg, None)
        }
        #[allow(clippy::too_many_arguments)]
        fn send_from(
            &self,
            amount: Uint128,
            contract: String,
            msg: Binary,
            owner: String,
        ) -> Result<::cw_orch::TxResponse<Chain>, ::cw_orch::BootError> {
            let msg = Cw20ExecuteMsg::SendFrom {
                amount,
                contract,
                msg,
                owner,
            };
            self.execute(&msg, None)
        }
        #[allow(clippy::too_many_arguments)]
        fn burn_from(
            &self,
            amount: Uint128,
            owner: String,
        ) -> Result<::cw_orch::TxResponse<Chain>, ::cw_orch::BootError> {
            let msg = Cw20ExecuteMsg::BurnFrom {
                amount,
                owner,
            };
            self.execute(&msg, None)
        }
        #[allow(clippy::too_many_arguments)]
        fn mint(
            &self,
            amount: Uint128,
            recipient: String,
        ) -> Result<::cw_orch::TxResponse<Chain>, ::cw_orch::BootError> {
            let msg = Cw20ExecuteMsg::Mint {
                amount,
                recipient,
            };
            self.execute(&msg, None)
        }
        #[allow(clippy::too_many_arguments)]
        fn update_minter(
            &self,
            new_minter: Option<String>,
        ) -> Result<::cw_orch::TxResponse<Chain>, ::cw_orch::BootError> {
            let msg = Cw20ExecuteMsg::UpdateMinter {
                new_minter,
            };
            self.execute(&msg, None)
        }
        #[allow(clippy::too_many_arguments)]
        fn update_marketing(
            &self,
            description: Option<String>,
            marketing: Option<String>,
            project: Option<String>,
        ) -> Result<::cw_orch::TxResponse<Chain>, ::cw_orch::BootError> {
            let msg = Cw20ExecuteMsg::UpdateMarketing {
                description,
                marketing,
                project,
            };
            self.execute(&msg, None)
        }
    }
    #[automatically_derived]
    impl<SupportedContract, Chain: ::cw_orch::CwEnv> Cw20ExecuteMsgFns<Chain>
    for SupportedContract
    where
        SupportedContract: ::cw_orch::BootExecute<Chain, ExecuteMsg = Cw20ExecuteMsg>,
    {}
    #[doc(hidden)]
    #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
    const _: () = {
        use ::cosmwasm_schema::serde as _serde;
        #[automatically_derived]
        impl ::cosmwasm_schema::serde::Serialize for Cw20ExecuteMsg {
            fn serialize<__S>(
                &self,
                __serializer: __S,
            ) -> ::cosmwasm_schema::serde::__private::Result<__S::Ok, __S::Error>
            where
                __S: ::cosmwasm_schema::serde::Serializer,
            {
                match *self {
                    Cw20ExecuteMsg::Transfer { ref recipient, ref amount } => {
                        let mut __serde_state = match _serde::Serializer::serialize_struct_variant(
                            __serializer,
                            "Cw20ExecuteMsg",
                            0u32,
                            "transfer",
                            0 + 1 + 1,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStructVariant::serialize_field(
                            &mut __serde_state,
                            "recipient",
                            recipient,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStructVariant::serialize_field(
                            &mut __serde_state,
                            "amount",
                            amount,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        _serde::ser::SerializeStructVariant::end(__serde_state)
                    }
                    Cw20ExecuteMsg::Burn { ref amount } => {
                        let mut __serde_state = match _serde::Serializer::serialize_struct_variant(
                            __serializer,
                            "Cw20ExecuteMsg",
                            1u32,
                            "burn",
                            0 + 1,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStructVariant::serialize_field(
                            &mut __serde_state,
                            "amount",
                            amount,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        _serde::ser::SerializeStructVariant::end(__serde_state)
                    }
                    Cw20ExecuteMsg::Send { ref contract, ref amount, ref msg } => {
                        let mut __serde_state = match _serde::Serializer::serialize_struct_variant(
                            __serializer,
                            "Cw20ExecuteMsg",
                            2u32,
                            "send",
                            0 + 1 + 1 + 1,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStructVariant::serialize_field(
                            &mut __serde_state,
                            "contract",
                            contract,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStructVariant::serialize_field(
                            &mut __serde_state,
                            "amount",
                            amount,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStructVariant::serialize_field(
                            &mut __serde_state,
                            "msg",
                            msg,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        _serde::ser::SerializeStructVariant::end(__serde_state)
                    }
                    Cw20ExecuteMsg::IncreaseAllowance {
                        ref spender,
                        ref amount,
                        ref expires,
                    } => {
                        let mut __serde_state = match _serde::Serializer::serialize_struct_variant(
                            __serializer,
                            "Cw20ExecuteMsg",
                            3u32,
                            "increase_allowance",
                            0 + 1 + 1 + 1,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStructVariant::serialize_field(
                            &mut __serde_state,
                            "spender",
                            spender,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStructVariant::serialize_field(
                            &mut __serde_state,
                            "amount",
                            amount,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStructVariant::serialize_field(
                            &mut __serde_state,
                            "expires",
                            expires,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        _serde::ser::SerializeStructVariant::end(__serde_state)
                    }
                    Cw20ExecuteMsg::DecreaseAllowance {
                        ref spender,
                        ref amount,
                        ref expires,
                    } => {
                        let mut __serde_state = match _serde::Serializer::serialize_struct_variant(
                            __serializer,
                            "Cw20ExecuteMsg",
                            4u32,
                            "decrease_allowance",
                            0 + 1 + 1 + 1,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStructVariant::serialize_field(
                            &mut __serde_state,
                            "spender",
                            spender,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStructVariant::serialize_field(
                            &mut __serde_state,
                            "amount",
                            amount,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStructVariant::serialize_field(
                            &mut __serde_state,
                            "expires",
                            expires,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        _serde::ser::SerializeStructVariant::end(__serde_state)
                    }
                    Cw20ExecuteMsg::TransferFrom {
                        ref owner,
                        ref recipient,
                        ref amount,
                    } => {
                        let mut __serde_state = match _serde::Serializer::serialize_struct_variant(
                            __serializer,
                            "Cw20ExecuteMsg",
                            5u32,
                            "transfer_from",
                            0 + 1 + 1 + 1,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStructVariant::serialize_field(
                            &mut __serde_state,
                            "owner",
                            owner,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStructVariant::serialize_field(
                            &mut __serde_state,
                            "recipient",
                            recipient,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStructVariant::serialize_field(
                            &mut __serde_state,
                            "amount",
                            amount,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        _serde::ser::SerializeStructVariant::end(__serde_state)
                    }
                    Cw20ExecuteMsg::SendFrom {
                        ref owner,
                        ref contract,
                        ref amount,
                        ref msg,
                    } => {
                        let mut __serde_state = match _serde::Serializer::serialize_struct_variant(
                            __serializer,
                            "Cw20ExecuteMsg",
                            6u32,
                            "send_from",
                            0 + 1 + 1 + 1 + 1,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStructVariant::serialize_field(
                            &mut __serde_state,
                            "owner",
                            owner,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStructVariant::serialize_field(
                            &mut __serde_state,
                            "contract",
                            contract,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStructVariant::serialize_field(
                            &mut __serde_state,
                            "amount",
                            amount,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStructVariant::serialize_field(
                            &mut __serde_state,
                            "msg",
                            msg,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        _serde::ser::SerializeStructVariant::end(__serde_state)
                    }
                    Cw20ExecuteMsg::BurnFrom { ref owner, ref amount } => {
                        let mut __serde_state = match _serde::Serializer::serialize_struct_variant(
                            __serializer,
                            "Cw20ExecuteMsg",
                            7u32,
                            "burn_from",
                            0 + 1 + 1,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStructVariant::serialize_field(
                            &mut __serde_state,
                            "owner",
                            owner,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStructVariant::serialize_field(
                            &mut __serde_state,
                            "amount",
                            amount,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        _serde::ser::SerializeStructVariant::end(__serde_state)
                    }
                    Cw20ExecuteMsg::Mint { ref recipient, ref amount } => {
                        let mut __serde_state = match _serde::Serializer::serialize_struct_variant(
                            __serializer,
                            "Cw20ExecuteMsg",
                            8u32,
                            "mint",
                            0 + 1 + 1,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStructVariant::serialize_field(
                            &mut __serde_state,
                            "recipient",
                            recipient,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStructVariant::serialize_field(
                            &mut __serde_state,
                            "amount",
                            amount,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        _serde::ser::SerializeStructVariant::end(__serde_state)
                    }
                    Cw20ExecuteMsg::UpdateMinter { ref new_minter } => {
                        let mut __serde_state = match _serde::Serializer::serialize_struct_variant(
                            __serializer,
                            "Cw20ExecuteMsg",
                            9u32,
                            "update_minter",
                            0 + 1,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStructVariant::serialize_field(
                            &mut __serde_state,
                            "new_minter",
                            new_minter,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        _serde::ser::SerializeStructVariant::end(__serde_state)
                    }
                    Cw20ExecuteMsg::UpdateMarketing {
                        ref project,
                        ref description,
                        ref marketing,
                    } => {
                        let mut __serde_state = match _serde::Serializer::serialize_struct_variant(
                            __serializer,
                            "Cw20ExecuteMsg",
                            10u32,
                            "update_marketing",
                            0 + 1 + 1 + 1,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStructVariant::serialize_field(
                            &mut __serde_state,
                            "project",
                            project,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStructVariant::serialize_field(
                            &mut __serde_state,
                            "description",
                            description,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        match _serde::ser::SerializeStructVariant::serialize_field(
                            &mut __serde_state,
                            "marketing",
                            marketing,
                        ) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        };
                        _serde::ser::SerializeStructVariant::end(__serde_state)
                    }
                    Cw20ExecuteMsg::UploadLogo(ref __field0) => {
                        _serde::Serializer::serialize_newtype_variant(
                            __serializer,
                            "Cw20ExecuteMsg",
                            11u32,
                            "upload_logo",
                            __field0,
                        )
                    }
                }
            }
        }
    };
    #[doc(hidden)]
    #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
    const _: () = {
        use ::cosmwasm_schema::serde as _serde;
        #[automatically_derived]
        impl<'de> ::cosmwasm_schema::serde::Deserialize<'de> for Cw20ExecuteMsg {
            fn deserialize<__D>(
                __deserializer: __D,
            ) -> ::cosmwasm_schema::serde::__private::Result<Self, __D::Error>
            where
                __D: ::cosmwasm_schema::serde::Deserializer<'de>,
            {
                #[allow(non_camel_case_types)]
                enum __Field {
                    __field0,
                    __field1,
                    __field2,
                    __field3,
                    __field4,
                    __field5,
                    __field6,
                    __field7,
                    __field8,
                    __field9,
                    __field10,
                    __field11,
                }
                struct __FieldVisitor;
                impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
                    type Value = __Field;
                    fn expecting(
                        &self,
                        __formatter: &mut _serde::__private::Formatter,
                    ) -> _serde::__private::fmt::Result {
                        _serde::__private::Formatter::write_str(
                            __formatter,
                            "variant identifier",
                        )
                    }
                    fn visit_u64<__E>(
                        self,
                        __value: u64,
                    ) -> _serde::__private::Result<Self::Value, __E>
                    where
                        __E: _serde::de::Error,
                    {
                        match __value {
                            0u64 => _serde::__private::Ok(__Field::__field0),
                            1u64 => _serde::__private::Ok(__Field::__field1),
                            2u64 => _serde::__private::Ok(__Field::__field2),
                            3u64 => _serde::__private::Ok(__Field::__field3),
                            4u64 => _serde::__private::Ok(__Field::__field4),
                            5u64 => _serde::__private::Ok(__Field::__field5),
                            6u64 => _serde::__private::Ok(__Field::__field6),
                            7u64 => _serde::__private::Ok(__Field::__field7),
                            8u64 => _serde::__private::Ok(__Field::__field8),
                            9u64 => _serde::__private::Ok(__Field::__field9),
                            10u64 => _serde::__private::Ok(__Field::__field10),
                            11u64 => _serde::__private::Ok(__Field::__field11),
                            _ => {
                                _serde::__private::Err(
                                    _serde::de::Error::invalid_value(
                                        _serde::de::Unexpected::Unsigned(__value),
                                        &"variant index 0 <= i < 12",
                                    ),
                                )
                            }
                        }
                    }
                    fn visit_str<__E>(
                        self,
                        __value: &str,
                    ) -> _serde::__private::Result<Self::Value, __E>
                    where
                        __E: _serde::de::Error,
                    {
                        match __value {
                            "transfer" => _serde::__private::Ok(__Field::__field0),
                            "burn" => _serde::__private::Ok(__Field::__field1),
                            "send" => _serde::__private::Ok(__Field::__field2),
                            "increase_allowance" => {
                                _serde::__private::Ok(__Field::__field3)
                            }
                            "decrease_allowance" => {
                                _serde::__private::Ok(__Field::__field4)
                            }
                            "transfer_from" => _serde::__private::Ok(__Field::__field5),
                            "send_from" => _serde::__private::Ok(__Field::__field6),
                            "burn_from" => _serde::__private::Ok(__Field::__field7),
                            "mint" => _serde::__private::Ok(__Field::__field8),
                            "update_minter" => _serde::__private::Ok(__Field::__field9),
                            "update_marketing" => {
                                _serde::__private::Ok(__Field::__field10)
                            }
                            "upload_logo" => _serde::__private::Ok(__Field::__field11),
                            _ => {
                                _serde::__private::Err(
                                    _serde::de::Error::unknown_variant(__value, VARIANTS),
                                )
                            }
                        }
                    }
                    fn visit_bytes<__E>(
                        self,
                        __value: &[u8],
                    ) -> _serde::__private::Result<Self::Value, __E>
                    where
                        __E: _serde::de::Error,
                    {
                        match __value {
                            b"transfer" => _serde::__private::Ok(__Field::__field0),
                            b"burn" => _serde::__private::Ok(__Field::__field1),
                            b"send" => _serde::__private::Ok(__Field::__field2),
                            b"increase_allowance" => {
                                _serde::__private::Ok(__Field::__field3)
                            }
                            b"decrease_allowance" => {
                                _serde::__private::Ok(__Field::__field4)
                            }
                            b"transfer_from" => _serde::__private::Ok(__Field::__field5),
                            b"send_from" => _serde::__private::Ok(__Field::__field6),
                            b"burn_from" => _serde::__private::Ok(__Field::__field7),
                            b"mint" => _serde::__private::Ok(__Field::__field8),
                            b"update_minter" => _serde::__private::Ok(__Field::__field9),
                            b"update_marketing" => {
                                _serde::__private::Ok(__Field::__field10)
                            }
                            b"upload_logo" => _serde::__private::Ok(__Field::__field11),
                            _ => {
                                let __value = &_serde::__private::from_utf8_lossy(__value);
                                _serde::__private::Err(
                                    _serde::de::Error::unknown_variant(__value, VARIANTS),
                                )
                            }
                        }
                    }
                }
                impl<'de> _serde::Deserialize<'de> for __Field {
                    #[inline]
                    fn deserialize<__D>(
                        __deserializer: __D,
                    ) -> _serde::__private::Result<Self, __D::Error>
                    where
                        __D: _serde::Deserializer<'de>,
                    {
                        _serde::Deserializer::deserialize_identifier(
                            __deserializer,
                            __FieldVisitor,
                        )
                    }
                }
                struct __Visitor<'de> {
                    marker: _serde::__private::PhantomData<Cw20ExecuteMsg>,
                    lifetime: _serde::__private::PhantomData<&'de ()>,
                }
                impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
                    type Value = Cw20ExecuteMsg;
                    fn expecting(
                        &self,
                        __formatter: &mut _serde::__private::Formatter,
                    ) -> _serde::__private::fmt::Result {
                        _serde::__private::Formatter::write_str(
                            __formatter,
                            "enum Cw20ExecuteMsg",
                        )
                    }
                    fn visit_enum<__A>(
                        self,
                        __data: __A,
                    ) -> _serde::__private::Result<Self::Value, __A::Error>
                    where
                        __A: _serde::de::EnumAccess<'de>,
                    {
                        match match _serde::de::EnumAccess::variant(__data) {
                            _serde::__private::Ok(__val) => __val,
                            _serde::__private::Err(__err) => {
                                return _serde::__private::Err(__err);
                            }
                        } {
                            (__Field::__field0, __variant) => {
                                #[allow(non_camel_case_types)]
                                enum __Field {
                                    __field0,
                                    __field1,
                                }
                                struct __FieldVisitor;
                                impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
                                    type Value = __Field;
                                    fn expecting(
                                        &self,
                                        __formatter: &mut _serde::__private::Formatter,
                                    ) -> _serde::__private::fmt::Result {
                                        _serde::__private::Formatter::write_str(
                                            __formatter,
                                            "field identifier",
                                        )
                                    }
                                    fn visit_u64<__E>(
                                        self,
                                        __value: u64,
                                    ) -> _serde::__private::Result<Self::Value, __E>
                                    where
                                        __E: _serde::de::Error,
                                    {
                                        match __value {
                                            0u64 => _serde::__private::Ok(__Field::__field0),
                                            1u64 => _serde::__private::Ok(__Field::__field1),
                                            _ => {
                                                _serde::__private::Err(
                                                    _serde::de::Error::invalid_value(
                                                        _serde::de::Unexpected::Unsigned(__value),
                                                        &"field index 0 <= i < 2",
                                                    ),
                                                )
                                            }
                                        }
                                    }
                                    fn visit_str<__E>(
                                        self,
                                        __value: &str,
                                    ) -> _serde::__private::Result<Self::Value, __E>
                                    where
                                        __E: _serde::de::Error,
                                    {
                                        match __value {
                                            "recipient" => _serde::__private::Ok(__Field::__field0),
                                            "amount" => _serde::__private::Ok(__Field::__field1),
                                            _ => {
                                                _serde::__private::Err(
                                                    _serde::de::Error::unknown_field(__value, FIELDS),
                                                )
                                            }
                                        }
                                    }
                                    fn visit_bytes<__E>(
                                        self,
                                        __value: &[u8],
                                    ) -> _serde::__private::Result<Self::Value, __E>
                                    where
                                        __E: _serde::de::Error,
                                    {
                                        match __value {
                                            b"recipient" => _serde::__private::Ok(__Field::__field0),
                                            b"amount" => _serde::__private::Ok(__Field::__field1),
                                            _ => {
                                                let __value = &_serde::__private::from_utf8_lossy(__value);
                                                _serde::__private::Err(
                                                    _serde::de::Error::unknown_field(__value, FIELDS),
                                                )
                                            }
                                        }
                                    }
                                }
                                impl<'de> _serde::Deserialize<'de> for __Field {
                                    #[inline]
                                    fn deserialize<__D>(
                                        __deserializer: __D,
                                    ) -> _serde::__private::Result<Self, __D::Error>
                                    where
                                        __D: _serde::Deserializer<'de>,
                                    {
                                        _serde::Deserializer::deserialize_identifier(
                                            __deserializer,
                                            __FieldVisitor,
                                        )
                                    }
                                }
                                struct __Visitor<'de> {
                                    marker: _serde::__private::PhantomData<Cw20ExecuteMsg>,
                                    lifetime: _serde::__private::PhantomData<&'de ()>,
                                }
                                impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
                                    type Value = Cw20ExecuteMsg;
                                    fn expecting(
                                        &self,
                                        __formatter: &mut _serde::__private::Formatter,
                                    ) -> _serde::__private::fmt::Result {
                                        _serde::__private::Formatter::write_str(
                                            __formatter,
                                            "struct variant Cw20ExecuteMsg::Transfer",
                                        )
                                    }
                                    #[inline]
                                    fn visit_seq<__A>(
                                        self,
                                        mut __seq: __A,
                                    ) -> _serde::__private::Result<Self::Value, __A::Error>
                                    where
                                        __A: _serde::de::SeqAccess<'de>,
                                    {
                                        let __field0 = match match _serde::de::SeqAccess::next_element::<
                                            String,
                                        >(&mut __seq) {
                                            _serde::__private::Ok(__val) => __val,
                                            _serde::__private::Err(__err) => {
                                                return _serde::__private::Err(__err);
                                            }
                                        } {
                                            _serde::__private::Some(__value) => __value,
                                            _serde::__private::None => {
                                                return _serde::__private::Err(
                                                    _serde::de::Error::invalid_length(
                                                        0usize,
                                                        &"struct variant Cw20ExecuteMsg::Transfer with 2 elements",
                                                    ),
                                                );
                                            }
                                        };
                                        let __field1 = match match _serde::de::SeqAccess::next_element::<
                                            Uint128,
                                        >(&mut __seq) {
                                            _serde::__private::Ok(__val) => __val,
                                            _serde::__private::Err(__err) => {
                                                return _serde::__private::Err(__err);
                                            }
                                        } {
                                            _serde::__private::Some(__value) => __value,
                                            _serde::__private::None => {
                                                return _serde::__private::Err(
                                                    _serde::de::Error::invalid_length(
                                                        1usize,
                                                        &"struct variant Cw20ExecuteMsg::Transfer with 2 elements",
                                                    ),
                                                );
                                            }
                                        };
                                        _serde::__private::Ok(Cw20ExecuteMsg::Transfer {
                                            recipient: __field0,
                                            amount: __field1,
                                        })
                                    }
                                    #[inline]
                                    fn visit_map<__A>(
                                        self,
                                        mut __map: __A,
                                    ) -> _serde::__private::Result<Self::Value, __A::Error>
                                    where
                                        __A: _serde::de::MapAccess<'de>,
                                    {
                                        let mut __field0: _serde::__private::Option<String> = _serde::__private::None;
                                        let mut __field1: _serde::__private::Option<Uint128> = _serde::__private::None;
                                        while let _serde::__private::Some(__key)
                                            = match _serde::de::MapAccess::next_key::<
                                                __Field,
                                            >(&mut __map) {
                                                _serde::__private::Ok(__val) => __val,
                                                _serde::__private::Err(__err) => {
                                                    return _serde::__private::Err(__err);
                                                }
                                            } {
                                            match __key {
                                                __Field::__field0 => {
                                                    if _serde::__private::Option::is_some(&__field0) {
                                                        return _serde::__private::Err(
                                                            <__A::Error as _serde::de::Error>::duplicate_field(
                                                                "recipient",
                                                            ),
                                                        );
                                                    }
                                                    __field0 = _serde::__private::Some(
                                                        match _serde::de::MapAccess::next_value::<
                                                            String,
                                                        >(&mut __map) {
                                                            _serde::__private::Ok(__val) => __val,
                                                            _serde::__private::Err(__err) => {
                                                                return _serde::__private::Err(__err);
                                                            }
                                                        },
                                                    );
                                                }
                                                __Field::__field1 => {
                                                    if _serde::__private::Option::is_some(&__field1) {
                                                        return _serde::__private::Err(
                                                            <__A::Error as _serde::de::Error>::duplicate_field("amount"),
                                                        );
                                                    }
                                                    __field1 = _serde::__private::Some(
                                                        match _serde::de::MapAccess::next_value::<
                                                            Uint128,
                                                        >(&mut __map) {
                                                            _serde::__private::Ok(__val) => __val,
                                                            _serde::__private::Err(__err) => {
                                                                return _serde::__private::Err(__err);
                                                            }
                                                        },
                                                    );
                                                }
                                            }
                                        }
                                        let __field0 = match __field0 {
                                            _serde::__private::Some(__field0) => __field0,
                                            _serde::__private::None => {
                                                match _serde::__private::de::missing_field("recipient") {
                                                    _serde::__private::Ok(__val) => __val,
                                                    _serde::__private::Err(__err) => {
                                                        return _serde::__private::Err(__err);
                                                    }
                                                }
                                            }
                                        };
                                        let __field1 = match __field1 {
                                            _serde::__private::Some(__field1) => __field1,
                                            _serde::__private::None => {
                                                match _serde::__private::de::missing_field("amount") {
                                                    _serde::__private::Ok(__val) => __val,
                                                    _serde::__private::Err(__err) => {
                                                        return _serde::__private::Err(__err);
                                                    }
                                                }
                                            }
                                        };
                                        _serde::__private::Ok(Cw20ExecuteMsg::Transfer {
                                            recipient: __field0,
                                            amount: __field1,
                                        })
                                    }
                                }
                                const FIELDS: &'static [&'static str] = &[
                                    "recipient",
                                    "amount",
                                ];
                                _serde::de::VariantAccess::struct_variant(
                                    __variant,
                                    FIELDS,
                                    __Visitor {
                                        marker: _serde::__private::PhantomData::<Cw20ExecuteMsg>,
                                        lifetime: _serde::__private::PhantomData,
                                    },
                                )
                            }
                            (__Field::__field1, __variant) => {
                                #[allow(non_camel_case_types)]
                                enum __Field {
                                    __field0,
                                }
                                struct __FieldVisitor;
                                impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
                                    type Value = __Field;
                                    fn expecting(
                                        &self,
                                        __formatter: &mut _serde::__private::Formatter,
                                    ) -> _serde::__private::fmt::Result {
                                        _serde::__private::Formatter::write_str(
                                            __formatter,
                                            "field identifier",
                                        )
                                    }
                                    fn visit_u64<__E>(
                                        self,
                                        __value: u64,
                                    ) -> _serde::__private::Result<Self::Value, __E>
                                    where
                                        __E: _serde::de::Error,
                                    {
                                        match __value {
                                            0u64 => _serde::__private::Ok(__Field::__field0),
                                            _ => {
                                                _serde::__private::Err(
                                                    _serde::de::Error::invalid_value(
                                                        _serde::de::Unexpected::Unsigned(__value),
                                                        &"field index 0 <= i < 1",
                                                    ),
                                                )
                                            }
                                        }
                                    }
                                    fn visit_str<__E>(
                                        self,
                                        __value: &str,
                                    ) -> _serde::__private::Result<Self::Value, __E>
                                    where
                                        __E: _serde::de::Error,
                                    {
                                        match __value {
                                            "amount" => _serde::__private::Ok(__Field::__field0),
                                            _ => {
                                                _serde::__private::Err(
                                                    _serde::de::Error::unknown_field(__value, FIELDS),
                                                )
                                            }
                                        }
                                    }
                                    fn visit_bytes<__E>(
                                        self,
                                        __value: &[u8],
                                    ) -> _serde::__private::Result<Self::Value, __E>
                                    where
                                        __E: _serde::de::Error,
                                    {
                                        match __value {
                                            b"amount" => _serde::__private::Ok(__Field::__field0),
                                            _ => {
                                                let __value = &_serde::__private::from_utf8_lossy(__value);
                                                _serde::__private::Err(
                                                    _serde::de::Error::unknown_field(__value, FIELDS),
                                                )
                                            }
                                        }
                                    }
                                }
                                impl<'de> _serde::Deserialize<'de> for __Field {
                                    #[inline]
                                    fn deserialize<__D>(
                                        __deserializer: __D,
                                    ) -> _serde::__private::Result<Self, __D::Error>
                                    where
                                        __D: _serde::Deserializer<'de>,
                                    {
                                        _serde::Deserializer::deserialize_identifier(
                                            __deserializer,
                                            __FieldVisitor,
                                        )
                                    }
                                }
                                struct __Visitor<'de> {
                                    marker: _serde::__private::PhantomData<Cw20ExecuteMsg>,
                                    lifetime: _serde::__private::PhantomData<&'de ()>,
                                }
                                impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
                                    type Value = Cw20ExecuteMsg;
                                    fn expecting(
                                        &self,
                                        __formatter: &mut _serde::__private::Formatter,
                                    ) -> _serde::__private::fmt::Result {
                                        _serde::__private::Formatter::write_str(
                                            __formatter,
                                            "struct variant Cw20ExecuteMsg::Burn",
                                        )
                                    }
                                    #[inline]
                                    fn visit_seq<__A>(
                                        self,
                                        mut __seq: __A,
                                    ) -> _serde::__private::Result<Self::Value, __A::Error>
                                    where
                                        __A: _serde::de::SeqAccess<'de>,
                                    {
                                        let __field0 = match match _serde::de::SeqAccess::next_element::<
                                            Uint128,
                                        >(&mut __seq) {
                                            _serde::__private::Ok(__val) => __val,
                                            _serde::__private::Err(__err) => {
                                                return _serde::__private::Err(__err);
                                            }
                                        } {
                                            _serde::__private::Some(__value) => __value,
                                            _serde::__private::None => {
                                                return _serde::__private::Err(
                                                    _serde::de::Error::invalid_length(
                                                        0usize,
                                                        &"struct variant Cw20ExecuteMsg::Burn with 1 element",
                                                    ),
                                                );
                                            }
                                        };
                                        _serde::__private::Ok(Cw20ExecuteMsg::Burn {
                                            amount: __field0,
                                        })
                                    }
                                    #[inline]
                                    fn visit_map<__A>(
                                        self,
                                        mut __map: __A,
                                    ) -> _serde::__private::Result<Self::Value, __A::Error>
                                    where
                                        __A: _serde::de::MapAccess<'de>,
                                    {
                                        let mut __field0: _serde::__private::Option<Uint128> = _serde::__private::None;
                                        while let _serde::__private::Some(__key)
                                            = match _serde::de::MapAccess::next_key::<
                                                __Field,
                                            >(&mut __map) {
                                                _serde::__private::Ok(__val) => __val,
                                                _serde::__private::Err(__err) => {
                                                    return _serde::__private::Err(__err);
                                                }
                                            } {
                                            match __key {
                                                __Field::__field0 => {
                                                    if _serde::__private::Option::is_some(&__field0) {
                                                        return _serde::__private::Err(
                                                            <__A::Error as _serde::de::Error>::duplicate_field("amount"),
                                                        );
                                                    }
                                                    __field0 = _serde::__private::Some(
                                                        match _serde::de::MapAccess::next_value::<
                                                            Uint128,
                                                        >(&mut __map) {
                                                            _serde::__private::Ok(__val) => __val,
                                                            _serde::__private::Err(__err) => {
                                                                return _serde::__private::Err(__err);
                                                            }
                                                        },
                                                    );
                                                }
                                            }
                                        }
                                        let __field0 = match __field0 {
                                            _serde::__private::Some(__field0) => __field0,
                                            _serde::__private::None => {
                                                match _serde::__private::de::missing_field("amount") {
                                                    _serde::__private::Ok(__val) => __val,
                                                    _serde::__private::Err(__err) => {
                                                        return _serde::__private::Err(__err);
                                                    }
                                                }
                                            }
                                        };
                                        _serde::__private::Ok(Cw20ExecuteMsg::Burn {
                                            amount: __field0,
                                        })
                                    }
                                }
                                const FIELDS: &'static [&'static str] = &["amount"];
                                _serde::de::VariantAccess::struct_variant(
                                    __variant,
                                    FIELDS,
                                    __Visitor {
                                        marker: _serde::__private::PhantomData::<Cw20ExecuteMsg>,
                                        lifetime: _serde::__private::PhantomData,
                                    },
                                )
                            }
                            (__Field::__field2, __variant) => {
                                #[allow(non_camel_case_types)]
                                enum __Field {
                                    __field0,
                                    __field1,
                                    __field2,
                                }
                                struct __FieldVisitor;
                                impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
                                    type Value = __Field;
                                    fn expecting(
                                        &self,
                                        __formatter: &mut _serde::__private::Formatter,
                                    ) -> _serde::__private::fmt::Result {
                                        _serde::__private::Formatter::write_str(
                                            __formatter,
                                            "field identifier",
                                        )
                                    }
                                    fn visit_u64<__E>(
                                        self,
                                        __value: u64,
                                    ) -> _serde::__private::Result<Self::Value, __E>
                                    where
                                        __E: _serde::de::Error,
                                    {
                                        match __value {
                                            0u64 => _serde::__private::Ok(__Field::__field0),
                                            1u64 => _serde::__private::Ok(__Field::__field1),
                                            2u64 => _serde::__private::Ok(__Field::__field2),
                                            _ => {
                                                _serde::__private::Err(
                                                    _serde::de::Error::invalid_value(
                                                        _serde::de::Unexpected::Unsigned(__value),
                                                        &"field index 0 <= i < 3",
                                                    ),
                                                )
                                            }
                                        }
                                    }
                                    fn visit_str<__E>(
                                        self,
                                        __value: &str,
                                    ) -> _serde::__private::Result<Self::Value, __E>
                                    where
                                        __E: _serde::de::Error,
                                    {
                                        match __value {
                                            "contract" => _serde::__private::Ok(__Field::__field0),
                                            "amount" => _serde::__private::Ok(__Field::__field1),
                                            "msg" => _serde::__private::Ok(__Field::__field2),
                                            _ => {
                                                _serde::__private::Err(
                                                    _serde::de::Error::unknown_field(__value, FIELDS),
                                                )
                                            }
                                        }
                                    }
                                    fn visit_bytes<__E>(
                                        self,
                                        __value: &[u8],
                                    ) -> _serde::__private::Result<Self::Value, __E>
                                    where
                                        __E: _serde::de::Error,
                                    {
                                        match __value {
                                            b"contract" => _serde::__private::Ok(__Field::__field0),
                                            b"amount" => _serde::__private::Ok(__Field::__field1),
                                            b"msg" => _serde::__private::Ok(__Field::__field2),
                                            _ => {
                                                let __value = &_serde::__private::from_utf8_lossy(__value);
                                                _serde::__private::Err(
                                                    _serde::de::Error::unknown_field(__value, FIELDS),
                                                )
                                            }
                                        }
                                    }
                                }
                                impl<'de> _serde::Deserialize<'de> for __Field {
                                    #[inline]
                                    fn deserialize<__D>(
                                        __deserializer: __D,
                                    ) -> _serde::__private::Result<Self, __D::Error>
                                    where
                                        __D: _serde::Deserializer<'de>,
                                    {
                                        _serde::Deserializer::deserialize_identifier(
                                            __deserializer,
                                            __FieldVisitor,
                                        )
                                    }
                                }
                                struct __Visitor<'de> {
                                    marker: _serde::__private::PhantomData<Cw20ExecuteMsg>,
                                    lifetime: _serde::__private::PhantomData<&'de ()>,
                                }
                                impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
                                    type Value = Cw20ExecuteMsg;
                                    fn expecting(
                                        &self,
                                        __formatter: &mut _serde::__private::Formatter,
                                    ) -> _serde::__private::fmt::Result {
                                        _serde::__private::Formatter::write_str(
                                            __formatter,
                                            "struct variant Cw20ExecuteMsg::Send",
                                        )
                                    }
                                    #[inline]
                                    fn visit_seq<__A>(
                                        self,
                                        mut __seq: __A,
                                    ) -> _serde::__private::Result<Self::Value, __A::Error>
                                    where
                                        __A: _serde::de::SeqAccess<'de>,
                                    {
                                        let __field0 = match match _serde::de::SeqAccess::next_element::<
                                            String,
                                        >(&mut __seq) {
                                            _serde::__private::Ok(__val) => __val,
                                            _serde::__private::Err(__err) => {
                                                return _serde::__private::Err(__err);
                                            }
                                        } {
                                            _serde::__private::Some(__value) => __value,
                                            _serde::__private::None => {
                                                return _serde::__private::Err(
                                                    _serde::de::Error::invalid_length(
                                                        0usize,
                                                        &"struct variant Cw20ExecuteMsg::Send with 3 elements",
                                                    ),
                                                );
                                            }
                                        };
                                        let __field1 = match match _serde::de::SeqAccess::next_element::<
                                            Uint128,
                                        >(&mut __seq) {
                                            _serde::__private::Ok(__val) => __val,
                                            _serde::__private::Err(__err) => {
                                                return _serde::__private::Err(__err);
                                            }
                                        } {
                                            _serde::__private::Some(__value) => __value,
                                            _serde::__private::None => {
                                                return _serde::__private::Err(
                                                    _serde::de::Error::invalid_length(
                                                        1usize,
                                                        &"struct variant Cw20ExecuteMsg::Send with 3 elements",
                                                    ),
                                                );
                                            }
                                        };
                                        let __field2 = match match _serde::de::SeqAccess::next_element::<
                                            Binary,
                                        >(&mut __seq) {
                                            _serde::__private::Ok(__val) => __val,
                                            _serde::__private::Err(__err) => {
                                                return _serde::__private::Err(__err);
                                            }
                                        } {
                                            _serde::__private::Some(__value) => __value,
                                            _serde::__private::None => {
                                                return _serde::__private::Err(
                                                    _serde::de::Error::invalid_length(
                                                        2usize,
                                                        &"struct variant Cw20ExecuteMsg::Send with 3 elements",
                                                    ),
                                                );
                                            }
                                        };
                                        _serde::__private::Ok(Cw20ExecuteMsg::Send {
                                            contract: __field0,
                                            amount: __field1,
                                            msg: __field2,
                                        })
                                    }
                                    #[inline]
                                    fn visit_map<__A>(
                                        self,
                                        mut __map: __A,
                                    ) -> _serde::__private::Result<Self::Value, __A::Error>
                                    where
                                        __A: _serde::de::MapAccess<'de>,
                                    {
                                        let mut __field0: _serde::__private::Option<String> = _serde::__private::None;
                                        let mut __field1: _serde::__private::Option<Uint128> = _serde::__private::None;
                                        let mut __field2: _serde::__private::Option<Binary> = _serde::__private::None;
                                        while let _serde::__private::Some(__key)
                                            = match _serde::de::MapAccess::next_key::<
                                                __Field,
                                            >(&mut __map) {
                                                _serde::__private::Ok(__val) => __val,
                                                _serde::__private::Err(__err) => {
                                                    return _serde::__private::Err(__err);
                                                }
                                            } {
                                            match __key {
                                                __Field::__field0 => {
                                                    if _serde::__private::Option::is_some(&__field0) {
                                                        return _serde::__private::Err(
                                                            <__A::Error as _serde::de::Error>::duplicate_field(
                                                                "contract",
                                                            ),
                                                        );
                                                    }
                                                    __field0 = _serde::__private::Some(
                                                        match _serde::de::MapAccess::next_value::<
                                                            String,
                                                        >(&mut __map) {
                                                            _serde::__private::Ok(__val) => __val,
                                                            _serde::__private::Err(__err) => {
                                                                return _serde::__private::Err(__err);
                                                            }
                                                        },
                                                    );
                                                }
                                                __Field::__field1 => {
                                                    if _serde::__private::Option::is_some(&__field1) {
                                                        return _serde::__private::Err(
                                                            <__A::Error as _serde::de::Error>::duplicate_field("amount"),
                                                        );
                                                    }
                                                    __field1 = _serde::__private::Some(
                                                        match _serde::de::MapAccess::next_value::<
                                                            Uint128,
                                                        >(&mut __map) {
                                                            _serde::__private::Ok(__val) => __val,
                                                            _serde::__private::Err(__err) => {
                                                                return _serde::__private::Err(__err);
                                                            }
                                                        },
                                                    );
                                                }
                                                __Field::__field2 => {
                                                    if _serde::__private::Option::is_some(&__field2) {
                                                        return _serde::__private::Err(
                                                            <__A::Error as _serde::de::Error>::duplicate_field("msg"),
                                                        );
                                                    }
                                                    __field2 = _serde::__private::Some(
                                                        match _serde::de::MapAccess::next_value::<
                                                            Binary,
                                                        >(&mut __map) {
                                                            _serde::__private::Ok(__val) => __val,
                                                            _serde::__private::Err(__err) => {
                                                                return _serde::__private::Err(__err);
                                                            }
                                                        },
                                                    );
                                                }
                                            }
                                        }
                                        let __field0 = match __field0 {
                                            _serde::__private::Some(__field0) => __field0,
                                            _serde::__private::None => {
                                                match _serde::__private::de::missing_field("contract") {
                                                    _serde::__private::Ok(__val) => __val,
                                                    _serde::__private::Err(__err) => {
                                                        return _serde::__private::Err(__err);
                                                    }
                                                }
                                            }
                                        };
                                        let __field1 = match __field1 {
                                            _serde::__private::Some(__field1) => __field1,
                                            _serde::__private::None => {
                                                match _serde::__private::de::missing_field("amount") {
                                                    _serde::__private::Ok(__val) => __val,
                                                    _serde::__private::Err(__err) => {
                                                        return _serde::__private::Err(__err);
                                                    }
                                                }
                                            }
                                        };
                                        let __field2 = match __field2 {
                                            _serde::__private::Some(__field2) => __field2,
                                            _serde::__private::None => {
                                                match _serde::__private::de::missing_field("msg") {
                                                    _serde::__private::Ok(__val) => __val,
                                                    _serde::__private::Err(__err) => {
                                                        return _serde::__private::Err(__err);
                                                    }
                                                }
                                            }
                                        };
                                        _serde::__private::Ok(Cw20ExecuteMsg::Send {
                                            contract: __field0,
                                            amount: __field1,
                                            msg: __field2,
                                        })
                                    }
                                }
                                const FIELDS: &'static [&'static str] = &[
                                    "contract",
                                    "amount",
                                    "msg",
                                ];
                                _serde::de::VariantAccess::struct_variant(
                                    __variant,
                                    FIELDS,
                                    __Visitor {
                                        marker: _serde::__private::PhantomData::<Cw20ExecuteMsg>,
                                        lifetime: _serde::__private::PhantomData,
                                    },
                                )
                            }
                            (__Field::__field3, __variant) => {
                                #[allow(non_camel_case_types)]
                                enum __Field {
                                    __field0,
                                    __field1,
                                    __field2,
                                }
                                struct __FieldVisitor;
                                impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
                                    type Value = __Field;
                                    fn expecting(
                                        &self,
                                        __formatter: &mut _serde::__private::Formatter,
                                    ) -> _serde::__private::fmt::Result {
                                        _serde::__private::Formatter::write_str(
                                            __formatter,
                                            "field identifier",
                                        )
                                    }
                                    fn visit_u64<__E>(
                                        self,
                                        __value: u64,
                                    ) -> _serde::__private::Result<Self::Value, __E>
                                    where
                                        __E: _serde::de::Error,
                                    {
                                        match __value {
                                            0u64 => _serde::__private::Ok(__Field::__field0),
                                            1u64 => _serde::__private::Ok(__Field::__field1),
                                            2u64 => _serde::__private::Ok(__Field::__field2),
                                            _ => {
                                                _serde::__private::Err(
                                                    _serde::de::Error::invalid_value(
                                                        _serde::de::Unexpected::Unsigned(__value),
                                                        &"field index 0 <= i < 3",
                                                    ),
                                                )
                                            }
                                        }
                                    }
                                    fn visit_str<__E>(
                                        self,
                                        __value: &str,
                                    ) -> _serde::__private::Result<Self::Value, __E>
                                    where
                                        __E: _serde::de::Error,
                                    {
                                        match __value {
                                            "spender" => _serde::__private::Ok(__Field::__field0),
                                            "amount" => _serde::__private::Ok(__Field::__field1),
                                            "expires" => _serde::__private::Ok(__Field::__field2),
                                            _ => {
                                                _serde::__private::Err(
                                                    _serde::de::Error::unknown_field(__value, FIELDS),
                                                )
                                            }
                                        }
                                    }
                                    fn visit_bytes<__E>(
                                        self,
                                        __value: &[u8],
                                    ) -> _serde::__private::Result<Self::Value, __E>
                                    where
                                        __E: _serde::de::Error,
                                    {
                                        match __value {
                                            b"spender" => _serde::__private::Ok(__Field::__field0),
                                            b"amount" => _serde::__private::Ok(__Field::__field1),
                                            b"expires" => _serde::__private::Ok(__Field::__field2),
                                            _ => {
                                                let __value = &_serde::__private::from_utf8_lossy(__value);
                                                _serde::__private::Err(
                                                    _serde::de::Error::unknown_field(__value, FIELDS),
                                                )
                                            }
                                        }
                                    }
                                }
                                impl<'de> _serde::Deserialize<'de> for __Field {
                                    #[inline]
                                    fn deserialize<__D>(
                                        __deserializer: __D,
                                    ) -> _serde::__private::Result<Self, __D::Error>
                                    where
                                        __D: _serde::Deserializer<'de>,
                                    {
                                        _serde::Deserializer::deserialize_identifier(
                                            __deserializer,
                                            __FieldVisitor,
                                        )
                                    }
                                }
                                struct __Visitor<'de> {
                                    marker: _serde::__private::PhantomData<Cw20ExecuteMsg>,
                                    lifetime: _serde::__private::PhantomData<&'de ()>,
                                }
                                impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
                                    type Value = Cw20ExecuteMsg;
                                    fn expecting(
                                        &self,
                                        __formatter: &mut _serde::__private::Formatter,
                                    ) -> _serde::__private::fmt::Result {
                                        _serde::__private::Formatter::write_str(
                                            __formatter,
                                            "struct variant Cw20ExecuteMsg::IncreaseAllowance",
                                        )
                                    }
                                    #[inline]
                                    fn visit_seq<__A>(
                                        self,
                                        mut __seq: __A,
                                    ) -> _serde::__private::Result<Self::Value, __A::Error>
                                    where
                                        __A: _serde::de::SeqAccess<'de>,
                                    {
                                        let __field0 = match match _serde::de::SeqAccess::next_element::<
                                            String,
                                        >(&mut __seq) {
                                            _serde::__private::Ok(__val) => __val,
                                            _serde::__private::Err(__err) => {
                                                return _serde::__private::Err(__err);
                                            }
                                        } {
                                            _serde::__private::Some(__value) => __value,
                                            _serde::__private::None => {
                                                return _serde::__private::Err(
                                                    _serde::de::Error::invalid_length(
                                                        0usize,
                                                        &"struct variant Cw20ExecuteMsg::IncreaseAllowance with 3 elements",
                                                    ),
                                                );
                                            }
                                        };
                                        let __field1 = match match _serde::de::SeqAccess::next_element::<
                                            Uint128,
                                        >(&mut __seq) {
                                            _serde::__private::Ok(__val) => __val,
                                            _serde::__private::Err(__err) => {
                                                return _serde::__private::Err(__err);
                                            }
                                        } {
                                            _serde::__private::Some(__value) => __value,
                                            _serde::__private::None => {
                                                return _serde::__private::Err(
                                                    _serde::de::Error::invalid_length(
                                                        1usize,
                                                        &"struct variant Cw20ExecuteMsg::IncreaseAllowance with 3 elements",
                                                    ),
                                                );
                                            }
                                        };
                                        let __field2 = match match _serde::de::SeqAccess::next_element::<
                                            Option<Expiration>,
                                        >(&mut __seq) {
                                            _serde::__private::Ok(__val) => __val,
                                            _serde::__private::Err(__err) => {
                                                return _serde::__private::Err(__err);
                                            }
                                        } {
                                            _serde::__private::Some(__value) => __value,
                                            _serde::__private::None => {
                                                return _serde::__private::Err(
                                                    _serde::de::Error::invalid_length(
                                                        2usize,
                                                        &"struct variant Cw20ExecuteMsg::IncreaseAllowance with 3 elements",
                                                    ),
                                                );
                                            }
                                        };
                                        _serde::__private::Ok(Cw20ExecuteMsg::IncreaseAllowance {
                                            spender: __field0,
                                            amount: __field1,
                                            expires: __field2,
                                        })
                                    }
                                    #[inline]
                                    fn visit_map<__A>(
                                        self,
                                        mut __map: __A,
                                    ) -> _serde::__private::Result<Self::Value, __A::Error>
                                    where
                                        __A: _serde::de::MapAccess<'de>,
                                    {
                                        let mut __field0: _serde::__private::Option<String> = _serde::__private::None;
                                        let mut __field1: _serde::__private::Option<Uint128> = _serde::__private::None;
                                        let mut __field2: _serde::__private::Option<
                                            Option<Expiration>,
                                        > = _serde::__private::None;
                                        while let _serde::__private::Some(__key)
                                            = match _serde::de::MapAccess::next_key::<
                                                __Field,
                                            >(&mut __map) {
                                                _serde::__private::Ok(__val) => __val,
                                                _serde::__private::Err(__err) => {
                                                    return _serde::__private::Err(__err);
                                                }
                                            } {
                                            match __key {
                                                __Field::__field0 => {
                                                    if _serde::__private::Option::is_some(&__field0) {
                                                        return _serde::__private::Err(
                                                            <__A::Error as _serde::de::Error>::duplicate_field(
                                                                "spender",
                                                            ),
                                                        );
                                                    }
                                                    __field0 = _serde::__private::Some(
                                                        match _serde::de::MapAccess::next_value::<
                                                            String,
                                                        >(&mut __map) {
                                                            _serde::__private::Ok(__val) => __val,
                                                            _serde::__private::Err(__err) => {
                                                                return _serde::__private::Err(__err);
                                                            }
                                                        },
                                                    );
                                                }
                                                __Field::__field1 => {
                                                    if _serde::__private::Option::is_some(&__field1) {
                                                        return _serde::__private::Err(
                                                            <__A::Error as _serde::de::Error>::duplicate_field("amount"),
                                                        );
                                                    }
                                                    __field1 = _serde::__private::Some(
                                                        match _serde::de::MapAccess::next_value::<
                                                            Uint128,
                                                        >(&mut __map) {
                                                            _serde::__private::Ok(__val) => __val,
                                                            _serde::__private::Err(__err) => {
                                                                return _serde::__private::Err(__err);
                                                            }
                                                        },
                                                    );
                                                }
                                                __Field::__field2 => {
                                                    if _serde::__private::Option::is_some(&__field2) {
                                                        return _serde::__private::Err(
                                                            <__A::Error as _serde::de::Error>::duplicate_field(
                                                                "expires",
                                                            ),
                                                        );
                                                    }
                                                    __field2 = _serde::__private::Some(
                                                        match _serde::de::MapAccess::next_value::<
                                                            Option<Expiration>,
                                                        >(&mut __map) {
                                                            _serde::__private::Ok(__val) => __val,
                                                            _serde::__private::Err(__err) => {
                                                                return _serde::__private::Err(__err);
                                                            }
                                                        },
                                                    );
                                                }
                                            }
                                        }
                                        let __field0 = match __field0 {
                                            _serde::__private::Some(__field0) => __field0,
                                            _serde::__private::None => {
                                                match _serde::__private::de::missing_field("spender") {
                                                    _serde::__private::Ok(__val) => __val,
                                                    _serde::__private::Err(__err) => {
                                                        return _serde::__private::Err(__err);
                                                    }
                                                }
                                            }
                                        };
                                        let __field1 = match __field1 {
                                            _serde::__private::Some(__field1) => __field1,
                                            _serde::__private::None => {
                                                match _serde::__private::de::missing_field("amount") {
                                                    _serde::__private::Ok(__val) => __val,
                                                    _serde::__private::Err(__err) => {
                                                        return _serde::__private::Err(__err);
                                                    }
                                                }
                                            }
                                        };
                                        let __field2 = match __field2 {
                                            _serde::__private::Some(__field2) => __field2,
                                            _serde::__private::None => {
                                                match _serde::__private::de::missing_field("expires") {
                                                    _serde::__private::Ok(__val) => __val,
                                                    _serde::__private::Err(__err) => {
                                                        return _serde::__private::Err(__err);
                                                    }
                                                }
                                            }
                                        };
                                        _serde::__private::Ok(Cw20ExecuteMsg::IncreaseAllowance {
                                            spender: __field0,
                                            amount: __field1,
                                            expires: __field2,
                                        })
                                    }
                                }
                                const FIELDS: &'static [&'static str] = &[
                                    "spender",
                                    "amount",
                                    "expires",
                                ];
                                _serde::de::VariantAccess::struct_variant(
                                    __variant,
                                    FIELDS,
                                    __Visitor {
                                        marker: _serde::__private::PhantomData::<Cw20ExecuteMsg>,
                                        lifetime: _serde::__private::PhantomData,
                                    },
                                )
                            }
                            (__Field::__field4, __variant) => {
                                #[allow(non_camel_case_types)]
                                enum __Field {
                                    __field0,
                                    __field1,
                                    __field2,
                                }
                                struct __FieldVisitor;
                                impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
                                    type Value = __Field;
                                    fn expecting(
                                        &self,
                                        __formatter: &mut _serde::__private::Formatter,
                                    ) -> _serde::__private::fmt::Result {
                                        _serde::__private::Formatter::write_str(
                                            __formatter,
                                            "field identifier",
                                        )
                                    }
                                    fn visit_u64<__E>(
                                        self,
                                        __value: u64,
                                    ) -> _serde::__private::Result<Self::Value, __E>
                                    where
                                        __E: _serde::de::Error,
                                    {
                                        match __value {
                                            0u64 => _serde::__private::Ok(__Field::__field0),
                                            1u64 => _serde::__private::Ok(__Field::__field1),
                                            2u64 => _serde::__private::Ok(__Field::__field2),
                                            _ => {
                                                _serde::__private::Err(
                                                    _serde::de::Error::invalid_value(
                                                        _serde::de::Unexpected::Unsigned(__value),
                                                        &"field index 0 <= i < 3",
                                                    ),
                                                )
                                            }
                                        }
                                    }
                                    fn visit_str<__E>(
                                        self,
                                        __value: &str,
                                    ) -> _serde::__private::Result<Self::Value, __E>
                                    where
                                        __E: _serde::de::Error,
                                    {
                                        match __value {
                                            "spender" => _serde::__private::Ok(__Field::__field0),
                                            "amount" => _serde::__private::Ok(__Field::__field1),
                                            "expires" => _serde::__private::Ok(__Field::__field2),
                                            _ => {
                                                _serde::__private::Err(
                                                    _serde::de::Error::unknown_field(__value, FIELDS),
                                                )
                                            }
                                        }
                                    }
                                    fn visit_bytes<__E>(
                                        self,
                                        __value: &[u8],
                                    ) -> _serde::__private::Result<Self::Value, __E>
                                    where
                                        __E: _serde::de::Error,
                                    {
                                        match __value {
                                            b"spender" => _serde::__private::Ok(__Field::__field0),
                                            b"amount" => _serde::__private::Ok(__Field::__field1),
                                            b"expires" => _serde::__private::Ok(__Field::__field2),
                                            _ => {
                                                let __value = &_serde::__private::from_utf8_lossy(__value);
                                                _serde::__private::Err(
                                                    _serde::de::Error::unknown_field(__value, FIELDS),
                                                )
                                            }
                                        }
                                    }
                                }
                                impl<'de> _serde::Deserialize<'de> for __Field {
                                    #[inline]
                                    fn deserialize<__D>(
                                        __deserializer: __D,
                                    ) -> _serde::__private::Result<Self, __D::Error>
                                    where
                                        __D: _serde::Deserializer<'de>,
                                    {
                                        _serde::Deserializer::deserialize_identifier(
                                            __deserializer,
                                            __FieldVisitor,
                                        )
                                    }
                                }
                                struct __Visitor<'de> {
                                    marker: _serde::__private::PhantomData<Cw20ExecuteMsg>,
                                    lifetime: _serde::__private::PhantomData<&'de ()>,
                                }
                                impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
                                    type Value = Cw20ExecuteMsg;
                                    fn expecting(
                                        &self,
                                        __formatter: &mut _serde::__private::Formatter,
                                    ) -> _serde::__private::fmt::Result {
                                        _serde::__private::Formatter::write_str(
                                            __formatter,
                                            "struct variant Cw20ExecuteMsg::DecreaseAllowance",
                                        )
                                    }
                                    #[inline]
                                    fn visit_seq<__A>(
                                        self,
                                        mut __seq: __A,
                                    ) -> _serde::__private::Result<Self::Value, __A::Error>
                                    where
                                        __A: _serde::de::SeqAccess<'de>,
                                    {
                                        let __field0 = match match _serde::de::SeqAccess::next_element::<
                                            String,
                                        >(&mut __seq) {
                                            _serde::__private::Ok(__val) => __val,
                                            _serde::__private::Err(__err) => {
                                                return _serde::__private::Err(__err);
                                            }
                                        } {
                                            _serde::__private::Some(__value) => __value,
                                            _serde::__private::None => {
                                                return _serde::__private::Err(
                                                    _serde::de::Error::invalid_length(
                                                        0usize,
                                                        &"struct variant Cw20ExecuteMsg::DecreaseAllowance with 3 elements",
                                                    ),
                                                );
                                            }
                                        };
                                        let __field1 = match match _serde::de::SeqAccess::next_element::<
                                            Uint128,
                                        >(&mut __seq) {
                                            _serde::__private::Ok(__val) => __val,
                                            _serde::__private::Err(__err) => {
                                                return _serde::__private::Err(__err);
                                            }
                                        } {
                                            _serde::__private::Some(__value) => __value,
                                            _serde::__private::None => {
                                                return _serde::__private::Err(
                                                    _serde::de::Error::invalid_length(
                                                        1usize,
                                                        &"struct variant Cw20ExecuteMsg::DecreaseAllowance with 3 elements",
                                                    ),
                                                );
                                            }
                                        };
                                        let __field2 = match match _serde::de::SeqAccess::next_element::<
                                            Option<Expiration>,
                                        >(&mut __seq) {
                                            _serde::__private::Ok(__val) => __val,
                                            _serde::__private::Err(__err) => {
                                                return _serde::__private::Err(__err);
                                            }
                                        } {
                                            _serde::__private::Some(__value) => __value,
                                            _serde::__private::None => {
                                                return _serde::__private::Err(
                                                    _serde::de::Error::invalid_length(
                                                        2usize,
                                                        &"struct variant Cw20ExecuteMsg::DecreaseAllowance with 3 elements",
                                                    ),
                                                );
                                            }
                                        };
                                        _serde::__private::Ok(Cw20ExecuteMsg::DecreaseAllowance {
                                            spender: __field0,
                                            amount: __field1,
                                            expires: __field2,
                                        })
                                    }
                                    #[inline]
                                    fn visit_map<__A>(
                                        self,
                                        mut __map: __A,
                                    ) -> _serde::__private::Result<Self::Value, __A::Error>
                                    where
                                        __A: _serde::de::MapAccess<'de>,
                                    {
                                        let mut __field0: _serde::__private::Option<String> = _serde::__private::None;
                                        let mut __field1: _serde::__private::Option<Uint128> = _serde::__private::None;
                                        let mut __field2: _serde::__private::Option<
                                            Option<Expiration>,
                                        > = _serde::__private::None;
                                        while let _serde::__private::Some(__key)
                                            = match _serde::de::MapAccess::next_key::<
                                                __Field,
                                            >(&mut __map) {
                                                _serde::__private::Ok(__val) => __val,
                                                _serde::__private::Err(__err) => {
                                                    return _serde::__private::Err(__err);
                                                }
                                            } {
                                            match __key {
                                                __Field::__field0 => {
                                                    if _serde::__private::Option::is_some(&__field0) {
                                                        return _serde::__private::Err(
                                                            <__A::Error as _serde::de::Error>::duplicate_field(
                                                                "spender",
                                                            ),
                                                        );
                                                    }
                                                    __field0 = _serde::__private::Some(
                                                        match _serde::de::MapAccess::next_value::<
                                                            String,
                                                        >(&mut __map) {
                                                            _serde::__private::Ok(__val) => __val,
                                                            _serde::__private::Err(__err) => {
                                                                return _serde::__private::Err(__err);
                                                            }
                                                        },
                                                    );
                                                }
                                                __Field::__field1 => {
                                                    if _serde::__private::Option::is_some(&__field1) {
                                                        return _serde::__private::Err(
                                                            <__A::Error as _serde::de::Error>::duplicate_field("amount"),
                                                        );
                                                    }
                                                    __field1 = _serde::__private::Some(
                                                        match _serde::de::MapAccess::next_value::<
                                                            Uint128,
                                                        >(&mut __map) {
                                                            _serde::__private::Ok(__val) => __val,
                                                            _serde::__private::Err(__err) => {
                                                                return _serde::__private::Err(__err);
                                                            }
                                                        },
                                                    );
                                                }
                                                __Field::__field2 => {
                                                    if _serde::__private::Option::is_some(&__field2) {
                                                        return _serde::__private::Err(
                                                            <__A::Error as _serde::de::Error>::duplicate_field(
                                                                "expires",
                                                            ),
                                                        );
                                                    }
                                                    __field2 = _serde::__private::Some(
                                                        match _serde::de::MapAccess::next_value::<
                                                            Option<Expiration>,
                                                        >(&mut __map) {
                                                            _serde::__private::Ok(__val) => __val,
                                                            _serde::__private::Err(__err) => {
                                                                return _serde::__private::Err(__err);
                                                            }
                                                        },
                                                    );
                                                }
                                            }
                                        }
                                        let __field0 = match __field0 {
                                            _serde::__private::Some(__field0) => __field0,
                                            _serde::__private::None => {
                                                match _serde::__private::de::missing_field("spender") {
                                                    _serde::__private::Ok(__val) => __val,
                                                    _serde::__private::Err(__err) => {
                                                        return _serde::__private::Err(__err);
                                                    }
                                                }
                                            }
                                        };
                                        let __field1 = match __field1 {
                                            _serde::__private::Some(__field1) => __field1,
                                            _serde::__private::None => {
                                                match _serde::__private::de::missing_field("amount") {
                                                    _serde::__private::Ok(__val) => __val,
                                                    _serde::__private::Err(__err) => {
                                                        return _serde::__private::Err(__err);
                                                    }
                                                }
                                            }
                                        };
                                        let __field2 = match __field2 {
                                            _serde::__private::Some(__field2) => __field2,
                                            _serde::__private::None => {
                                                match _serde::__private::de::missing_field("expires") {
                                                    _serde::__private::Ok(__val) => __val,
                                                    _serde::__private::Err(__err) => {
                                                        return _serde::__private::Err(__err);
                                                    }
                                                }
                                            }
                                        };
                                        _serde::__private::Ok(Cw20ExecuteMsg::DecreaseAllowance {
                                            spender: __field0,
                                            amount: __field1,
                                            expires: __field2,
                                        })
                                    }
                                }
                                const FIELDS: &'static [&'static str] = &[
                                    "spender",
                                    "amount",
                                    "expires",
                                ];
                                _serde::de::VariantAccess::struct_variant(
                                    __variant,
                                    FIELDS,
                                    __Visitor {
                                        marker: _serde::__private::PhantomData::<Cw20ExecuteMsg>,
                                        lifetime: _serde::__private::PhantomData,
                                    },
                                )
                            }
                            (__Field::__field5, __variant) => {
                                #[allow(non_camel_case_types)]
                                enum __Field {
                                    __field0,
                                    __field1,
                                    __field2,
                                }
                                struct __FieldVisitor;
                                impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
                                    type Value = __Field;
                                    fn expecting(
                                        &self,
                                        __formatter: &mut _serde::__private::Formatter,
                                    ) -> _serde::__private::fmt::Result {
                                        _serde::__private::Formatter::write_str(
                                            __formatter,
                                            "field identifier",
                                        )
                                    }
                                    fn visit_u64<__E>(
                                        self,
                                        __value: u64,
                                    ) -> _serde::__private::Result<Self::Value, __E>
                                    where
                                        __E: _serde::de::Error,
                                    {
                                        match __value {
                                            0u64 => _serde::__private::Ok(__Field::__field0),
                                            1u64 => _serde::__private::Ok(__Field::__field1),
                                            2u64 => _serde::__private::Ok(__Field::__field2),
                                            _ => {
                                                _serde::__private::Err(
                                                    _serde::de::Error::invalid_value(
                                                        _serde::de::Unexpected::Unsigned(__value),
                                                        &"field index 0 <= i < 3",
                                                    ),
                                                )
                                            }
                                        }
                                    }
                                    fn visit_str<__E>(
                                        self,
                                        __value: &str,
                                    ) -> _serde::__private::Result<Self::Value, __E>
                                    where
                                        __E: _serde::de::Error,
                                    {
                                        match __value {
                                            "owner" => _serde::__private::Ok(__Field::__field0),
                                            "recipient" => _serde::__private::Ok(__Field::__field1),
                                            "amount" => _serde::__private::Ok(__Field::__field2),
                                            _ => {
                                                _serde::__private::Err(
                                                    _serde::de::Error::unknown_field(__value, FIELDS),
                                                )
                                            }
                                        }
                                    }
                                    fn visit_bytes<__E>(
                                        self,
                                        __value: &[u8],
                                    ) -> _serde::__private::Result<Self::Value, __E>
                                    where
                                        __E: _serde::de::Error,
                                    {
                                        match __value {
                                            b"owner" => _serde::__private::Ok(__Field::__field0),
                                            b"recipient" => _serde::__private::Ok(__Field::__field1),
                                            b"amount" => _serde::__private::Ok(__Field::__field2),
                                            _ => {
                                                let __value = &_serde::__private::from_utf8_lossy(__value);
                                                _serde::__private::Err(
                                                    _serde::de::Error::unknown_field(__value, FIELDS),
                                                )
                                            }
                                        }
                                    }
                                }
                                impl<'de> _serde::Deserialize<'de> for __Field {
                                    #[inline]
                                    fn deserialize<__D>(
                                        __deserializer: __D,
                                    ) -> _serde::__private::Result<Self, __D::Error>
                                    where
                                        __D: _serde::Deserializer<'de>,
                                    {
                                        _serde::Deserializer::deserialize_identifier(
                                            __deserializer,
                                            __FieldVisitor,
                                        )
                                    }
                                }
                                struct __Visitor<'de> {
                                    marker: _serde::__private::PhantomData<Cw20ExecuteMsg>,
                                    lifetime: _serde::__private::PhantomData<&'de ()>,
                                }
                                impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
                                    type Value = Cw20ExecuteMsg;
                                    fn expecting(
                                        &self,
                                        __formatter: &mut _serde::__private::Formatter,
                                    ) -> _serde::__private::fmt::Result {
                                        _serde::__private::Formatter::write_str(
                                            __formatter,
                                            "struct variant Cw20ExecuteMsg::TransferFrom",
                                        )
                                    }
                                    #[inline]
                                    fn visit_seq<__A>(
                                        self,
                                        mut __seq: __A,
                                    ) -> _serde::__private::Result<Self::Value, __A::Error>
                                    where
                                        __A: _serde::de::SeqAccess<'de>,
                                    {
                                        let __field0 = match match _serde::de::SeqAccess::next_element::<
                                            String,
                                        >(&mut __seq) {
                                            _serde::__private::Ok(__val) => __val,
                                            _serde::__private::Err(__err) => {
                                                return _serde::__private::Err(__err);
                                            }
                                        } {
                                            _serde::__private::Some(__value) => __value,
                                            _serde::__private::None => {
                                                return _serde::__private::Err(
                                                    _serde::de::Error::invalid_length(
                                                        0usize,
                                                        &"struct variant Cw20ExecuteMsg::TransferFrom with 3 elements",
                                                    ),
                                                );
                                            }
                                        };
                                        let __field1 = match match _serde::de::SeqAccess::next_element::<
                                            String,
                                        >(&mut __seq) {
                                            _serde::__private::Ok(__val) => __val,
                                            _serde::__private::Err(__err) => {
                                                return _serde::__private::Err(__err);
                                            }
                                        } {
                                            _serde::__private::Some(__value) => __value,
                                            _serde::__private::None => {
                                                return _serde::__private::Err(
                                                    _serde::de::Error::invalid_length(
                                                        1usize,
                                                        &"struct variant Cw20ExecuteMsg::TransferFrom with 3 elements",
                                                    ),
                                                );
                                            }
                                        };
                                        let __field2 = match match _serde::de::SeqAccess::next_element::<
                                            Uint128,
                                        >(&mut __seq) {
                                            _serde::__private::Ok(__val) => __val,
                                            _serde::__private::Err(__err) => {
                                                return _serde::__private::Err(__err);
                                            }
                                        } {
                                            _serde::__private::Some(__value) => __value,
                                            _serde::__private::None => {
                                                return _serde::__private::Err(
                                                    _serde::de::Error::invalid_length(
                                                        2usize,
                                                        &"struct variant Cw20ExecuteMsg::TransferFrom with 3 elements",
                                                    ),
                                                );
                                            }
                                        };
                                        _serde::__private::Ok(Cw20ExecuteMsg::TransferFrom {
                                            owner: __field0,
                                            recipient: __field1,
                                            amount: __field2,
                                        })
                                    }
                                    #[inline]
                                    fn visit_map<__A>(
                                        self,
                                        mut __map: __A,
                                    ) -> _serde::__private::Result<Self::Value, __A::Error>
                                    where
                                        __A: _serde::de::MapAccess<'de>,
                                    {
                                        let mut __field0: _serde::__private::Option<String> = _serde::__private::None;
                                        let mut __field1: _serde::__private::Option<String> = _serde::__private::None;
                                        let mut __field2: _serde::__private::Option<Uint128> = _serde::__private::None;
                                        while let _serde::__private::Some(__key)
                                            = match _serde::de::MapAccess::next_key::<
                                                __Field,
                                            >(&mut __map) {
                                                _serde::__private::Ok(__val) => __val,
                                                _serde::__private::Err(__err) => {
                                                    return _serde::__private::Err(__err);
                                                }
                                            } {
                                            match __key {
                                                __Field::__field0 => {
                                                    if _serde::__private::Option::is_some(&__field0) {
                                                        return _serde::__private::Err(
                                                            <__A::Error as _serde::de::Error>::duplicate_field("owner"),
                                                        );
                                                    }
                                                    __field0 = _serde::__private::Some(
                                                        match _serde::de::MapAccess::next_value::<
                                                            String,
                                                        >(&mut __map) {
                                                            _serde::__private::Ok(__val) => __val,
                                                            _serde::__private::Err(__err) => {
                                                                return _serde::__private::Err(__err);
                                                            }
                                                        },
                                                    );
                                                }
                                                __Field::__field1 => {
                                                    if _serde::__private::Option::is_some(&__field1) {
                                                        return _serde::__private::Err(
                                                            <__A::Error as _serde::de::Error>::duplicate_field(
                                                                "recipient",
                                                            ),
                                                        );
                                                    }
                                                    __field1 = _serde::__private::Some(
                                                        match _serde::de::MapAccess::next_value::<
                                                            String,
                                                        >(&mut __map) {
                                                            _serde::__private::Ok(__val) => __val,
                                                            _serde::__private::Err(__err) => {
                                                                return _serde::__private::Err(__err);
                                                            }
                                                        },
                                                    );
                                                }
                                                __Field::__field2 => {
                                                    if _serde::__private::Option::is_some(&__field2) {
                                                        return _serde::__private::Err(
                                                            <__A::Error as _serde::de::Error>::duplicate_field("amount"),
                                                        );
                                                    }
                                                    __field2 = _serde::__private::Some(
                                                        match _serde::de::MapAccess::next_value::<
                                                            Uint128,
                                                        >(&mut __map) {
                                                            _serde::__private::Ok(__val) => __val,
                                                            _serde::__private::Err(__err) => {
                                                                return _serde::__private::Err(__err);
                                                            }
                                                        },
                                                    );
                                                }
                                            }
                                        }
                                        let __field0 = match __field0 {
                                            _serde::__private::Some(__field0) => __field0,
                                            _serde::__private::None => {
                                                match _serde::__private::de::missing_field("owner") {
                                                    _serde::__private::Ok(__val) => __val,
                                                    _serde::__private::Err(__err) => {
                                                        return _serde::__private::Err(__err);
                                                    }
                                                }
                                            }
                                        };
                                        let __field1 = match __field1 {
                                            _serde::__private::Some(__field1) => __field1,
                                            _serde::__private::None => {
                                                match _serde::__private::de::missing_field("recipient") {
                                                    _serde::__private::Ok(__val) => __val,
                                                    _serde::__private::Err(__err) => {
                                                        return _serde::__private::Err(__err);
                                                    }
                                                }
                                            }
                                        };
                                        let __field2 = match __field2 {
                                            _serde::__private::Some(__field2) => __field2,
                                            _serde::__private::None => {
                                                match _serde::__private::de::missing_field("amount") {
                                                    _serde::__private::Ok(__val) => __val,
                                                    _serde::__private::Err(__err) => {
                                                        return _serde::__private::Err(__err);
                                                    }
                                                }
                                            }
                                        };
                                        _serde::__private::Ok(Cw20ExecuteMsg::TransferFrom {
                                            owner: __field0,
                                            recipient: __field1,
                                            amount: __field2,
                                        })
                                    }
                                }
                                const FIELDS: &'static [&'static str] = &[
                                    "owner",
                                    "recipient",
                                    "amount",
                                ];
                                _serde::de::VariantAccess::struct_variant(
                                    __variant,
                                    FIELDS,
                                    __Visitor {
                                        marker: _serde::__private::PhantomData::<Cw20ExecuteMsg>,
                                        lifetime: _serde::__private::PhantomData,
                                    },
                                )
                            }
                            (__Field::__field6, __variant) => {
                                #[allow(non_camel_case_types)]
                                enum __Field {
                                    __field0,
                                    __field1,
                                    __field2,
                                    __field3,
                                }
                                struct __FieldVisitor;
                                impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
                                    type Value = __Field;
                                    fn expecting(
                                        &self,
                                        __formatter: &mut _serde::__private::Formatter,
                                    ) -> _serde::__private::fmt::Result {
                                        _serde::__private::Formatter::write_str(
                                            __formatter,
                                            "field identifier",
                                        )
                                    }
                                    fn visit_u64<__E>(
                                        self,
                                        __value: u64,
                                    ) -> _serde::__private::Result<Self::Value, __E>
                                    where
                                        __E: _serde::de::Error,
                                    {
                                        match __value {
                                            0u64 => _serde::__private::Ok(__Field::__field0),
                                            1u64 => _serde::__private::Ok(__Field::__field1),
                                            2u64 => _serde::__private::Ok(__Field::__field2),
                                            3u64 => _serde::__private::Ok(__Field::__field3),
                                            _ => {
                                                _serde::__private::Err(
                                                    _serde::de::Error::invalid_value(
                                                        _serde::de::Unexpected::Unsigned(__value),
                                                        &"field index 0 <= i < 4",
                                                    ),
                                                )
                                            }
                                        }
                                    }
                                    fn visit_str<__E>(
                                        self,
                                        __value: &str,
                                    ) -> _serde::__private::Result<Self::Value, __E>
                                    where
                                        __E: _serde::de::Error,
                                    {
                                        match __value {
                                            "owner" => _serde::__private::Ok(__Field::__field0),
                                            "contract" => _serde::__private::Ok(__Field::__field1),
                                            "amount" => _serde::__private::Ok(__Field::__field2),
                                            "msg" => _serde::__private::Ok(__Field::__field3),
                                            _ => {
                                                _serde::__private::Err(
                                                    _serde::de::Error::unknown_field(__value, FIELDS),
                                                )
                                            }
                                        }
                                    }
                                    fn visit_bytes<__E>(
                                        self,
                                        __value: &[u8],
                                    ) -> _serde::__private::Result<Self::Value, __E>
                                    where
                                        __E: _serde::de::Error,
                                    {
                                        match __value {
                                            b"owner" => _serde::__private::Ok(__Field::__field0),
                                            b"contract" => _serde::__private::Ok(__Field::__field1),
                                            b"amount" => _serde::__private::Ok(__Field::__field2),
                                            b"msg" => _serde::__private::Ok(__Field::__field3),
                                            _ => {
                                                let __value = &_serde::__private::from_utf8_lossy(__value);
                                                _serde::__private::Err(
                                                    _serde::de::Error::unknown_field(__value, FIELDS),
                                                )
                                            }
                                        }
                                    }
                                }
                                impl<'de> _serde::Deserialize<'de> for __Field {
                                    #[inline]
                                    fn deserialize<__D>(
                                        __deserializer: __D,
                                    ) -> _serde::__private::Result<Self, __D::Error>
                                    where
                                        __D: _serde::Deserializer<'de>,
                                    {
                                        _serde::Deserializer::deserialize_identifier(
                                            __deserializer,
                                            __FieldVisitor,
                                        )
                                    }
                                }
                                struct __Visitor<'de> {
                                    marker: _serde::__private::PhantomData<Cw20ExecuteMsg>,
                                    lifetime: _serde::__private::PhantomData<&'de ()>,
                                }
                                impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
                                    type Value = Cw20ExecuteMsg;
                                    fn expecting(
                                        &self,
                                        __formatter: &mut _serde::__private::Formatter,
                                    ) -> _serde::__private::fmt::Result {
                                        _serde::__private::Formatter::write_str(
                                            __formatter,
                                            "struct variant Cw20ExecuteMsg::SendFrom",
                                        )
                                    }
                                    #[inline]
                                    fn visit_seq<__A>(
                                        self,
                                        mut __seq: __A,
                                    ) -> _serde::__private::Result<Self::Value, __A::Error>
                                    where
                                        __A: _serde::de::SeqAccess<'de>,
                                    {
                                        let __field0 = match match _serde::de::SeqAccess::next_element::<
                                            String,
                                        >(&mut __seq) {
                                            _serde::__private::Ok(__val) => __val,
                                            _serde::__private::Err(__err) => {
                                                return _serde::__private::Err(__err);
                                            }
                                        } {
                                            _serde::__private::Some(__value) => __value,
                                            _serde::__private::None => {
                                                return _serde::__private::Err(
                                                    _serde::de::Error::invalid_length(
                                                        0usize,
                                                        &"struct variant Cw20ExecuteMsg::SendFrom with 4 elements",
                                                    ),
                                                );
                                            }
                                        };
                                        let __field1 = match match _serde::de::SeqAccess::next_element::<
                                            String,
                                        >(&mut __seq) {
                                            _serde::__private::Ok(__val) => __val,
                                            _serde::__private::Err(__err) => {
                                                return _serde::__private::Err(__err);
                                            }
                                        } {
                                            _serde::__private::Some(__value) => __value,
                                            _serde::__private::None => {
                                                return _serde::__private::Err(
                                                    _serde::de::Error::invalid_length(
                                                        1usize,
                                                        &"struct variant Cw20ExecuteMsg::SendFrom with 4 elements",
                                                    ),
                                                );
                                            }
                                        };
                                        let __field2 = match match _serde::de::SeqAccess::next_element::<
                                            Uint128,
                                        >(&mut __seq) {
                                            _serde::__private::Ok(__val) => __val,
                                            _serde::__private::Err(__err) => {
                                                return _serde::__private::Err(__err);
                                            }
                                        } {
                                            _serde::__private::Some(__value) => __value,
                                            _serde::__private::None => {
                                                return _serde::__private::Err(
                                                    _serde::de::Error::invalid_length(
                                                        2usize,
                                                        &"struct variant Cw20ExecuteMsg::SendFrom with 4 elements",
                                                    ),
                                                );
                                            }
                                        };
                                        let __field3 = match match _serde::de::SeqAccess::next_element::<
                                            Binary,
                                        >(&mut __seq) {
                                            _serde::__private::Ok(__val) => __val,
                                            _serde::__private::Err(__err) => {
                                                return _serde::__private::Err(__err);
                                            }
                                        } {
                                            _serde::__private::Some(__value) => __value,
                                            _serde::__private::None => {
                                                return _serde::__private::Err(
                                                    _serde::de::Error::invalid_length(
                                                        3usize,
                                                        &"struct variant Cw20ExecuteMsg::SendFrom with 4 elements",
                                                    ),
                                                );
                                            }
                                        };
                                        _serde::__private::Ok(Cw20ExecuteMsg::SendFrom {
                                            owner: __field0,
                                            contract: __field1,
                                            amount: __field2,
                                            msg: __field3,
                                        })
                                    }
                                    #[inline]
                                    fn visit_map<__A>(
                                        self,
                                        mut __map: __A,
                                    ) -> _serde::__private::Result<Self::Value, __A::Error>
                                    where
                                        __A: _serde::de::MapAccess<'de>,
                                    {
                                        let mut __field0: _serde::__private::Option<String> = _serde::__private::None;
                                        let mut __field1: _serde::__private::Option<String> = _serde::__private::None;
                                        let mut __field2: _serde::__private::Option<Uint128> = _serde::__private::None;
                                        let mut __field3: _serde::__private::Option<Binary> = _serde::__private::None;
                                        while let _serde::__private::Some(__key)
                                            = match _serde::de::MapAccess::next_key::<
                                                __Field,
                                            >(&mut __map) {
                                                _serde::__private::Ok(__val) => __val,
                                                _serde::__private::Err(__err) => {
                                                    return _serde::__private::Err(__err);
                                                }
                                            } {
                                            match __key {
                                                __Field::__field0 => {
                                                    if _serde::__private::Option::is_some(&__field0) {
                                                        return _serde::__private::Err(
                                                            <__A::Error as _serde::de::Error>::duplicate_field("owner"),
                                                        );
                                                    }
                                                    __field0 = _serde::__private::Some(
                                                        match _serde::de::MapAccess::next_value::<
                                                            String,
                                                        >(&mut __map) {
                                                            _serde::__private::Ok(__val) => __val,
                                                            _serde::__private::Err(__err) => {
                                                                return _serde::__private::Err(__err);
                                                            }
                                                        },
                                                    );
                                                }
                                                __Field::__field1 => {
                                                    if _serde::__private::Option::is_some(&__field1) {
                                                        return _serde::__private::Err(
                                                            <__A::Error as _serde::de::Error>::duplicate_field(
                                                                "contract",
                                                            ),
                                                        );
                                                    }
                                                    __field1 = _serde::__private::Some(
                                                        match _serde::de::MapAccess::next_value::<
                                                            String,
                                                        >(&mut __map) {
                                                            _serde::__private::Ok(__val) => __val,
                                                            _serde::__private::Err(__err) => {
                                                                return _serde::__private::Err(__err);
                                                            }
                                                        },
                                                    );
                                                }
                                                __Field::__field2 => {
                                                    if _serde::__private::Option::is_some(&__field2) {
                                                        return _serde::__private::Err(
                                                            <__A::Error as _serde::de::Error>::duplicate_field("amount"),
                                                        );
                                                    }
                                                    __field2 = _serde::__private::Some(
                                                        match _serde::de::MapAccess::next_value::<
                                                            Uint128,
                                                        >(&mut __map) {
                                                            _serde::__private::Ok(__val) => __val,
                                                            _serde::__private::Err(__err) => {
                                                                return _serde::__private::Err(__err);
                                                            }
                                                        },
                                                    );
                                                }
                                                __Field::__field3 => {
                                                    if _serde::__private::Option::is_some(&__field3) {
                                                        return _serde::__private::Err(
                                                            <__A::Error as _serde::de::Error>::duplicate_field("msg"),
                                                        );
                                                    }
                                                    __field3 = _serde::__private::Some(
                                                        match _serde::de::MapAccess::next_value::<
                                                            Binary,
                                                        >(&mut __map) {
                                                            _serde::__private::Ok(__val) => __val,
                                                            _serde::__private::Err(__err) => {
                                                                return _serde::__private::Err(__err);
                                                            }
                                                        },
                                                    );
                                                }
                                            }
                                        }
                                        let __field0 = match __field0 {
                                            _serde::__private::Some(__field0) => __field0,
                                            _serde::__private::None => {
                                                match _serde::__private::de::missing_field("owner") {
                                                    _serde::__private::Ok(__val) => __val,
                                                    _serde::__private::Err(__err) => {
                                                        return _serde::__private::Err(__err);
                                                    }
                                                }
                                            }
                                        };
                                        let __field1 = match __field1 {
                                            _serde::__private::Some(__field1) => __field1,
                                            _serde::__private::None => {
                                                match _serde::__private::de::missing_field("contract") {
                                                    _serde::__private::Ok(__val) => __val,
                                                    _serde::__private::Err(__err) => {
                                                        return _serde::__private::Err(__err);
                                                    }
                                                }
                                            }
                                        };
                                        let __field2 = match __field2 {
                                            _serde::__private::Some(__field2) => __field2,
                                            _serde::__private::None => {
                                                match _serde::__private::de::missing_field("amount") {
                                                    _serde::__private::Ok(__val) => __val,
                                                    _serde::__private::Err(__err) => {
                                                        return _serde::__private::Err(__err);
                                                    }
                                                }
                                            }
                                        };
                                        let __field3 = match __field3 {
                                            _serde::__private::Some(__field3) => __field3,
                                            _serde::__private::None => {
                                                match _serde::__private::de::missing_field("msg") {
                                                    _serde::__private::Ok(__val) => __val,
                                                    _serde::__private::Err(__err) => {
                                                        return _serde::__private::Err(__err);
                                                    }
                                                }
                                            }
                                        };
                                        _serde::__private::Ok(Cw20ExecuteMsg::SendFrom {
                                            owner: __field0,
                                            contract: __field1,
                                            amount: __field2,
                                            msg: __field3,
                                        })
                                    }
                                }
                                const FIELDS: &'static [&'static str] = &[
                                    "owner",
                                    "contract",
                                    "amount",
                                    "msg",
                                ];
                                _serde::de::VariantAccess::struct_variant(
                                    __variant,
                                    FIELDS,
                                    __Visitor {
                                        marker: _serde::__private::PhantomData::<Cw20ExecuteMsg>,
                                        lifetime: _serde::__private::PhantomData,
                                    },
                                )
                            }
                            (__Field::__field7, __variant) => {
                                #[allow(non_camel_case_types)]
                                enum __Field {
                                    __field0,
                                    __field1,
                                }
                                struct __FieldVisitor;
                                impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
                                    type Value = __Field;
                                    fn expecting(
                                        &self,
                                        __formatter: &mut _serde::__private::Formatter,
                                    ) -> _serde::__private::fmt::Result {
                                        _serde::__private::Formatter::write_str(
                                            __formatter,
                                            "field identifier",
                                        )
                                    }
                                    fn visit_u64<__E>(
                                        self,
                                        __value: u64,
                                    ) -> _serde::__private::Result<Self::Value, __E>
                                    where
                                        __E: _serde::de::Error,
                                    {
                                        match __value {
                                            0u64 => _serde::__private::Ok(__Field::__field0),
                                            1u64 => _serde::__private::Ok(__Field::__field1),
                                            _ => {
                                                _serde::__private::Err(
                                                    _serde::de::Error::invalid_value(
                                                        _serde::de::Unexpected::Unsigned(__value),
                                                        &"field index 0 <= i < 2",
                                                    ),
                                                )
                                            }
                                        }
                                    }
                                    fn visit_str<__E>(
                                        self,
                                        __value: &str,
                                    ) -> _serde::__private::Result<Self::Value, __E>
                                    where
                                        __E: _serde::de::Error,
                                    {
                                        match __value {
                                            "owner" => _serde::__private::Ok(__Field::__field0),
                                            "amount" => _serde::__private::Ok(__Field::__field1),
                                            _ => {
                                                _serde::__private::Err(
                                                    _serde::de::Error::unknown_field(__value, FIELDS),
                                                )
                                            }
                                        }
                                    }
                                    fn visit_bytes<__E>(
                                        self,
                                        __value: &[u8],
                                    ) -> _serde::__private::Result<Self::Value, __E>
                                    where
                                        __E: _serde::de::Error,
                                    {
                                        match __value {
                                            b"owner" => _serde::__private::Ok(__Field::__field0),
                                            b"amount" => _serde::__private::Ok(__Field::__field1),
                                            _ => {
                                                let __value = &_serde::__private::from_utf8_lossy(__value);
                                                _serde::__private::Err(
                                                    _serde::de::Error::unknown_field(__value, FIELDS),
                                                )
                                            }
                                        }
                                    }
                                }
                                impl<'de> _serde::Deserialize<'de> for __Field {
                                    #[inline]
                                    fn deserialize<__D>(
                                        __deserializer: __D,
                                    ) -> _serde::__private::Result<Self, __D::Error>
                                    where
                                        __D: _serde::Deserializer<'de>,
                                    {
                                        _serde::Deserializer::deserialize_identifier(
                                            __deserializer,
                                            __FieldVisitor,
                                        )
                                    }
                                }
                                struct __Visitor<'de> {
                                    marker: _serde::__private::PhantomData<Cw20ExecuteMsg>,
                                    lifetime: _serde::__private::PhantomData<&'de ()>,
                                }
                                impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
                                    type Value = Cw20ExecuteMsg;
                                    fn expecting(
                                        &self,
                                        __formatter: &mut _serde::__private::Formatter,
                                    ) -> _serde::__private::fmt::Result {
                                        _serde::__private::Formatter::write_str(
                                            __formatter,
                                            "struct variant Cw20ExecuteMsg::BurnFrom",
                                        )
                                    }
                                    #[inline]
                                    fn visit_seq<__A>(
                                        self,
                                        mut __seq: __A,
                                    ) -> _serde::__private::Result<Self::Value, __A::Error>
                                    where
                                        __A: _serde::de::SeqAccess<'de>,
                                    {
                                        let __field0 = match match _serde::de::SeqAccess::next_element::<
                                            String,
                                        >(&mut __seq) {
                                            _serde::__private::Ok(__val) => __val,
                                            _serde::__private::Err(__err) => {
                                                return _serde::__private::Err(__err);
                                            }
                                        } {
                                            _serde::__private::Some(__value) => __value,
                                            _serde::__private::None => {
                                                return _serde::__private::Err(
                                                    _serde::de::Error::invalid_length(
                                                        0usize,
                                                        &"struct variant Cw20ExecuteMsg::BurnFrom with 2 elements",
                                                    ),
                                                );
                                            }
                                        };
                                        let __field1 = match match _serde::de::SeqAccess::next_element::<
                                            Uint128,
                                        >(&mut __seq) {
                                            _serde::__private::Ok(__val) => __val,
                                            _serde::__private::Err(__err) => {
                                                return _serde::__private::Err(__err);
                                            }
                                        } {
                                            _serde::__private::Some(__value) => __value,
                                            _serde::__private::None => {
                                                return _serde::__private::Err(
                                                    _serde::de::Error::invalid_length(
                                                        1usize,
                                                        &"struct variant Cw20ExecuteMsg::BurnFrom with 2 elements",
                                                    ),
                                                );
                                            }
                                        };
                                        _serde::__private::Ok(Cw20ExecuteMsg::BurnFrom {
                                            owner: __field0,
                                            amount: __field1,
                                        })
                                    }
                                    #[inline]
                                    fn visit_map<__A>(
                                        self,
                                        mut __map: __A,
                                    ) -> _serde::__private::Result<Self::Value, __A::Error>
                                    where
                                        __A: _serde::de::MapAccess<'de>,
                                    {
                                        let mut __field0: _serde::__private::Option<String> = _serde::__private::None;
                                        let mut __field1: _serde::__private::Option<Uint128> = _serde::__private::None;
                                        while let _serde::__private::Some(__key)
                                            = match _serde::de::MapAccess::next_key::<
                                                __Field,
                                            >(&mut __map) {
                                                _serde::__private::Ok(__val) => __val,
                                                _serde::__private::Err(__err) => {
                                                    return _serde::__private::Err(__err);
                                                }
                                            } {
                                            match __key {
                                                __Field::__field0 => {
                                                    if _serde::__private::Option::is_some(&__field0) {
                                                        return _serde::__private::Err(
                                                            <__A::Error as _serde::de::Error>::duplicate_field("owner"),
                                                        );
                                                    }
                                                    __field0 = _serde::__private::Some(
                                                        match _serde::de::MapAccess::next_value::<
                                                            String,
                                                        >(&mut __map) {
                                                            _serde::__private::Ok(__val) => __val,
                                                            _serde::__private::Err(__err) => {
                                                                return _serde::__private::Err(__err);
                                                            }
                                                        },
                                                    );
                                                }
                                                __Field::__field1 => {
                                                    if _serde::__private::Option::is_some(&__field1) {
                                                        return _serde::__private::Err(
                                                            <__A::Error as _serde::de::Error>::duplicate_field("amount"),
                                                        );
                                                    }
                                                    __field1 = _serde::__private::Some(
                                                        match _serde::de::MapAccess::next_value::<
                                                            Uint128,
                                                        >(&mut __map) {
                                                            _serde::__private::Ok(__val) => __val,
                                                            _serde::__private::Err(__err) => {
                                                                return _serde::__private::Err(__err);
                                                            }
                                                        },
                                                    );
                                                }
                                            }
                                        }
                                        let __field0 = match __field0 {
                                            _serde::__private::Some(__field0) => __field0,
                                            _serde::__private::None => {
                                                match _serde::__private::de::missing_field("owner") {
                                                    _serde::__private::Ok(__val) => __val,
                                                    _serde::__private::Err(__err) => {
                                                        return _serde::__private::Err(__err);
                                                    }
                                                }
                                            }
                                        };
                                        let __field1 = match __field1 {
                                            _serde::__private::Some(__field1) => __field1,
                                            _serde::__private::None => {
                                                match _serde::__private::de::missing_field("amount") {
                                                    _serde::__private::Ok(__val) => __val,
                                                    _serde::__private::Err(__err) => {
                                                        return _serde::__private::Err(__err);
                                                    }
                                                }
                                            }
                                        };
                                        _serde::__private::Ok(Cw20ExecuteMsg::BurnFrom {
                                            owner: __field0,
                                            amount: __field1,
                                        })
                                    }
                                }
                                const FIELDS: &'static [&'static str] = &[
                                    "owner",
                                    "amount",
                                ];
                                _serde::de::VariantAccess::struct_variant(
                                    __variant,
                                    FIELDS,
                                    __Visitor {
                                        marker: _serde::__private::PhantomData::<Cw20ExecuteMsg>,
                                        lifetime: _serde::__private::PhantomData,
                                    },
                                )
                            }
                            (__Field::__field8, __variant) => {
                                #[allow(non_camel_case_types)]
                                enum __Field {
                                    __field0,
                                    __field1,
                                }
                                struct __FieldVisitor;
                                impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
                                    type Value = __Field;
                                    fn expecting(
                                        &self,
                                        __formatter: &mut _serde::__private::Formatter,
                                    ) -> _serde::__private::fmt::Result {
                                        _serde::__private::Formatter::write_str(
                                            __formatter,
                                            "field identifier",
                                        )
                                    }
                                    fn visit_u64<__E>(
                                        self,
                                        __value: u64,
                                    ) -> _serde::__private::Result<Self::Value, __E>
                                    where
                                        __E: _serde::de::Error,
                                    {
                                        match __value {
                                            0u64 => _serde::__private::Ok(__Field::__field0),
                                            1u64 => _serde::__private::Ok(__Field::__field1),
                                            _ => {
                                                _serde::__private::Err(
                                                    _serde::de::Error::invalid_value(
                                                        _serde::de::Unexpected::Unsigned(__value),
                                                        &"field index 0 <= i < 2",
                                                    ),
                                                )
                                            }
                                        }
                                    }
                                    fn visit_str<__E>(
                                        self,
                                        __value: &str,
                                    ) -> _serde::__private::Result<Self::Value, __E>
                                    where
                                        __E: _serde::de::Error,
                                    {
                                        match __value {
                                            "recipient" => _serde::__private::Ok(__Field::__field0),
                                            "amount" => _serde::__private::Ok(__Field::__field1),
                                            _ => {
                                                _serde::__private::Err(
                                                    _serde::de::Error::unknown_field(__value, FIELDS),
                                                )
                                            }
                                        }
                                    }
                                    fn visit_bytes<__E>(
                                        self,
                                        __value: &[u8],
                                    ) -> _serde::__private::Result<Self::Value, __E>
                                    where
                                        __E: _serde::de::Error,
                                    {
                                        match __value {
                                            b"recipient" => _serde::__private::Ok(__Field::__field0),
                                            b"amount" => _serde::__private::Ok(__Field::__field1),
                                            _ => {
                                                let __value = &_serde::__private::from_utf8_lossy(__value);
                                                _serde::__private::Err(
                                                    _serde::de::Error::unknown_field(__value, FIELDS),
                                                )
                                            }
                                        }
                                    }
                                }
                                impl<'de> _serde::Deserialize<'de> for __Field {
                                    #[inline]
                                    fn deserialize<__D>(
                                        __deserializer: __D,
                                    ) -> _serde::__private::Result<Self, __D::Error>
                                    where
                                        __D: _serde::Deserializer<'de>,
                                    {
                                        _serde::Deserializer::deserialize_identifier(
                                            __deserializer,
                                            __FieldVisitor,
                                        )
                                    }
                                }
                                struct __Visitor<'de> {
                                    marker: _serde::__private::PhantomData<Cw20ExecuteMsg>,
                                    lifetime: _serde::__private::PhantomData<&'de ()>,
                                }
                                impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
                                    type Value = Cw20ExecuteMsg;
                                    fn expecting(
                                        &self,
                                        __formatter: &mut _serde::__private::Formatter,
                                    ) -> _serde::__private::fmt::Result {
                                        _serde::__private::Formatter::write_str(
                                            __formatter,
                                            "struct variant Cw20ExecuteMsg::Mint",
                                        )
                                    }
                                    #[inline]
                                    fn visit_seq<__A>(
                                        self,
                                        mut __seq: __A,
                                    ) -> _serde::__private::Result<Self::Value, __A::Error>
                                    where
                                        __A: _serde::de::SeqAccess<'de>,
                                    {
                                        let __field0 = match match _serde::de::SeqAccess::next_element::<
                                            String,
                                        >(&mut __seq) {
                                            _serde::__private::Ok(__val) => __val,
                                            _serde::__private::Err(__err) => {
                                                return _serde::__private::Err(__err);
                                            }
                                        } {
                                            _serde::__private::Some(__value) => __value,
                                            _serde::__private::None => {
                                                return _serde::__private::Err(
                                                    _serde::de::Error::invalid_length(
                                                        0usize,
                                                        &"struct variant Cw20ExecuteMsg::Mint with 2 elements",
                                                    ),
                                                );
                                            }
                                        };
                                        let __field1 = match match _serde::de::SeqAccess::next_element::<
                                            Uint128,
                                        >(&mut __seq) {
                                            _serde::__private::Ok(__val) => __val,
                                            _serde::__private::Err(__err) => {
                                                return _serde::__private::Err(__err);
                                            }
                                        } {
                                            _serde::__private::Some(__value) => __value,
                                            _serde::__private::None => {
                                                return _serde::__private::Err(
                                                    _serde::de::Error::invalid_length(
                                                        1usize,
                                                        &"struct variant Cw20ExecuteMsg::Mint with 2 elements",
                                                    ),
                                                );
                                            }
                                        };
                                        _serde::__private::Ok(Cw20ExecuteMsg::Mint {
                                            recipient: __field0,
                                            amount: __field1,
                                        })
                                    }
                                    #[inline]
                                    fn visit_map<__A>(
                                        self,
                                        mut __map: __A,
                                    ) -> _serde::__private::Result<Self::Value, __A::Error>
                                    where
                                        __A: _serde::de::MapAccess<'de>,
                                    {
                                        let mut __field0: _serde::__private::Option<String> = _serde::__private::None;
                                        let mut __field1: _serde::__private::Option<Uint128> = _serde::__private::None;
                                        while let _serde::__private::Some(__key)
                                            = match _serde::de::MapAccess::next_key::<
                                                __Field,
                                            >(&mut __map) {
                                                _serde::__private::Ok(__val) => __val,
                                                _serde::__private::Err(__err) => {
                                                    return _serde::__private::Err(__err);
                                                }
                                            } {
                                            match __key {
                                                __Field::__field0 => {
                                                    if _serde::__private::Option::is_some(&__field0) {
                                                        return _serde::__private::Err(
                                                            <__A::Error as _serde::de::Error>::duplicate_field(
                                                                "recipient",
                                                            ),
                                                        );
                                                    }
                                                    __field0 = _serde::__private::Some(
                                                        match _serde::de::MapAccess::next_value::<
                                                            String,
                                                        >(&mut __map) {
                                                            _serde::__private::Ok(__val) => __val,
                                                            _serde::__private::Err(__err) => {
                                                                return _serde::__private::Err(__err);
                                                            }
                                                        },
                                                    );
                                                }
                                                __Field::__field1 => {
                                                    if _serde::__private::Option::is_some(&__field1) {
                                                        return _serde::__private::Err(
                                                            <__A::Error as _serde::de::Error>::duplicate_field("amount"),
                                                        );
                                                    }
                                                    __field1 = _serde::__private::Some(
                                                        match _serde::de::MapAccess::next_value::<
                                                            Uint128,
                                                        >(&mut __map) {
                                                            _serde::__private::Ok(__val) => __val,
                                                            _serde::__private::Err(__err) => {
                                                                return _serde::__private::Err(__err);
                                                            }
                                                        },
                                                    );
                                                }
                                            }
                                        }
                                        let __field0 = match __field0 {
                                            _serde::__private::Some(__field0) => __field0,
                                            _serde::__private::None => {
                                                match _serde::__private::de::missing_field("recipient") {
                                                    _serde::__private::Ok(__val) => __val,
                                                    _serde::__private::Err(__err) => {
                                                        return _serde::__private::Err(__err);
                                                    }
                                                }
                                            }
                                        };
                                        let __field1 = match __field1 {
                                            _serde::__private::Some(__field1) => __field1,
                                            _serde::__private::None => {
                                                match _serde::__private::de::missing_field("amount") {
                                                    _serde::__private::Ok(__val) => __val,
                                                    _serde::__private::Err(__err) => {
                                                        return _serde::__private::Err(__err);
                                                    }
                                                }
                                            }
                                        };
                                        _serde::__private::Ok(Cw20ExecuteMsg::Mint {
                                            recipient: __field0,
                                            amount: __field1,
                                        })
                                    }
                                }
                                const FIELDS: &'static [&'static str] = &[
                                    "recipient",
                                    "amount",
                                ];
                                _serde::de::VariantAccess::struct_variant(
                                    __variant,
                                    FIELDS,
                                    __Visitor {
                                        marker: _serde::__private::PhantomData::<Cw20ExecuteMsg>,
                                        lifetime: _serde::__private::PhantomData,
                                    },
                                )
                            }
                            (__Field::__field9, __variant) => {
                                #[allow(non_camel_case_types)]
                                enum __Field {
                                    __field0,
                                }
                                struct __FieldVisitor;
                                impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
                                    type Value = __Field;
                                    fn expecting(
                                        &self,
                                        __formatter: &mut _serde::__private::Formatter,
                                    ) -> _serde::__private::fmt::Result {
                                        _serde::__private::Formatter::write_str(
                                            __formatter,
                                            "field identifier",
                                        )
                                    }
                                    fn visit_u64<__E>(
                                        self,
                                        __value: u64,
                                    ) -> _serde::__private::Result<Self::Value, __E>
                                    where
                                        __E: _serde::de::Error,
                                    {
                                        match __value {
                                            0u64 => _serde::__private::Ok(__Field::__field0),
                                            _ => {
                                                _serde::__private::Err(
                                                    _serde::de::Error::invalid_value(
                                                        _serde::de::Unexpected::Unsigned(__value),
                                                        &"field index 0 <= i < 1",
                                                    ),
                                                )
                                            }
                                        }
                                    }
                                    fn visit_str<__E>(
                                        self,
                                        __value: &str,
                                    ) -> _serde::__private::Result<Self::Value, __E>
                                    where
                                        __E: _serde::de::Error,
                                    {
                                        match __value {
                                            "new_minter" => _serde::__private::Ok(__Field::__field0),
                                            _ => {
                                                _serde::__private::Err(
                                                    _serde::de::Error::unknown_field(__value, FIELDS),
                                                )
                                            }
                                        }
                                    }
                                    fn visit_bytes<__E>(
                                        self,
                                        __value: &[u8],
                                    ) -> _serde::__private::Result<Self::Value, __E>
                                    where
                                        __E: _serde::de::Error,
                                    {
                                        match __value {
                                            b"new_minter" => _serde::__private::Ok(__Field::__field0),
                                            _ => {
                                                let __value = &_serde::__private::from_utf8_lossy(__value);
                                                _serde::__private::Err(
                                                    _serde::de::Error::unknown_field(__value, FIELDS),
                                                )
                                            }
                                        }
                                    }
                                }
                                impl<'de> _serde::Deserialize<'de> for __Field {
                                    #[inline]
                                    fn deserialize<__D>(
                                        __deserializer: __D,
                                    ) -> _serde::__private::Result<Self, __D::Error>
                                    where
                                        __D: _serde::Deserializer<'de>,
                                    {
                                        _serde::Deserializer::deserialize_identifier(
                                            __deserializer,
                                            __FieldVisitor,
                                        )
                                    }
                                }
                                struct __Visitor<'de> {
                                    marker: _serde::__private::PhantomData<Cw20ExecuteMsg>,
                                    lifetime: _serde::__private::PhantomData<&'de ()>,
                                }
                                impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
                                    type Value = Cw20ExecuteMsg;
                                    fn expecting(
                                        &self,
                                        __formatter: &mut _serde::__private::Formatter,
                                    ) -> _serde::__private::fmt::Result {
                                        _serde::__private::Formatter::write_str(
                                            __formatter,
                                            "struct variant Cw20ExecuteMsg::UpdateMinter",
                                        )
                                    }
                                    #[inline]
                                    fn visit_seq<__A>(
                                        self,
                                        mut __seq: __A,
                                    ) -> _serde::__private::Result<Self::Value, __A::Error>
                                    where
                                        __A: _serde::de::SeqAccess<'de>,
                                    {
                                        let __field0 = match match _serde::de::SeqAccess::next_element::<
                                            Option<String>,
                                        >(&mut __seq) {
                                            _serde::__private::Ok(__val) => __val,
                                            _serde::__private::Err(__err) => {
                                                return _serde::__private::Err(__err);
                                            }
                                        } {
                                            _serde::__private::Some(__value) => __value,
                                            _serde::__private::None => {
                                                return _serde::__private::Err(
                                                    _serde::de::Error::invalid_length(
                                                        0usize,
                                                        &"struct variant Cw20ExecuteMsg::UpdateMinter with 1 element",
                                                    ),
                                                );
                                            }
                                        };
                                        _serde::__private::Ok(Cw20ExecuteMsg::UpdateMinter {
                                            new_minter: __field0,
                                        })
                                    }
                                    #[inline]
                                    fn visit_map<__A>(
                                        self,
                                        mut __map: __A,
                                    ) -> _serde::__private::Result<Self::Value, __A::Error>
                                    where
                                        __A: _serde::de::MapAccess<'de>,
                                    {
                                        let mut __field0: _serde::__private::Option<
                                            Option<String>,
                                        > = _serde::__private::None;
                                        while let _serde::__private::Some(__key)
                                            = match _serde::de::MapAccess::next_key::<
                                                __Field,
                                            >(&mut __map) {
                                                _serde::__private::Ok(__val) => __val,
                                                _serde::__private::Err(__err) => {
                                                    return _serde::__private::Err(__err);
                                                }
                                            } {
                                            match __key {
                                                __Field::__field0 => {
                                                    if _serde::__private::Option::is_some(&__field0) {
                                                        return _serde::__private::Err(
                                                            <__A::Error as _serde::de::Error>::duplicate_field(
                                                                "new_minter",
                                                            ),
                                                        );
                                                    }
                                                    __field0 = _serde::__private::Some(
                                                        match _serde::de::MapAccess::next_value::<
                                                            Option<String>,
                                                        >(&mut __map) {
                                                            _serde::__private::Ok(__val) => __val,
                                                            _serde::__private::Err(__err) => {
                                                                return _serde::__private::Err(__err);
                                                            }
                                                        },
                                                    );
                                                }
                                            }
                                        }
                                        let __field0 = match __field0 {
                                            _serde::__private::Some(__field0) => __field0,
                                            _serde::__private::None => {
                                                match _serde::__private::de::missing_field("new_minter") {
                                                    _serde::__private::Ok(__val) => __val,
                                                    _serde::__private::Err(__err) => {
                                                        return _serde::__private::Err(__err);
                                                    }
                                                }
                                            }
                                        };
                                        _serde::__private::Ok(Cw20ExecuteMsg::UpdateMinter {
                                            new_minter: __field0,
                                        })
                                    }
                                }
                                const FIELDS: &'static [&'static str] = &["new_minter"];
                                _serde::de::VariantAccess::struct_variant(
                                    __variant,
                                    FIELDS,
                                    __Visitor {
                                        marker: _serde::__private::PhantomData::<Cw20ExecuteMsg>,
                                        lifetime: _serde::__private::PhantomData,
                                    },
                                )
                            }
                            (__Field::__field10, __variant) => {
                                #[allow(non_camel_case_types)]
                                enum __Field {
                                    __field0,
                                    __field1,
                                    __field2,
                                }
                                struct __FieldVisitor;
                                impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
                                    type Value = __Field;
                                    fn expecting(
                                        &self,
                                        __formatter: &mut _serde::__private::Formatter,
                                    ) -> _serde::__private::fmt::Result {
                                        _serde::__private::Formatter::write_str(
                                            __formatter,
                                            "field identifier",
                                        )
                                    }
                                    fn visit_u64<__E>(
                                        self,
                                        __value: u64,
                                    ) -> _serde::__private::Result<Self::Value, __E>
                                    where
                                        __E: _serde::de::Error,
                                    {
                                        match __value {
                                            0u64 => _serde::__private::Ok(__Field::__field0),
                                            1u64 => _serde::__private::Ok(__Field::__field1),
                                            2u64 => _serde::__private::Ok(__Field::__field2),
                                            _ => {
                                                _serde::__private::Err(
                                                    _serde::de::Error::invalid_value(
                                                        _serde::de::Unexpected::Unsigned(__value),
                                                        &"field index 0 <= i < 3",
                                                    ),
                                                )
                                            }
                                        }
                                    }
                                    fn visit_str<__E>(
                                        self,
                                        __value: &str,
                                    ) -> _serde::__private::Result<Self::Value, __E>
                                    where
                                        __E: _serde::de::Error,
                                    {
                                        match __value {
                                            "project" => _serde::__private::Ok(__Field::__field0),
                                            "description" => _serde::__private::Ok(__Field::__field1),
                                            "marketing" => _serde::__private::Ok(__Field::__field2),
                                            _ => {
                                                _serde::__private::Err(
                                                    _serde::de::Error::unknown_field(__value, FIELDS),
                                                )
                                            }
                                        }
                                    }
                                    fn visit_bytes<__E>(
                                        self,
                                        __value: &[u8],
                                    ) -> _serde::__private::Result<Self::Value, __E>
                                    where
                                        __E: _serde::de::Error,
                                    {
                                        match __value {
                                            b"project" => _serde::__private::Ok(__Field::__field0),
                                            b"description" => _serde::__private::Ok(__Field::__field1),
                                            b"marketing" => _serde::__private::Ok(__Field::__field2),
                                            _ => {
                                                let __value = &_serde::__private::from_utf8_lossy(__value);
                                                _serde::__private::Err(
                                                    _serde::de::Error::unknown_field(__value, FIELDS),
                                                )
                                            }
                                        }
                                    }
                                }
                                impl<'de> _serde::Deserialize<'de> for __Field {
                                    #[inline]
                                    fn deserialize<__D>(
                                        __deserializer: __D,
                                    ) -> _serde::__private::Result<Self, __D::Error>
                                    where
                                        __D: _serde::Deserializer<'de>,
                                    {
                                        _serde::Deserializer::deserialize_identifier(
                                            __deserializer,
                                            __FieldVisitor,
                                        )
                                    }
                                }
                                struct __Visitor<'de> {
                                    marker: _serde::__private::PhantomData<Cw20ExecuteMsg>,
                                    lifetime: _serde::__private::PhantomData<&'de ()>,
                                }
                                impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
                                    type Value = Cw20ExecuteMsg;
                                    fn expecting(
                                        &self,
                                        __formatter: &mut _serde::__private::Formatter,
                                    ) -> _serde::__private::fmt::Result {
                                        _serde::__private::Formatter::write_str(
                                            __formatter,
                                            "struct variant Cw20ExecuteMsg::UpdateMarketing",
                                        )
                                    }
                                    #[inline]
                                    fn visit_seq<__A>(
                                        self,
                                        mut __seq: __A,
                                    ) -> _serde::__private::Result<Self::Value, __A::Error>
                                    where
                                        __A: _serde::de::SeqAccess<'de>,
                                    {
                                        let __field0 = match match _serde::de::SeqAccess::next_element::<
                                            Option<String>,
                                        >(&mut __seq) {
                                            _serde::__private::Ok(__val) => __val,
                                            _serde::__private::Err(__err) => {
                                                return _serde::__private::Err(__err);
                                            }
                                        } {
                                            _serde::__private::Some(__value) => __value,
                                            _serde::__private::None => {
                                                return _serde::__private::Err(
                                                    _serde::de::Error::invalid_length(
                                                        0usize,
                                                        &"struct variant Cw20ExecuteMsg::UpdateMarketing with 3 elements",
                                                    ),
                                                );
                                            }
                                        };
                                        let __field1 = match match _serde::de::SeqAccess::next_element::<
                                            Option<String>,
                                        >(&mut __seq) {
                                            _serde::__private::Ok(__val) => __val,
                                            _serde::__private::Err(__err) => {
                                                return _serde::__private::Err(__err);
                                            }
                                        } {
                                            _serde::__private::Some(__value) => __value,
                                            _serde::__private::None => {
                                                return _serde::__private::Err(
                                                    _serde::de::Error::invalid_length(
                                                        1usize,
                                                        &"struct variant Cw20ExecuteMsg::UpdateMarketing with 3 elements",
                                                    ),
                                                );
                                            }
                                        };
                                        let __field2 = match match _serde::de::SeqAccess::next_element::<
                                            Option<String>,
                                        >(&mut __seq) {
                                            _serde::__private::Ok(__val) => __val,
                                            _serde::__private::Err(__err) => {
                                                return _serde::__private::Err(__err);
                                            }
                                        } {
                                            _serde::__private::Some(__value) => __value,
                                            _serde::__private::None => {
                                                return _serde::__private::Err(
                                                    _serde::de::Error::invalid_length(
                                                        2usize,
                                                        &"struct variant Cw20ExecuteMsg::UpdateMarketing with 3 elements",
                                                    ),
                                                );
                                            }
                                        };
                                        _serde::__private::Ok(Cw20ExecuteMsg::UpdateMarketing {
                                            project: __field0,
                                            description: __field1,
                                            marketing: __field2,
                                        })
                                    }
                                    #[inline]
                                    fn visit_map<__A>(
                                        self,
                                        mut __map: __A,
                                    ) -> _serde::__private::Result<Self::Value, __A::Error>
                                    where
                                        __A: _serde::de::MapAccess<'de>,
                                    {
                                        let mut __field0: _serde::__private::Option<
                                            Option<String>,
                                        > = _serde::__private::None;
                                        let mut __field1: _serde::__private::Option<
                                            Option<String>,
                                        > = _serde::__private::None;
                                        let mut __field2: _serde::__private::Option<
                                            Option<String>,
                                        > = _serde::__private::None;
                                        while let _serde::__private::Some(__key)
                                            = match _serde::de::MapAccess::next_key::<
                                                __Field,
                                            >(&mut __map) {
                                                _serde::__private::Ok(__val) => __val,
                                                _serde::__private::Err(__err) => {
                                                    return _serde::__private::Err(__err);
                                                }
                                            } {
                                            match __key {
                                                __Field::__field0 => {
                                                    if _serde::__private::Option::is_some(&__field0) {
                                                        return _serde::__private::Err(
                                                            <__A::Error as _serde::de::Error>::duplicate_field(
                                                                "project",
                                                            ),
                                                        );
                                                    }
                                                    __field0 = _serde::__private::Some(
                                                        match _serde::de::MapAccess::next_value::<
                                                            Option<String>,
                                                        >(&mut __map) {
                                                            _serde::__private::Ok(__val) => __val,
                                                            _serde::__private::Err(__err) => {
                                                                return _serde::__private::Err(__err);
                                                            }
                                                        },
                                                    );
                                                }
                                                __Field::__field1 => {
                                                    if _serde::__private::Option::is_some(&__field1) {
                                                        return _serde::__private::Err(
                                                            <__A::Error as _serde::de::Error>::duplicate_field(
                                                                "description",
                                                            ),
                                                        );
                                                    }
                                                    __field1 = _serde::__private::Some(
                                                        match _serde::de::MapAccess::next_value::<
                                                            Option<String>,
                                                        >(&mut __map) {
                                                            _serde::__private::Ok(__val) => __val,
                                                            _serde::__private::Err(__err) => {
                                                                return _serde::__private::Err(__err);
                                                            }
                                                        },
                                                    );
                                                }
                                                __Field::__field2 => {
                                                    if _serde::__private::Option::is_some(&__field2) {
                                                        return _serde::__private::Err(
                                                            <__A::Error as _serde::de::Error>::duplicate_field(
                                                                "marketing",
                                                            ),
                                                        );
                                                    }
                                                    __field2 = _serde::__private::Some(
                                                        match _serde::de::MapAccess::next_value::<
                                                            Option<String>,
                                                        >(&mut __map) {
                                                            _serde::__private::Ok(__val) => __val,
                                                            _serde::__private::Err(__err) => {
                                                                return _serde::__private::Err(__err);
                                                            }
                                                        },
                                                    );
                                                }
                                            }
                                        }
                                        let __field0 = match __field0 {
                                            _serde::__private::Some(__field0) => __field0,
                                            _serde::__private::None => {
                                                match _serde::__private::de::missing_field("project") {
                                                    _serde::__private::Ok(__val) => __val,
                                                    _serde::__private::Err(__err) => {
                                                        return _serde::__private::Err(__err);
                                                    }
                                                }
                                            }
                                        };
                                        let __field1 = match __field1 {
                                            _serde::__private::Some(__field1) => __field1,
                                            _serde::__private::None => {
                                                match _serde::__private::de::missing_field("description") {
                                                    _serde::__private::Ok(__val) => __val,
                                                    _serde::__private::Err(__err) => {
                                                        return _serde::__private::Err(__err);
                                                    }
                                                }
                                            }
                                        };
                                        let __field2 = match __field2 {
                                            _serde::__private::Some(__field2) => __field2,
                                            _serde::__private::None => {
                                                match _serde::__private::de::missing_field("marketing") {
                                                    _serde::__private::Ok(__val) => __val,
                                                    _serde::__private::Err(__err) => {
                                                        return _serde::__private::Err(__err);
                                                    }
                                                }
                                            }
                                        };
                                        _serde::__private::Ok(Cw20ExecuteMsg::UpdateMarketing {
                                            project: __field0,
                                            description: __field1,
                                            marketing: __field2,
                                        })
                                    }
                                }
                                const FIELDS: &'static [&'static str] = &[
                                    "project",
                                    "description",
                                    "marketing",
                                ];
                                _serde::de::VariantAccess::struct_variant(
                                    __variant,
                                    FIELDS,
                                    __Visitor {
                                        marker: _serde::__private::PhantomData::<Cw20ExecuteMsg>,
                                        lifetime: _serde::__private::PhantomData,
                                    },
                                )
                            }
                            (__Field::__field11, __variant) => {
                                _serde::__private::Result::map(
                                    _serde::de::VariantAccess::newtype_variant::<
                                        Logo,
                                    >(__variant),
                                    Cw20ExecuteMsg::UploadLogo,
                                )
                            }
                        }
                    }
                }
                const VARIANTS: &'static [&'static str] = &[
                    "transfer",
                    "burn",
                    "send",
                    "increase_allowance",
                    "decrease_allowance",
                    "transfer_from",
                    "send_from",
                    "burn_from",
                    "mint",
                    "update_minter",
                    "update_marketing",
                    "upload_logo",
                ];
                _serde::Deserializer::deserialize_enum(
                    __deserializer,
                    "Cw20ExecuteMsg",
                    VARIANTS,
                    __Visitor {
                        marker: _serde::__private::PhantomData::<Cw20ExecuteMsg>,
                        lifetime: _serde::__private::PhantomData,
                    },
                )
            }
        }
    };
    #[automatically_derived]
    #[allow(clippy::derive_partial_eq_without_eq)]
    impl ::core::clone::Clone for Cw20ExecuteMsg {
        #[inline]
        fn clone(&self) -> Cw20ExecuteMsg {
            match self {
                Cw20ExecuteMsg::Transfer { recipient: __self_0, amount: __self_1 } => {
                    Cw20ExecuteMsg::Transfer {
                        recipient: ::core::clone::Clone::clone(__self_0),
                        amount: ::core::clone::Clone::clone(__self_1),
                    }
                }
                Cw20ExecuteMsg::Burn { amount: __self_0 } => {
                    Cw20ExecuteMsg::Burn {
                        amount: ::core::clone::Clone::clone(__self_0),
                    }
                }
                Cw20ExecuteMsg::Send {
                    contract: __self_0,
                    amount: __self_1,
                    msg: __self_2,
                } => {
                    Cw20ExecuteMsg::Send {
                        contract: ::core::clone::Clone::clone(__self_0),
                        amount: ::core::clone::Clone::clone(__self_1),
                        msg: ::core::clone::Clone::clone(__self_2),
                    }
                }
                Cw20ExecuteMsg::IncreaseAllowance {
                    spender: __self_0,
                    amount: __self_1,
                    expires: __self_2,
                } => {
                    Cw20ExecuteMsg::IncreaseAllowance {
                        spender: ::core::clone::Clone::clone(__self_0),
                        amount: ::core::clone::Clone::clone(__self_1),
                        expires: ::core::clone::Clone::clone(__self_2),
                    }
                }
                Cw20ExecuteMsg::DecreaseAllowance {
                    spender: __self_0,
                    amount: __self_1,
                    expires: __self_2,
                } => {
                    Cw20ExecuteMsg::DecreaseAllowance {
                        spender: ::core::clone::Clone::clone(__self_0),
                        amount: ::core::clone::Clone::clone(__self_1),
                        expires: ::core::clone::Clone::clone(__self_2),
                    }
                }
                Cw20ExecuteMsg::TransferFrom {
                    owner: __self_0,
                    recipient: __self_1,
                    amount: __self_2,
                } => {
                    Cw20ExecuteMsg::TransferFrom {
                        owner: ::core::clone::Clone::clone(__self_0),
                        recipient: ::core::clone::Clone::clone(__self_1),
                        amount: ::core::clone::Clone::clone(__self_2),
                    }
                }
                Cw20ExecuteMsg::SendFrom {
                    owner: __self_0,
                    contract: __self_1,
                    amount: __self_2,
                    msg: __self_3,
                } => {
                    Cw20ExecuteMsg::SendFrom {
                        owner: ::core::clone::Clone::clone(__self_0),
                        contract: ::core::clone::Clone::clone(__self_1),
                        amount: ::core::clone::Clone::clone(__self_2),
                        msg: ::core::clone::Clone::clone(__self_3),
                    }
                }
                Cw20ExecuteMsg::BurnFrom { owner: __self_0, amount: __self_1 } => {
                    Cw20ExecuteMsg::BurnFrom {
                        owner: ::core::clone::Clone::clone(__self_0),
                        amount: ::core::clone::Clone::clone(__self_1),
                    }
                }
                Cw20ExecuteMsg::Mint { recipient: __self_0, amount: __self_1 } => {
                    Cw20ExecuteMsg::Mint {
                        recipient: ::core::clone::Clone::clone(__self_0),
                        amount: ::core::clone::Clone::clone(__self_1),
                    }
                }
                Cw20ExecuteMsg::UpdateMinter { new_minter: __self_0 } => {
                    Cw20ExecuteMsg::UpdateMinter {
                        new_minter: ::core::clone::Clone::clone(__self_0),
                    }
                }
                Cw20ExecuteMsg::UpdateMarketing {
                    project: __self_0,
                    description: __self_1,
                    marketing: __self_2,
                } => {
                    Cw20ExecuteMsg::UpdateMarketing {
                        project: ::core::clone::Clone::clone(__self_0),
                        description: ::core::clone::Clone::clone(__self_1),
                        marketing: ::core::clone::Clone::clone(__self_2),
                    }
                }
                Cw20ExecuteMsg::UploadLogo(__self_0) => {
                    Cw20ExecuteMsg::UploadLogo(::core::clone::Clone::clone(__self_0))
                }
            }
        }
    }
    #[automatically_derived]
    #[allow(clippy::derive_partial_eq_without_eq)]
    impl ::core::fmt::Debug for Cw20ExecuteMsg {
        fn fmt(&self, f: &mut ::core::fmt::Formatter) -> ::core::fmt::Result {
            match self {
                Cw20ExecuteMsg::Transfer { recipient: __self_0, amount: __self_1 } => {
                    ::core::fmt::Formatter::debug_struct_field2_finish(
                        f,
                        "Transfer",
                        "recipient",
                        __self_0,
                        "amount",
                        &__self_1,
                    )
                }
                Cw20ExecuteMsg::Burn { amount: __self_0 } => {
                    ::core::fmt::Formatter::debug_struct_field1_finish(
                        f,
                        "Burn",
                        "amount",
                        &__self_0,
                    )
                }
                Cw20ExecuteMsg::Send {
                    contract: __self_0,
                    amount: __self_1,
                    msg: __self_2,
                } => {
                    ::core::fmt::Formatter::debug_struct_field3_finish(
                        f,
                        "Send",
                        "contract",
                        __self_0,
                        "amount",
                        __self_1,
                        "msg",
                        &__self_2,
                    )
                }
                Cw20ExecuteMsg::IncreaseAllowance {
                    spender: __self_0,
                    amount: __self_1,
                    expires: __self_2,
                } => {
                    ::core::fmt::Formatter::debug_struct_field3_finish(
                        f,
                        "IncreaseAllowance",
                        "spender",
                        __self_0,
                        "amount",
                        __self_1,
                        "expires",
                        &__self_2,
                    )
                }
                Cw20ExecuteMsg::DecreaseAllowance {
                    spender: __self_0,
                    amount: __self_1,
                    expires: __self_2,
                } => {
                    ::core::fmt::Formatter::debug_struct_field3_finish(
                        f,
                        "DecreaseAllowance",
                        "spender",
                        __self_0,
                        "amount",
                        __self_1,
                        "expires",
                        &__self_2,
                    )
                }
                Cw20ExecuteMsg::TransferFrom {
                    owner: __self_0,
                    recipient: __self_1,
                    amount: __self_2,
                } => {
                    ::core::fmt::Formatter::debug_struct_field3_finish(
                        f,
                        "TransferFrom",
                        "owner",
                        __self_0,
                        "recipient",
                        __self_1,
                        "amount",
                        &__self_2,
                    )
                }
                Cw20ExecuteMsg::SendFrom {
                    owner: __self_0,
                    contract: __self_1,
                    amount: __self_2,
                    msg: __self_3,
                } => {
                    ::core::fmt::Formatter::debug_struct_field4_finish(
                        f,
                        "SendFrom",
                        "owner",
                        __self_0,
                        "contract",
                        __self_1,
                        "amount",
                        __self_2,
                        "msg",
                        &__self_3,
                    )
                }
                Cw20ExecuteMsg::BurnFrom { owner: __self_0, amount: __self_1 } => {
                    ::core::fmt::Formatter::debug_struct_field2_finish(
                        f,
                        "BurnFrom",
                        "owner",
                        __self_0,
                        "amount",
                        &__self_1,
                    )
                }
                Cw20ExecuteMsg::Mint { recipient: __self_0, amount: __self_1 } => {
                    ::core::fmt::Formatter::debug_struct_field2_finish(
                        f,
                        "Mint",
                        "recipient",
                        __self_0,
                        "amount",
                        &__self_1,
                    )
                }
                Cw20ExecuteMsg::UpdateMinter { new_minter: __self_0 } => {
                    ::core::fmt::Formatter::debug_struct_field1_finish(
                        f,
                        "UpdateMinter",
                        "new_minter",
                        &__self_0,
                    )
                }
                Cw20ExecuteMsg::UpdateMarketing {
                    project: __self_0,
                    description: __self_1,
                    marketing: __self_2,
                } => {
                    ::core::fmt::Formatter::debug_struct_field3_finish(
                        f,
                        "UpdateMarketing",
                        "project",
                        __self_0,
                        "description",
                        __self_1,
                        "marketing",
                        &__self_2,
                    )
                }
                Cw20ExecuteMsg::UploadLogo(__self_0) => {
                    ::core::fmt::Formatter::debug_tuple_field1_finish(
                        f,
                        "UploadLogo",
                        &__self_0,
                    )
                }
            }
        }
    }
    #[allow(clippy::derive_partial_eq_without_eq)]
    #[automatically_derived]
    impl ::core::marker::StructuralPartialEq for Cw20ExecuteMsg {}
    #[automatically_derived]
    #[allow(clippy::derive_partial_eq_without_eq)]
    impl ::core::cmp::PartialEq for Cw20ExecuteMsg {
        #[inline]
        fn eq(&self, other: &Cw20ExecuteMsg) -> bool {
            let __self_tag = ::core::intrinsics::discriminant_value(self);
            let __arg1_tag = ::core::intrinsics::discriminant_value(other);
            __self_tag == __arg1_tag
                && match (self, other) {
                    (
                        Cw20ExecuteMsg::Transfer {
                            recipient: __self_0,
                            amount: __self_1,
                        },
                        Cw20ExecuteMsg::Transfer {
                            recipient: __arg1_0,
                            amount: __arg1_1,
                        },
                    ) => *__self_0 == *__arg1_0 && *__self_1 == *__arg1_1,
                    (
                        Cw20ExecuteMsg::Burn { amount: __self_0 },
                        Cw20ExecuteMsg::Burn { amount: __arg1_0 },
                    ) => *__self_0 == *__arg1_0,
                    (
                        Cw20ExecuteMsg::Send {
                            contract: __self_0,
                            amount: __self_1,
                            msg: __self_2,
                        },
                        Cw20ExecuteMsg::Send {
                            contract: __arg1_0,
                            amount: __arg1_1,
                            msg: __arg1_2,
                        },
                    ) => {
                        *__self_0 == *__arg1_0 && *__self_1 == *__arg1_1
                            && *__self_2 == *__arg1_2
                    }
                    (
                        Cw20ExecuteMsg::IncreaseAllowance {
                            spender: __self_0,
                            amount: __self_1,
                            expires: __self_2,
                        },
                        Cw20ExecuteMsg::IncreaseAllowance {
                            spender: __arg1_0,
                            amount: __arg1_1,
                            expires: __arg1_2,
                        },
                    ) => {
                        *__self_0 == *__arg1_0 && *__self_1 == *__arg1_1
                            && *__self_2 == *__arg1_2
                    }
                    (
                        Cw20ExecuteMsg::DecreaseAllowance {
                            spender: __self_0,
                            amount: __self_1,
                            expires: __self_2,
                        },
                        Cw20ExecuteMsg::DecreaseAllowance {
                            spender: __arg1_0,
                            amount: __arg1_1,
                            expires: __arg1_2,
                        },
                    ) => {
                        *__self_0 == *__arg1_0 && *__self_1 == *__arg1_1
                            && *__self_2 == *__arg1_2
                    }
                    (
                        Cw20ExecuteMsg::TransferFrom {
                            owner: __self_0,
                            recipient: __self_1,
                            amount: __self_2,
                        },
                        Cw20ExecuteMsg::TransferFrom {
                            owner: __arg1_0,
                            recipient: __arg1_1,
                            amount: __arg1_2,
                        },
                    ) => {
                        *__self_0 == *__arg1_0 && *__self_1 == *__arg1_1
                            && *__self_2 == *__arg1_2
                    }
                    (
                        Cw20ExecuteMsg::SendFrom {
                            owner: __self_0,
                            contract: __self_1,
                            amount: __self_2,
                            msg: __self_3,
                        },
                        Cw20ExecuteMsg::SendFrom {
                            owner: __arg1_0,
                            contract: __arg1_1,
                            amount: __arg1_2,
                            msg: __arg1_3,
                        },
                    ) => {
                        *__self_0 == *__arg1_0 && *__self_1 == *__arg1_1
                            && *__self_2 == *__arg1_2 && *__self_3 == *__arg1_3
                    }
                    (
                        Cw20ExecuteMsg::BurnFrom { owner: __self_0, amount: __self_1 },
                        Cw20ExecuteMsg::BurnFrom { owner: __arg1_0, amount: __arg1_1 },
                    ) => *__self_0 == *__arg1_0 && *__self_1 == *__arg1_1,
                    (
                        Cw20ExecuteMsg::Mint { recipient: __self_0, amount: __self_1 },
                        Cw20ExecuteMsg::Mint { recipient: __arg1_0, amount: __arg1_1 },
                    ) => *__self_0 == *__arg1_0 && *__self_1 == *__arg1_1,
                    (
                        Cw20ExecuteMsg::UpdateMinter { new_minter: __self_0 },
                        Cw20ExecuteMsg::UpdateMinter { new_minter: __arg1_0 },
                    ) => *__self_0 == *__arg1_0,
                    (
                        Cw20ExecuteMsg::UpdateMarketing {
                            project: __self_0,
                            description: __self_1,
                            marketing: __self_2,
                        },
                        Cw20ExecuteMsg::UpdateMarketing {
                            project: __arg1_0,
                            description: __arg1_1,
                            marketing: __arg1_2,
                        },
                    ) => {
                        *__self_0 == *__arg1_0 && *__self_1 == *__arg1_1
                            && *__self_2 == *__arg1_2
                    }
                    (
                        Cw20ExecuteMsg::UploadLogo(__self_0),
                        Cw20ExecuteMsg::UploadLogo(__arg1_0),
                    ) => *__self_0 == *__arg1_0,
                    _ => unsafe { ::core::intrinsics::unreachable() }
                }
        }
    }
    const _: () = {
        use ::cosmwasm_schema::schemars as schemars;
        #[automatically_derived]
        #[allow(unused_braces)]
        impl schemars::JsonSchema for Cw20ExecuteMsg {
            fn schema_name() -> std::string::String {
                "Cw20ExecuteMsg".to_owned()
            }
            fn json_schema(
                gen: &mut schemars::gen::SchemaGenerator,
            ) -> schemars::schema::Schema {
                schemars::schema::Schema::Object(schemars::schema::SchemaObject {
                    subschemas: Some(
                        Box::new(schemars::schema::SubschemaValidation {
                            one_of: Some(
                                <[_]>::into_vec(
                                    #[rustc_box]
                                    ::alloc::boxed::Box::new([
                                        schemars::_private::apply_metadata(
                                            schemars::schema::Schema::Object(schemars::schema::SchemaObject {
                                                instance_type: Some(
                                                    schemars::schema::InstanceType::Object.into(),
                                                ),
                                                object: Some(
                                                    Box::new(schemars::schema::ObjectValidation {
                                                        properties: {
                                                            let mut props = schemars::Map::new();
                                                            props
                                                                .insert(
                                                                    "transfer".to_owned(),
                                                                    {
                                                                        let mut schema_object = schemars::schema::SchemaObject {
                                                                            instance_type: Some(
                                                                                schemars::schema::InstanceType::Object.into(),
                                                                            ),
                                                                            ..Default::default()
                                                                        };
                                                                        let object_validation = schema_object.object();
                                                                        object_validation
                                                                            .additional_properties = Some(Box::new(false.into()));
                                                                        {
                                                                            object_validation
                                                                                .properties
                                                                                .insert(
                                                                                    "recipient".to_owned(),
                                                                                    gen.subschema_for::<String>(),
                                                                                );
                                                                            if !<String as schemars::JsonSchema>::_schemars_private_is_option() {
                                                                                object_validation.required.insert("recipient".to_owned());
                                                                            }
                                                                        }
                                                                        {
                                                                            object_validation
                                                                                .properties
                                                                                .insert(
                                                                                    "amount".to_owned(),
                                                                                    gen.subschema_for::<Uint128>(),
                                                                                );
                                                                            if !<Uint128 as schemars::JsonSchema>::_schemars_private_is_option() {
                                                                                object_validation.required.insert("amount".to_owned());
                                                                            }
                                                                        }
                                                                        schemars::schema::Schema::Object(schema_object)
                                                                    },
                                                                );
                                                            props
                                                        },
                                                        required: {
                                                            let mut required = schemars::Set::new();
                                                            required.insert("transfer".to_owned());
                                                            required
                                                        },
                                                        additional_properties: Some(Box::new(false.into())),
                                                        ..Default::default()
                                                    }),
                                                ),
                                                ..Default::default()
                                            }),
                                            schemars::schema::Metadata {
                                                description: Some(
                                                    "Transfer is a base message to move tokens to another account without triggering actions"
                                                        .to_owned(),
                                                ),
                                                ..Default::default()
                                            },
                                        ),
                                        schemars::_private::apply_metadata(
                                            schemars::schema::Schema::Object(schemars::schema::SchemaObject {
                                                instance_type: Some(
                                                    schemars::schema::InstanceType::Object.into(),
                                                ),
                                                object: Some(
                                                    Box::new(schemars::schema::ObjectValidation {
                                                        properties: {
                                                            let mut props = schemars::Map::new();
                                                            props
                                                                .insert(
                                                                    "burn".to_owned(),
                                                                    {
                                                                        let mut schema_object = schemars::schema::SchemaObject {
                                                                            instance_type: Some(
                                                                                schemars::schema::InstanceType::Object.into(),
                                                                            ),
                                                                            ..Default::default()
                                                                        };
                                                                        let object_validation = schema_object.object();
                                                                        object_validation
                                                                            .additional_properties = Some(Box::new(false.into()));
                                                                        {
                                                                            object_validation
                                                                                .properties
                                                                                .insert(
                                                                                    "amount".to_owned(),
                                                                                    gen.subschema_for::<Uint128>(),
                                                                                );
                                                                            if !<Uint128 as schemars::JsonSchema>::_schemars_private_is_option() {
                                                                                object_validation.required.insert("amount".to_owned());
                                                                            }
                                                                        }
                                                                        schemars::schema::Schema::Object(schema_object)
                                                                    },
                                                                );
                                                            props
                                                        },
                                                        required: {
                                                            let mut required = schemars::Set::new();
                                                            required.insert("burn".to_owned());
                                                            required
                                                        },
                                                        additional_properties: Some(Box::new(false.into())),
                                                        ..Default::default()
                                                    }),
                                                ),
                                                ..Default::default()
                                            }),
                                            schemars::schema::Metadata {
                                                description: Some(
                                                    "Burn is a base message to destroy tokens forever"
                                                        .to_owned(),
                                                ),
                                                ..Default::default()
                                            },
                                        ),
                                        schemars::_private::apply_metadata(
                                            schemars::schema::Schema::Object(schemars::schema::SchemaObject {
                                                instance_type: Some(
                                                    schemars::schema::InstanceType::Object.into(),
                                                ),
                                                object: Some(
                                                    Box::new(schemars::schema::ObjectValidation {
                                                        properties: {
                                                            let mut props = schemars::Map::new();
                                                            props
                                                                .insert(
                                                                    "send".to_owned(),
                                                                    {
                                                                        let mut schema_object = schemars::schema::SchemaObject {
                                                                            instance_type: Some(
                                                                                schemars::schema::InstanceType::Object.into(),
                                                                            ),
                                                                            ..Default::default()
                                                                        };
                                                                        let object_validation = schema_object.object();
                                                                        object_validation
                                                                            .additional_properties = Some(Box::new(false.into()));
                                                                        {
                                                                            object_validation
                                                                                .properties
                                                                                .insert(
                                                                                    "contract".to_owned(),
                                                                                    gen.subschema_for::<String>(),
                                                                                );
                                                                            if !<String as schemars::JsonSchema>::_schemars_private_is_option() {
                                                                                object_validation.required.insert("contract".to_owned());
                                                                            }
                                                                        }
                                                                        {
                                                                            object_validation
                                                                                .properties
                                                                                .insert(
                                                                                    "amount".to_owned(),
                                                                                    gen.subschema_for::<Uint128>(),
                                                                                );
                                                                            if !<Uint128 as schemars::JsonSchema>::_schemars_private_is_option() {
                                                                                object_validation.required.insert("amount".to_owned());
                                                                            }
                                                                        }
                                                                        {
                                                                            object_validation
                                                                                .properties
                                                                                .insert("msg".to_owned(), gen.subschema_for::<Binary>());
                                                                            if !<Binary as schemars::JsonSchema>::_schemars_private_is_option() {
                                                                                object_validation.required.insert("msg".to_owned());
                                                                            }
                                                                        }
                                                                        schemars::schema::Schema::Object(schema_object)
                                                                    },
                                                                );
                                                            props
                                                        },
                                                        required: {
                                                            let mut required = schemars::Set::new();
                                                            required.insert("send".to_owned());
                                                            required
                                                        },
                                                        additional_properties: Some(Box::new(false.into())),
                                                        ..Default::default()
                                                    }),
                                                ),
                                                ..Default::default()
                                            }),
                                            schemars::schema::Metadata {
                                                description: Some(
                                                    "Send is a base message to transfer tokens to a contract and trigger an action on the receiving contract."
                                                        .to_owned(),
                                                ),
                                                ..Default::default()
                                            },
                                        ),
                                        schemars::_private::apply_metadata(
                                            schemars::schema::Schema::Object(schemars::schema::SchemaObject {
                                                instance_type: Some(
                                                    schemars::schema::InstanceType::Object.into(),
                                                ),
                                                object: Some(
                                                    Box::new(schemars::schema::ObjectValidation {
                                                        properties: {
                                                            let mut props = schemars::Map::new();
                                                            props
                                                                .insert(
                                                                    "increase_allowance".to_owned(),
                                                                    {
                                                                        let mut schema_object = schemars::schema::SchemaObject {
                                                                            instance_type: Some(
                                                                                schemars::schema::InstanceType::Object.into(),
                                                                            ),
                                                                            ..Default::default()
                                                                        };
                                                                        let object_validation = schema_object.object();
                                                                        object_validation
                                                                            .additional_properties = Some(Box::new(false.into()));
                                                                        {
                                                                            object_validation
                                                                                .properties
                                                                                .insert(
                                                                                    "spender".to_owned(),
                                                                                    gen.subschema_for::<String>(),
                                                                                );
                                                                            if !<String as schemars::JsonSchema>::_schemars_private_is_option() {
                                                                                object_validation.required.insert("spender".to_owned());
                                                                            }
                                                                        }
                                                                        {
                                                                            object_validation
                                                                                .properties
                                                                                .insert(
                                                                                    "amount".to_owned(),
                                                                                    gen.subschema_for::<Uint128>(),
                                                                                );
                                                                            if !<Uint128 as schemars::JsonSchema>::_schemars_private_is_option() {
                                                                                object_validation.required.insert("amount".to_owned());
                                                                            }
                                                                        }
                                                                        {
                                                                            object_validation
                                                                                .properties
                                                                                .insert(
                                                                                    "expires".to_owned(),
                                                                                    gen.subschema_for::<Option<Expiration>>(),
                                                                                );
                                                                            if !<Option<
                                                                                Expiration,
                                                                            > as schemars::JsonSchema>::_schemars_private_is_option() {
                                                                                object_validation.required.insert("expires".to_owned());
                                                                            }
                                                                        }
                                                                        schemars::schema::Schema::Object(schema_object)
                                                                    },
                                                                );
                                                            props
                                                        },
                                                        required: {
                                                            let mut required = schemars::Set::new();
                                                            required.insert("increase_allowance".to_owned());
                                                            required
                                                        },
                                                        additional_properties: Some(Box::new(false.into())),
                                                        ..Default::default()
                                                    }),
                                                ),
                                                ..Default::default()
                                            }),
                                            schemars::schema::Metadata {
                                                description: Some(
                                                    "Only with \"approval\" extension. Allows spender to access an additional amount tokens from the owner's (env.sender) account. If expires is Some(), overwrites current allowance expiration with this one."
                                                        .to_owned(),
                                                ),
                                                ..Default::default()
                                            },
                                        ),
                                        schemars::_private::apply_metadata(
                                            schemars::schema::Schema::Object(schemars::schema::SchemaObject {
                                                instance_type: Some(
                                                    schemars::schema::InstanceType::Object.into(),
                                                ),
                                                object: Some(
                                                    Box::new(schemars::schema::ObjectValidation {
                                                        properties: {
                                                            let mut props = schemars::Map::new();
                                                            props
                                                                .insert(
                                                                    "decrease_allowance".to_owned(),
                                                                    {
                                                                        let mut schema_object = schemars::schema::SchemaObject {
                                                                            instance_type: Some(
                                                                                schemars::schema::InstanceType::Object.into(),
                                                                            ),
                                                                            ..Default::default()
                                                                        };
                                                                        let object_validation = schema_object.object();
                                                                        object_validation
                                                                            .additional_properties = Some(Box::new(false.into()));
                                                                        {
                                                                            object_validation
                                                                                .properties
                                                                                .insert(
                                                                                    "spender".to_owned(),
                                                                                    gen.subschema_for::<String>(),
                                                                                );
                                                                            if !<String as schemars::JsonSchema>::_schemars_private_is_option() {
                                                                                object_validation.required.insert("spender".to_owned());
                                                                            }
                                                                        }
                                                                        {
                                                                            object_validation
                                                                                .properties
                                                                                .insert(
                                                                                    "amount".to_owned(),
                                                                                    gen.subschema_for::<Uint128>(),
                                                                                );
                                                                            if !<Uint128 as schemars::JsonSchema>::_schemars_private_is_option() {
                                                                                object_validation.required.insert("amount".to_owned());
                                                                            }
                                                                        }
                                                                        {
                                                                            object_validation
                                                                                .properties
                                                                                .insert(
                                                                                    "expires".to_owned(),
                                                                                    gen.subschema_for::<Option<Expiration>>(),
                                                                                );
                                                                            if !<Option<
                                                                                Expiration,
                                                                            > as schemars::JsonSchema>::_schemars_private_is_option() {
                                                                                object_validation.required.insert("expires".to_owned());
                                                                            }
                                                                        }
                                                                        schemars::schema::Schema::Object(schema_object)
                                                                    },
                                                                );
                                                            props
                                                        },
                                                        required: {
                                                            let mut required = schemars::Set::new();
                                                            required.insert("decrease_allowance".to_owned());
                                                            required
                                                        },
                                                        additional_properties: Some(Box::new(false.into())),
                                                        ..Default::default()
                                                    }),
                                                ),
                                                ..Default::default()
                                            }),
                                            schemars::schema::Metadata {
                                                description: Some(
                                                    "Only with \"approval\" extension. Lowers the spender's access of tokens from the owner's (env.sender) account by amount. If expires is Some(), overwrites current allowance expiration with this one."
                                                        .to_owned(),
                                                ),
                                                ..Default::default()
                                            },
                                        ),
                                        schemars::_private::apply_metadata(
                                            schemars::schema::Schema::Object(schemars::schema::SchemaObject {
                                                instance_type: Some(
                                                    schemars::schema::InstanceType::Object.into(),
                                                ),
                                                object: Some(
                                                    Box::new(schemars::schema::ObjectValidation {
                                                        properties: {
                                                            let mut props = schemars::Map::new();
                                                            props
                                                                .insert(
                                                                    "transfer_from".to_owned(),
                                                                    {
                                                                        let mut schema_object = schemars::schema::SchemaObject {
                                                                            instance_type: Some(
                                                                                schemars::schema::InstanceType::Object.into(),
                                                                            ),
                                                                            ..Default::default()
                                                                        };
                                                                        let object_validation = schema_object.object();
                                                                        object_validation
                                                                            .additional_properties = Some(Box::new(false.into()));
                                                                        {
                                                                            object_validation
                                                                                .properties
                                                                                .insert("owner".to_owned(), gen.subschema_for::<String>());
                                                                            if !<String as schemars::JsonSchema>::_schemars_private_is_option() {
                                                                                object_validation.required.insert("owner".to_owned());
                                                                            }
                                                                        }
                                                                        {
                                                                            object_validation
                                                                                .properties
                                                                                .insert(
                                                                                    "recipient".to_owned(),
                                                                                    gen.subschema_for::<String>(),
                                                                                );
                                                                            if !<String as schemars::JsonSchema>::_schemars_private_is_option() {
                                                                                object_validation.required.insert("recipient".to_owned());
                                                                            }
                                                                        }
                                                                        {
                                                                            object_validation
                                                                                .properties
                                                                                .insert(
                                                                                    "amount".to_owned(),
                                                                                    gen.subschema_for::<Uint128>(),
                                                                                );
                                                                            if !<Uint128 as schemars::JsonSchema>::_schemars_private_is_option() {
                                                                                object_validation.required.insert("amount".to_owned());
                                                                            }
                                                                        }
                                                                        schemars::schema::Schema::Object(schema_object)
                                                                    },
                                                                );
                                                            props
                                                        },
                                                        required: {
                                                            let mut required = schemars::Set::new();
                                                            required.insert("transfer_from".to_owned());
                                                            required
                                                        },
                                                        additional_properties: Some(Box::new(false.into())),
                                                        ..Default::default()
                                                    }),
                                                ),
                                                ..Default::default()
                                            }),
                                            schemars::schema::Metadata {
                                                description: Some(
                                                    "Only with \"approval\" extension. Transfers amount tokens from owner -> recipient if `env.sender` has sufficient pre-approval."
                                                        .to_owned(),
                                                ),
                                                ..Default::default()
                                            },
                                        ),
                                        schemars::_private::apply_metadata(
                                            schemars::schema::Schema::Object(schemars::schema::SchemaObject {
                                                instance_type: Some(
                                                    schemars::schema::InstanceType::Object.into(),
                                                ),
                                                object: Some(
                                                    Box::new(schemars::schema::ObjectValidation {
                                                        properties: {
                                                            let mut props = schemars::Map::new();
                                                            props
                                                                .insert(
                                                                    "send_from".to_owned(),
                                                                    {
                                                                        let mut schema_object = schemars::schema::SchemaObject {
                                                                            instance_type: Some(
                                                                                schemars::schema::InstanceType::Object.into(),
                                                                            ),
                                                                            ..Default::default()
                                                                        };
                                                                        let object_validation = schema_object.object();
                                                                        object_validation
                                                                            .additional_properties = Some(Box::new(false.into()));
                                                                        {
                                                                            object_validation
                                                                                .properties
                                                                                .insert("owner".to_owned(), gen.subschema_for::<String>());
                                                                            if !<String as schemars::JsonSchema>::_schemars_private_is_option() {
                                                                                object_validation.required.insert("owner".to_owned());
                                                                            }
                                                                        }
                                                                        {
                                                                            object_validation
                                                                                .properties
                                                                                .insert(
                                                                                    "contract".to_owned(),
                                                                                    gen.subschema_for::<String>(),
                                                                                );
                                                                            if !<String as schemars::JsonSchema>::_schemars_private_is_option() {
                                                                                object_validation.required.insert("contract".to_owned());
                                                                            }
                                                                        }
                                                                        {
                                                                            object_validation
                                                                                .properties
                                                                                .insert(
                                                                                    "amount".to_owned(),
                                                                                    gen.subschema_for::<Uint128>(),
                                                                                );
                                                                            if !<Uint128 as schemars::JsonSchema>::_schemars_private_is_option() {
                                                                                object_validation.required.insert("amount".to_owned());
                                                                            }
                                                                        }
                                                                        {
                                                                            object_validation
                                                                                .properties
                                                                                .insert("msg".to_owned(), gen.subschema_for::<Binary>());
                                                                            if !<Binary as schemars::JsonSchema>::_schemars_private_is_option() {
                                                                                object_validation.required.insert("msg".to_owned());
                                                                            }
                                                                        }
                                                                        schemars::schema::Schema::Object(schema_object)
                                                                    },
                                                                );
                                                            props
                                                        },
                                                        required: {
                                                            let mut required = schemars::Set::new();
                                                            required.insert("send_from".to_owned());
                                                            required
                                                        },
                                                        additional_properties: Some(Box::new(false.into())),
                                                        ..Default::default()
                                                    }),
                                                ),
                                                ..Default::default()
                                            }),
                                            schemars::schema::Metadata {
                                                description: Some(
                                                    "Only with \"approval\" extension. Sends amount tokens from owner -> contract if `env.sender` has sufficient pre-approval."
                                                        .to_owned(),
                                                ),
                                                ..Default::default()
                                            },
                                        ),
                                        schemars::_private::apply_metadata(
                                            schemars::schema::Schema::Object(schemars::schema::SchemaObject {
                                                instance_type: Some(
                                                    schemars::schema::InstanceType::Object.into(),
                                                ),
                                                object: Some(
                                                    Box::new(schemars::schema::ObjectValidation {
                                                        properties: {
                                                            let mut props = schemars::Map::new();
                                                            props
                                                                .insert(
                                                                    "burn_from".to_owned(),
                                                                    {
                                                                        let mut schema_object = schemars::schema::SchemaObject {
                                                                            instance_type: Some(
                                                                                schemars::schema::InstanceType::Object.into(),
                                                                            ),
                                                                            ..Default::default()
                                                                        };
                                                                        let object_validation = schema_object.object();
                                                                        object_validation
                                                                            .additional_properties = Some(Box::new(false.into()));
                                                                        {
                                                                            object_validation
                                                                                .properties
                                                                                .insert("owner".to_owned(), gen.subschema_for::<String>());
                                                                            if !<String as schemars::JsonSchema>::_schemars_private_is_option() {
                                                                                object_validation.required.insert("owner".to_owned());
                                                                            }
                                                                        }
                                                                        {
                                                                            object_validation
                                                                                .properties
                                                                                .insert(
                                                                                    "amount".to_owned(),
                                                                                    gen.subschema_for::<Uint128>(),
                                                                                );
                                                                            if !<Uint128 as schemars::JsonSchema>::_schemars_private_is_option() {
                                                                                object_validation.required.insert("amount".to_owned());
                                                                            }
                                                                        }
                                                                        schemars::schema::Schema::Object(schema_object)
                                                                    },
                                                                );
                                                            props
                                                        },
                                                        required: {
                                                            let mut required = schemars::Set::new();
                                                            required.insert("burn_from".to_owned());
                                                            required
                                                        },
                                                        additional_properties: Some(Box::new(false.into())),
                                                        ..Default::default()
                                                    }),
                                                ),
                                                ..Default::default()
                                            }),
                                            schemars::schema::Metadata {
                                                description: Some(
                                                    "Only with \"approval\" extension. Destroys tokens forever"
                                                        .to_owned(),
                                                ),
                                                ..Default::default()
                                            },
                                        ),
                                        schemars::_private::apply_metadata(
                                            schemars::schema::Schema::Object(schemars::schema::SchemaObject {
                                                instance_type: Some(
                                                    schemars::schema::InstanceType::Object.into(),
                                                ),
                                                object: Some(
                                                    Box::new(schemars::schema::ObjectValidation {
                                                        properties: {
                                                            let mut props = schemars::Map::new();
                                                            props
                                                                .insert(
                                                                    "mint".to_owned(),
                                                                    {
                                                                        let mut schema_object = schemars::schema::SchemaObject {
                                                                            instance_type: Some(
                                                                                schemars::schema::InstanceType::Object.into(),
                                                                            ),
                                                                            ..Default::default()
                                                                        };
                                                                        let object_validation = schema_object.object();
                                                                        object_validation
                                                                            .additional_properties = Some(Box::new(false.into()));
                                                                        {
                                                                            object_validation
                                                                                .properties
                                                                                .insert(
                                                                                    "recipient".to_owned(),
                                                                                    gen.subschema_for::<String>(),
                                                                                );
                                                                            if !<String as schemars::JsonSchema>::_schemars_private_is_option() {
                                                                                object_validation.required.insert("recipient".to_owned());
                                                                            }
                                                                        }
                                                                        {
                                                                            object_validation
                                                                                .properties
                                                                                .insert(
                                                                                    "amount".to_owned(),
                                                                                    gen.subschema_for::<Uint128>(),
                                                                                );
                                                                            if !<Uint128 as schemars::JsonSchema>::_schemars_private_is_option() {
                                                                                object_validation.required.insert("amount".to_owned());
                                                                            }
                                                                        }
                                                                        schemars::schema::Schema::Object(schema_object)
                                                                    },
                                                                );
                                                            props
                                                        },
                                                        required: {
                                                            let mut required = schemars::Set::new();
                                                            required.insert("mint".to_owned());
                                                            required
                                                        },
                                                        additional_properties: Some(Box::new(false.into())),
                                                        ..Default::default()
                                                    }),
                                                ),
                                                ..Default::default()
                                            }),
                                            schemars::schema::Metadata {
                                                description: Some(
                                                    "Only with the \"mintable\" extension. If authorized, creates amount new tokens and adds to the recipient balance."
                                                        .to_owned(),
                                                ),
                                                ..Default::default()
                                            },
                                        ),
                                        schemars::_private::apply_metadata(
                                            schemars::schema::Schema::Object(schemars::schema::SchemaObject {
                                                instance_type: Some(
                                                    schemars::schema::InstanceType::Object.into(),
                                                ),
                                                object: Some(
                                                    Box::new(schemars::schema::ObjectValidation {
                                                        properties: {
                                                            let mut props = schemars::Map::new();
                                                            props
                                                                .insert(
                                                                    "update_minter".to_owned(),
                                                                    {
                                                                        let mut schema_object = schemars::schema::SchemaObject {
                                                                            instance_type: Some(
                                                                                schemars::schema::InstanceType::Object.into(),
                                                                            ),
                                                                            ..Default::default()
                                                                        };
                                                                        let object_validation = schema_object.object();
                                                                        object_validation
                                                                            .additional_properties = Some(Box::new(false.into()));
                                                                        {
                                                                            object_validation
                                                                                .properties
                                                                                .insert(
                                                                                    "new_minter".to_owned(),
                                                                                    gen.subschema_for::<Option<String>>(),
                                                                                );
                                                                            if !<Option<
                                                                                String,
                                                                            > as schemars::JsonSchema>::_schemars_private_is_option() {
                                                                                object_validation.required.insert("new_minter".to_owned());
                                                                            }
                                                                        }
                                                                        schemars::schema::Schema::Object(schema_object)
                                                                    },
                                                                );
                                                            props
                                                        },
                                                        required: {
                                                            let mut required = schemars::Set::new();
                                                            required.insert("update_minter".to_owned());
                                                            required
                                                        },
                                                        additional_properties: Some(Box::new(false.into())),
                                                        ..Default::default()
                                                    }),
                                                ),
                                                ..Default::default()
                                            }),
                                            schemars::schema::Metadata {
                                                description: Some(
                                                    "Only with the \"mintable\" extension. The current minter may set a new minter. Setting the minter to None will remove the token's minter forever."
                                                        .to_owned(),
                                                ),
                                                ..Default::default()
                                            },
                                        ),
                                        schemars::_private::apply_metadata(
                                            schemars::schema::Schema::Object(schemars::schema::SchemaObject {
                                                instance_type: Some(
                                                    schemars::schema::InstanceType::Object.into(),
                                                ),
                                                object: Some(
                                                    Box::new(schemars::schema::ObjectValidation {
                                                        properties: {
                                                            let mut props = schemars::Map::new();
                                                            props
                                                                .insert(
                                                                    "update_marketing".to_owned(),
                                                                    {
                                                                        let mut schema_object = schemars::schema::SchemaObject {
                                                                            instance_type: Some(
                                                                                schemars::schema::InstanceType::Object.into(),
                                                                            ),
                                                                            ..Default::default()
                                                                        };
                                                                        let object_validation = schema_object.object();
                                                                        object_validation
                                                                            .additional_properties = Some(Box::new(false.into()));
                                                                        {
                                                                            object_validation
                                                                                .properties
                                                                                .insert(
                                                                                    "project".to_owned(),
                                                                                    schemars::_private::apply_metadata(
                                                                                        gen.subschema_for::<Option<String>>(),
                                                                                        schemars::schema::Metadata {
                                                                                            description: Some(
                                                                                                "A URL pointing to the project behind this token."
                                                                                                    .to_owned(),
                                                                                            ),
                                                                                            ..Default::default()
                                                                                        },
                                                                                    ),
                                                                                );
                                                                            if !<Option<
                                                                                String,
                                                                            > as schemars::JsonSchema>::_schemars_private_is_option() {
                                                                                object_validation.required.insert("project".to_owned());
                                                                            }
                                                                        }
                                                                        {
                                                                            object_validation
                                                                                .properties
                                                                                .insert(
                                                                                    "description".to_owned(),
                                                                                    schemars::_private::apply_metadata(
                                                                                        gen.subschema_for::<Option<String>>(),
                                                                                        schemars::schema::Metadata {
                                                                                            description: Some(
                                                                                                "A longer description of the token and it's utility. Designed for tooltips or such"
                                                                                                    .to_owned(),
                                                                                            ),
                                                                                            ..Default::default()
                                                                                        },
                                                                                    ),
                                                                                );
                                                                            if !<Option<
                                                                                String,
                                                                            > as schemars::JsonSchema>::_schemars_private_is_option() {
                                                                                object_validation.required.insert("description".to_owned());
                                                                            }
                                                                        }
                                                                        {
                                                                            object_validation
                                                                                .properties
                                                                                .insert(
                                                                                    "marketing".to_owned(),
                                                                                    schemars::_private::apply_metadata(
                                                                                        gen.subschema_for::<Option<String>>(),
                                                                                        schemars::schema::Metadata {
                                                                                            description: Some(
                                                                                                "The address (if any) who can update this data structure"
                                                                                                    .to_owned(),
                                                                                            ),
                                                                                            ..Default::default()
                                                                                        },
                                                                                    ),
                                                                                );
                                                                            if !<Option<
                                                                                String,
                                                                            > as schemars::JsonSchema>::_schemars_private_is_option() {
                                                                                object_validation.required.insert("marketing".to_owned());
                                                                            }
                                                                        }
                                                                        schemars::schema::Schema::Object(schema_object)
                                                                    },
                                                                );
                                                            props
                                                        },
                                                        required: {
                                                            let mut required = schemars::Set::new();
                                                            required.insert("update_marketing".to_owned());
                                                            required
                                                        },
                                                        additional_properties: Some(Box::new(false.into())),
                                                        ..Default::default()
                                                    }),
                                                ),
                                                ..Default::default()
                                            }),
                                            schemars::schema::Metadata {
                                                description: Some(
                                                    "Only with the \"marketing\" extension. If authorized, updates marketing metadata. Setting None/null for any of these will leave it unchanged. Setting Some(\"\") will clear this field on the contract storage"
                                                        .to_owned(),
                                                ),
                                                ..Default::default()
                                            },
                                        ),
                                        schemars::_private::apply_metadata(
                                            schemars::schema::Schema::Object(schemars::schema::SchemaObject {
                                                instance_type: Some(
                                                    schemars::schema::InstanceType::Object.into(),
                                                ),
                                                object: Some(
                                                    Box::new(schemars::schema::ObjectValidation {
                                                        properties: {
                                                            let mut props = schemars::Map::new();
                                                            props
                                                                .insert(
                                                                    "upload_logo".to_owned(),
                                                                    gen.subschema_for::<Logo>(),
                                                                );
                                                            props
                                                        },
                                                        required: {
                                                            let mut required = schemars::Set::new();
                                                            required.insert("upload_logo".to_owned());
                                                            required
                                                        },
                                                        additional_properties: Some(Box::new(false.into())),
                                                        ..Default::default()
                                                    }),
                                                ),
                                                ..Default::default()
                                            }),
                                            schemars::schema::Metadata {
                                                description: Some(
                                                    "If set as the \"marketing\" role on the contract, upload a new URL, SVG, or PNG for the token"
                                                        .to_owned(),
                                                ),
                                                ..Default::default()
                                            },
                                        ),
                                    ]),
                                ),
                            ),
                            ..Default::default()
                        }),
                    ),
                    ..Default::default()
                })
            }
        }
    };
}
