rust_iso20022 0.1.1

// @generated by src/bin/codegen.rs from the ISO 20022 XSD schema. Do not edit.
#![allow(clippy::all)]
#![allow(non_snake_case, non_camel_case_types, dead_code, unused_imports)]
// yaserde_derive 0.7 emits trait impls inside nested choice submodules, which
// trips the `non_local_definitions` lint on recent rustc. The generated code is
// correct; silence the lint here.
#![allow(non_local_definitions)]
use std::str::FromStr;
use crate::validate::Validate;
use yaserde_derive::{YaDeserialize, YaSerialize};

// pub type Document = Document;
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct Account27 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

    #[yaserde(rename = "AcctSvcr")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctSvcr"))]
    pub acct_svcr: PartyIdentification139,
}

impl Validate for Account27 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct Account38 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

    #[yaserde(rename = "AcctNm")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctNm"))]
    pub acct_nm: Max35Text,

    #[yaserde(rename = "Dsgnt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dsgnt"))]
    pub dsgnt: Max35Text,

    #[yaserde(rename = "Svcr")]
    #[cfg_attr(feature = "serde", serde(rename = "Svcr"))]
    pub svcr: PartyIdentification139,

    #[yaserde(rename = "SubAcctDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "SubAcctDtls"))]
    pub sub_acct_dtls: SubAccount5,

    #[yaserde(rename = "BlckChainAdrOrWllt")]
    #[cfg_attr(feature = "serde", serde(rename = "BlckChainAdrOrWllt"))]
    pub blck_chain_adr_or_wllt: BlockChainAddressWallet3,
}

impl Validate for Account38 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ActiveCurrencyAnd13DecimalAmountSimpleType (pub String);
crate::simple_type!(ActiveCurrencyAnd13DecimalAmountSimpleType);

impl Validate for ActiveCurrencyAnd13DecimalAmountSimpleType {
    fn validate(&self) -> Result<(), String> { 
        if self.0 < "0".parse::<String>().unwrap() {
            return Err(format!("MinInclusive validation error: invalid value of 0! \nExpected: 0 >= 0.\nActual: 0 == {}", self.0));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct ActiveCurrencyAnd13DecimalAmount {
    #[yaserde(text)]
    pub value: String,
    #[yaserde(attribute, rename = "Ccy")]
    #[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
    pub ccy: ActiveCurrencyCode,
}

impl Validate for ActiveCurrencyAnd13DecimalAmount {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ActiveCurrencyAndAmountSimpleType (pub String);
crate::simple_type!(ActiveCurrencyAndAmountSimpleType);

impl Validate for ActiveCurrencyAndAmountSimpleType {
    fn validate(&self) -> Result<(), String> { 
        if self.0 < "0".parse::<String>().unwrap() {
            return Err(format!("MinInclusive validation error: invalid value of 0! \nExpected: 0 >= 0.\nActual: 0 == {}", self.0));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct ActiveCurrencyAndAmount {
    #[yaserde(text)]
    pub value: String,
    #[yaserde(attribute, rename = "Ccy")]
    #[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
    pub ccy: ActiveCurrencyCode,
}

impl Validate for ActiveCurrencyAndAmount {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ActiveCurrencyCode (pub String);
crate::simple_type!(ActiveCurrencyCode);

impl Validate for ActiveCurrencyCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ActiveOrHistoricCurrencyAnd13DecimalAmountSimpleType (pub String);
crate::simple_type!(ActiveOrHistoricCurrencyAnd13DecimalAmountSimpleType);

impl Validate for ActiveOrHistoricCurrencyAnd13DecimalAmountSimpleType {
    fn validate(&self) -> Result<(), String> { 
        if self.0 < "0".parse::<String>().unwrap() {
            return Err(format!("MinInclusive validation error: invalid value of 0! \nExpected: 0 >= 0.\nActual: 0 == {}", self.0));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct ActiveOrHistoricCurrencyAnd13DecimalAmount {
    #[yaserde(text)]
    pub value: String,
    #[yaserde(attribute, rename = "Ccy")]
    #[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
    pub ccy: ActiveOrHistoricCurrencyCode,
}

impl Validate for ActiveOrHistoricCurrencyAnd13DecimalAmount {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ActiveOrHistoricCurrencyAndAmountSimpleType (pub String);
crate::simple_type!(ActiveOrHistoricCurrencyAndAmountSimpleType);

impl Validate for ActiveOrHistoricCurrencyAndAmountSimpleType {
    fn validate(&self) -> Result<(), String> { 
        if self.0 < "0".parse::<String>().unwrap() {
            return Err(format!("MinInclusive validation error: invalid value of 0! \nExpected: 0 >= 0.\nActual: 0 == {}", self.0));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct ActiveOrHistoricCurrencyAndAmount {
    #[yaserde(text)]
    pub value: String,
    #[yaserde(attribute, rename = "Ccy")]
    #[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
    pub ccy: ActiveOrHistoricCurrencyCode,
}

impl Validate for ActiveOrHistoricCurrencyAndAmount {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ActiveOrHistoricCurrencyCode (pub String);
crate::simple_type!(ActiveOrHistoricCurrencyCode);

impl Validate for ActiveOrHistoricCurrencyCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct AdditionalReference10 {
    #[yaserde(rename = "Ref")]
    #[cfg_attr(feature = "serde", serde(rename = "Ref"))]
    pub _ref: Max35Text,

    #[yaserde(rename = "RefIssr")]
    #[cfg_attr(feature = "serde", serde(rename = "RefIssr"))]
    pub ref_issr: PartyIdentification139,

    #[yaserde(rename = "MsgNm")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgNm"))]
    pub msg_nm: Max35Text,
}

impl Validate for AdditionalReference10 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct AdditionalReference11 {
    #[yaserde(rename = "Ref")]
    #[cfg_attr(feature = "serde", serde(rename = "Ref"))]
    pub _ref: Max35Text,

    #[yaserde(rename = "RefIssr")]
    #[cfg_attr(feature = "serde", serde(rename = "RefIssr"))]
    pub ref_issr: PartyIdentification139,

    #[yaserde(rename = "MsgNm")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgNm"))]
    pub msg_nm: Max35Text,
}

impl Validate for AdditionalReference11 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum AddressType2Code {
    #[yaserde(rename = "ADDR")]
    #[cfg_attr(feature = "serde", serde(rename = "ADDR"))]
    Addr,
    #[yaserde(rename = "PBOX")]
    #[cfg_attr(feature = "serde", serde(rename = "PBOX"))]
    Pbox,
    #[yaserde(rename = "HOME")]
    #[cfg_attr(feature = "serde", serde(rename = "HOME"))]
    Home,
    #[yaserde(rename = "BIZZ")]
    #[cfg_attr(feature = "serde", serde(rename = "BIZZ"))]
    Bizz,
    #[yaserde(rename = "MLTO")]
    #[cfg_attr(feature = "serde", serde(rename = "MLTO"))]
    Mlto,
    #[yaserde(rename = "DLVY")]
    #[cfg_attr(feature = "serde", serde(rename = "DLVY"))]
    Dlvy,
    __Unknown__(String),
}

impl Default for AddressType2Code {
    fn default() -> AddressType2Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for AddressType2Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct AlternatePartyIdentification7 {
    #[yaserde(rename = "IdTp")]
    #[cfg_attr(feature = "serde", serde(rename = "IdTp"))]
    pub id_tp: IdentificationType42Choice,

    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: CountryCode,

    #[yaserde(rename = "AltrnId")]
    #[cfg_attr(feature = "serde", serde(rename = "AltrnId"))]
    pub altrn_id: Max35Text,
}

impl Validate for AlternatePartyIdentification7 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct AlternateSecurityIdentification7 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

    #[yaserde(rename = "IdSrc")]
    #[cfg_attr(feature = "serde", serde(rename = "IdSrc"))]
    pub id_src: IdentificationSource1Choice,
}

impl Validate for AlternateSecurityIdentification7 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct AnyBICDec2014Identifier (pub String);
crate::simple_type!(AnyBICDec2014Identifier);

impl Validate for AnyBICDec2014Identifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct BaseOneRate (pub String);
crate::simple_type!(BaseOneRate);

impl Validate for BaseOneRate {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct BelgianIdentifier (pub String);
crate::simple_type!(BelgianIdentifier);

impl Validate for BelgianIdentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum BeneficiaryCertificationCompletion1Code {
    #[yaserde(rename = "NCER")]
    #[cfg_attr(feature = "serde", serde(rename = "NCER"))]
    Ncer,
    #[yaserde(rename = "ELEC")]
    #[cfg_attr(feature = "serde", serde(rename = "ELEC"))]
    Elec,
    #[yaserde(rename = "PHYS")]
    #[cfg_attr(feature = "serde", serde(rename = "PHYS"))]
    Phys,
    __Unknown__(String),
}

impl Default for BeneficiaryCertificationCompletion1Code {
    fn default() -> BeneficiaryCertificationCompletion1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for BeneficiaryCertificationCompletion1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct BlockChainAddressWallet3 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max140Text,

    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: GenericIdentification30,

    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max70Text,
}

impl Validate for BlockChainAddressWallet3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Bloomberg2Identifier (pub String);
crate::simple_type!(Bloomberg2Identifier);

impl Validate for Bloomberg2Identifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum BusinessFlowType1Code {
    #[yaserde(rename = "SLDP")]
    #[cfg_attr(feature = "serde", serde(rename = "SLDP"))]
    Sldp,
    #[yaserde(rename = "SLRP")]
    #[cfg_attr(feature = "serde", serde(rename = "SLRP"))]
    Slrp,
    #[yaserde(rename = "DLPR")]
    #[cfg_attr(feature = "serde", serde(rename = "DLPR"))]
    Dlpr,
    __Unknown__(String),
}

impl Default for BusinessFlowType1Code {
    fn default() -> BusinessFlowType1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for BusinessFlowType1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Cusipidentifier (pub String);
crate::simple_type!(Cusipidentifier);

impl Validate for Cusipidentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct ChargeBasis2Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<TaxationBasis5Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for ChargeBasis2Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum ChargeBearer1Code {
    #[yaserde(rename = "OUR")]
    #[cfg_attr(feature = "serde", serde(rename = "OUR"))]
    Our,
    #[yaserde(rename = "BEN")]
    #[cfg_attr(feature = "serde", serde(rename = "BEN"))]
    Ben,
    #[yaserde(rename = "SHA")]
    #[cfg_attr(feature = "serde", serde(rename = "SHA"))]
    Sha,
    __Unknown__(String),
}

impl Default for ChargeBearer1Code {
    fn default() -> ChargeBearer1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for ChargeBearer1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct ChargeOrCommissionDiscount1 {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: PercentageRate,

    #[yaserde(rename = "Bsis")]
    #[cfg_attr(feature = "serde", serde(rename = "Bsis"))]
    pub bsis: WaivingInstruction2Choice,
}

impl Validate for ChargeOrCommissionDiscount1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct ChargeOrCommissionDiscount2 {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: PercentageRate,

    #[yaserde(rename = "Bsis")]
    #[cfg_attr(feature = "serde", serde(rename = "Bsis"))]
    pub bsis: WaivingInstruction2Choice,
}

impl Validate for ChargeOrCommissionDiscount2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct ChargePaymentMethod1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ChargePaymentMethod1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for ChargePaymentMethod1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum ChargePaymentMethod1Code {
    #[yaserde(rename = "CASH")]
    #[cfg_attr(feature = "serde", serde(rename = "CASH"))]
    Cash,
    #[yaserde(rename = "UNIT")]
    #[cfg_attr(feature = "serde", serde(rename = "UNIT"))]
    Unit,
    __Unknown__(String),
}

impl Default for ChargePaymentMethod1Code {
    fn default() -> ChargePaymentMethod1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for ChargePaymentMethod1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct ChargeType10Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<InvestmentFundFee3Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for ChargeType10Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct ChargeType6Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<InvestmentFundFee2Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for ChargeType6Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ConsolidatedTapeAssociationIdentifier (pub String);
crate::simple_type!(ConsolidatedTapeAssociationIdentifier);

impl Validate for ConsolidatedTapeAssociationIdentifier {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 35 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 35 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct ContactIdentification2 {
    #[yaserde(rename = "NmPrfx")]
    #[cfg_attr(feature = "serde", serde(rename = "NmPrfx"))]
    pub nm_prfx: NamePrefix1Code,

    #[yaserde(rename = "GvnNm")]
    #[cfg_attr(feature = "serde", serde(rename = "GvnNm"))]
    pub gvn_nm: Max35Text,

    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max35Text,

    #[yaserde(rename = "PhneNb")]
    #[cfg_attr(feature = "serde", serde(rename = "PhneNb"))]
    pub phne_nb: PhoneNumber,

    #[yaserde(rename = "MobNb")]
    #[cfg_attr(feature = "serde", serde(rename = "MobNb"))]
    pub mob_nb: PhoneNumber,

    #[yaserde(rename = "FaxNb")]
    #[cfg_attr(feature = "serde", serde(rename = "FaxNb"))]
    pub fax_nb: PhoneNumber,

    #[yaserde(rename = "EmailAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "EmailAdr"))]
    pub email_adr: Max256Text,
}

impl Validate for ContactIdentification2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct CopyInformation5 {
    #[yaserde(rename = "CpyInd")]
    #[cfg_attr(feature = "serde", serde(rename = "CpyInd"))]
    pub cpy_ind: YesNoIndicator,

    #[yaserde(rename = "OrgnlRcvr")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlRcvr"))]
    pub orgnl_rcvr: AnyBICDec2014Identifier,
}

impl Validate for CopyInformation5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct CountryCode (pub String);
crate::simple_type!(CountryCode);

impl Validate for CountryCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Dti2024Identifier (pub String);
crate::simple_type!(Dti2024Identifier);

impl Validate for Dti2024Identifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct DateAndDateTime2Choice {
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Option<Isodate>,
    #[yaserde(rename = "DtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "DtTm"))]
    pub dt_tm: Option<IsodateTime>,
}

impl Validate for DateAndDateTime2Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct DecimalNumber (pub String);
crate::simple_type!(DecimalNumber);

impl Validate for DecimalNumber {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct DeliverInformation23 {
    #[yaserde(rename = "Trfr")]
    #[cfg_attr(feature = "serde", serde(rename = "Trfr"))]
    pub trfr: PartyIdentification139,

    #[yaserde(rename = "TrfrRegdAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "TrfrRegdAcct"))]
    pub trfr_regd_acct: Account38,

    #[yaserde(rename = "IntrmyInf")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrmyInf"))]
    pub intrmy_inf: Vec<Intermediary43>,

    #[yaserde(rename = "SctiesForm")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesForm"))]
    pub scties_form: FormOfSecurity1Code,

    #[yaserde(rename = "DmtrlsdInd")]
    #[cfg_attr(feature = "serde", serde(rename = "DmtrlsdInd"))]
    pub dmtrlsd_ind: YesNoIndicator,

    #[yaserde(rename = "IncmPref")]
    #[cfg_attr(feature = "serde", serde(rename = "IncmPref"))]
    pub incm_pref: IncomePreference2Code,

    #[yaserde(rename = "BnfcryCertfctnCmpltn")]
    #[cfg_attr(feature = "serde", serde(rename = "BnfcryCertfctnCmpltn"))]
    pub bnfcry_certfctn_cmpltn: BeneficiaryCertificationCompletion1Code,

    #[yaserde(rename = "ReqdTradDt")]
    #[cfg_attr(feature = "serde", serde(rename = "ReqdTradDt"))]
    pub reqd_trad_dt: Isodate,

    #[yaserde(rename = "ReqdSttlmDt")]
    #[cfg_attr(feature = "serde", serde(rename = "ReqdSttlmDt"))]
    pub reqd_sttlm_dt: Isodate,

    #[yaserde(rename = "FctvSttlmDt")]
    #[cfg_attr(feature = "serde", serde(rename = "FctvSttlmDt"))]
    pub fctv_sttlm_dt: DateAndDateTime2Choice,

    #[yaserde(rename = "SttlmAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmAmt"))]
    pub sttlm_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "StmpDty")]
    #[cfg_attr(feature = "serde", serde(rename = "StmpDty"))]
    pub stmp_dty: StampDutyType2Code,

    #[yaserde(rename = "NetAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "NetAmt"))]
    pub net_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "Fees")]
    #[cfg_attr(feature = "serde", serde(rename = "Fees"))]
    pub fees: Vec<Fees2>,

    #[yaserde(rename = "IndvTax")]
    #[cfg_attr(feature = "serde", serde(rename = "IndvTax"))]
    pub indv_tax: Vec<Tax38>,

    #[yaserde(rename = "FXDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "FXDtls"))]
    pub fx_dtls: Vec<ForeignExchangeTerms37>,

    #[yaserde(rename = "SttlmPtiesDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmPtiesDtls"))]
    pub sttlm_pties_dtls: FundSettlementParameters26,

    #[yaserde(rename = "PhysTrf")]
    #[cfg_attr(feature = "serde", serde(rename = "PhysTrf"))]
    pub phys_trf: PhysicalTransferType1Code,

    #[yaserde(rename = "PhysTrfDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "PhysTrfDtls"))]
    pub phys_trf_dtls: DeliveryParameters4,

    #[yaserde(rename = "ClntRef")]
    #[cfg_attr(feature = "serde", serde(rename = "ClntRef"))]
    pub clnt_ref: AdditionalReference10,
}

impl Validate for DeliverInformation23 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct DeliveryParameters4 {
    #[yaserde(rename = "RegdAdrInd")]
    #[cfg_attr(feature = "serde", serde(rename = "RegdAdrInd"))]
    pub regd_adr_ind: YesNoIndicator,

    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: NameAndAddress4,

    #[yaserde(rename = "CtctPrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "CtctPrsn"))]
    pub ctct_prsn: ContactIdentification2,
}

impl Validate for DeliveryParameters4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct DigitalPaymentSettlement3 {
    #[yaserde(rename = "FinInstrmId")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrmId"))]
    pub fin_instrm_id: SecurityIdentification50,

    #[yaserde(rename = "Qty")]
    #[cfg_attr(feature = "serde", serde(rename = "Qty"))]
    pub qty: Quantity48Choice,

    #[yaserde(rename = "DgtlLdgrId")]
    #[cfg_attr(feature = "serde", serde(rename = "DgtlLdgrId"))]
    pub dgtl_ldgr_id: Dti2024Identifier,
}

impl Validate for DigitalPaymentSettlement3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum DistributionPolicy1Code {
    #[yaserde(rename = "DIST")]
    #[cfg_attr(feature = "serde", serde(rename = "DIST"))]
    Dist,
    #[yaserde(rename = "ACCU")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCU"))]
    Accu,
    __Unknown__(String),
}

impl Default for DistributionPolicy1Code {
    fn default() -> DistributionPolicy1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for DistributionPolicy1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct Document {
    #[yaserde(rename = "TrfInConf")]
    #[cfg_attr(feature = "serde", serde(rename = "TrfInConf"))]
    pub trf_in_conf: TransferInConfirmationV10,
}

impl Validate for Document {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct DutchIdentifier (pub String);
crate::simple_type!(DutchIdentifier);

impl Validate for DutchIdentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct EuroclearClearstreamIdentifier (pub String);
crate::simple_type!(EuroclearClearstreamIdentifier);

impl Validate for EuroclearClearstreamIdentifier {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 12 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 12 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Exact4AlphaNumericText (pub String);
crate::simple_type!(Exact4AlphaNumericText);

impl Validate for Exact4AlphaNumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct ExemptionReason1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<TaxExemptReason1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for ExemptionReason1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct Extension1 {
    #[yaserde(rename = "PlcAndNm")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcAndNm"))]
    pub plc_and_nm: Max350Text,

    #[yaserde(rename = "Txt")]
    #[cfg_attr(feature = "serde", serde(rename = "Txt"))]
    pub txt: Max350Text,
}

impl Validate for Extension1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct Fee11 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: ChargeType10Choice,

    #[yaserde(rename = "Bsis")]
    #[cfg_attr(feature = "serde", serde(rename = "Bsis"))]
    pub bsis: ChargeBasis2Choice,

    #[yaserde(rename = "StdAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "StdAmt"))]
    pub std_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "StdRate")]
    #[cfg_attr(feature = "serde", serde(rename = "StdRate"))]
    pub std_rate: PercentageRate,

    #[yaserde(rename = "DscntDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "DscntDtls"))]
    pub dscnt_dtls: ChargeOrCommissionDiscount1,

    #[yaserde(rename = "ApldAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "ApldAmt"))]
    pub apld_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "ApldRate")]
    #[cfg_attr(feature = "serde", serde(rename = "ApldRate"))]
    pub apld_rate: PercentageRate,

    #[yaserde(rename = "NonStdSLARef")]
    #[cfg_attr(feature = "serde", serde(rename = "NonStdSLARef"))]
    pub non_std_sla_ref: Max35Text,

    #[yaserde(rename = "RcptId")]
    #[cfg_attr(feature = "serde", serde(rename = "RcptId"))]
    pub rcpt_id: PartyIdentification139,

    #[yaserde(rename = "InftvInd")]
    #[cfg_attr(feature = "serde", serde(rename = "InftvInd"))]
    pub inftv_ind: YesNoIndicator,
}

impl Validate for Fee11 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct Fee7 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: ChargeType6Choice,

    #[yaserde(rename = "Bsis")]
    #[cfg_attr(feature = "serde", serde(rename = "Bsis"))]
    pub bsis: ChargeBasis2Choice,

    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "DscntDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "DscntDtls"))]
    pub dscnt_dtls: ChargeOrCommissionDiscount2,

    #[yaserde(rename = "ChrgBr")]
    #[cfg_attr(feature = "serde", serde(rename = "ChrgBr"))]
    pub chrg_br: ChargeBearer1Code,

    #[yaserde(rename = "RcptId")]
    #[cfg_attr(feature = "serde", serde(rename = "RcptId"))]
    pub rcpt_id: PartyIdentification139,
}

impl Validate for Fee7 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct Fees2 {
    #[yaserde(rename = "ComrclAgrmtRef")]
    #[cfg_attr(feature = "serde", serde(rename = "ComrclAgrmtRef"))]
    pub comrcl_agrmt_ref: Max35Text,

    #[yaserde(rename = "IndvFee")]
    #[cfg_attr(feature = "serde", serde(rename = "IndvFee"))]
    pub indv_fee: Vec<Fee7>,
}

impl Validate for Fees2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct FinancialInstrument116 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: SecurityIdentification46Choice,

    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max350Text,

    #[yaserde(rename = "ShrtNm")]
    #[cfg_attr(feature = "serde", serde(rename = "ShrtNm"))]
    pub shrt_nm: Max35Text,

    #[yaserde(rename = "SplmtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "SplmtryId"))]
    pub splmtry_id: Max35Text,

    #[yaserde(rename = "ClssTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ClssTp"))]
    pub clss_tp: Max35Text,

    #[yaserde(rename = "SctiesForm")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesForm"))]
    pub scties_form: FormOfSecurity1Code,

    #[yaserde(rename = "DstrbtnPlcy")]
    #[cfg_attr(feature = "serde", serde(rename = "DstrbtnPlcy"))]
    pub dstrbtn_plcy: DistributionPolicy1Code,

    #[yaserde(rename = "DmtrlsdInd")]
    #[cfg_attr(feature = "serde", serde(rename = "DmtrlsdInd"))]
    pub dmtrlsd_ind: YesNoIndicator,
}

impl Validate for FinancialInstrument116 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum FinancialInstrumentIdentificationType1Code {
    #[yaserde(rename = "BELC")]
    #[cfg_attr(feature = "serde", serde(rename = "BELC"))]
    Belc,
    #[yaserde(rename = "BLOM")]
    #[cfg_attr(feature = "serde", serde(rename = "BLOM"))]
    Blom,
    #[yaserde(rename = "CCCD")]
    #[cfg_attr(feature = "serde", serde(rename = "CCCD"))]
    Cccd,
    #[yaserde(rename = "CMED")]
    #[cfg_attr(feature = "serde", serde(rename = "CMED"))]
    Cmed,
    #[yaserde(rename = "COMM")]
    #[cfg_attr(feature = "serde", serde(rename = "COMM"))]
    Comm,
    #[yaserde(rename = "CTAC")]
    #[cfg_attr(feature = "serde", serde(rename = "CTAC"))]
    Ctac,
    #[yaserde(rename = "CUSP")]
    #[cfg_attr(feature = "serde", serde(rename = "CUSP"))]
    Cusp,
    #[yaserde(rename = "FIGC")]
    #[cfg_attr(feature = "serde", serde(rename = "FIGC"))]
    Figc,
    #[yaserde(rename = "FIGG")]
    #[cfg_attr(feature = "serde", serde(rename = "FIGG"))]
    Figg,
    #[yaserde(rename = "FIGI")]
    #[cfg_attr(feature = "serde", serde(rename = "FIGI"))]
    Figi,
    #[yaserde(rename = "ISDU")]
    #[cfg_attr(feature = "serde", serde(rename = "ISDU"))]
    Isdu,
    #[yaserde(rename = "ISDX")]
    #[cfg_attr(feature = "serde", serde(rename = "ISDX"))]
    Isdx,
    #[yaserde(rename = "LCHD")]
    #[cfg_attr(feature = "serde", serde(rename = "LCHD"))]
    Lchd,
    #[yaserde(rename = "OCCS")]
    #[cfg_attr(feature = "serde", serde(rename = "OCCS"))]
    Occs,
    #[yaserde(rename = "OPRA")]
    #[cfg_attr(feature = "serde", serde(rename = "OPRA"))]
    Opra,
    #[yaserde(rename = "RCMD")]
    #[cfg_attr(feature = "serde", serde(rename = "RCMD"))]
    Rcmd,
    #[yaserde(rename = "RICC")]
    #[cfg_attr(feature = "serde", serde(rename = "RICC"))]
    Ricc,
    #[yaserde(rename = "SEDL")]
    #[cfg_attr(feature = "serde", serde(rename = "SEDL"))]
    Sedl,
    #[yaserde(rename = "SICC")]
    #[cfg_attr(feature = "serde", serde(rename = "SICC"))]
    Sicc,
    #[yaserde(rename = "TIKR")]
    #[cfg_attr(feature = "serde", serde(rename = "TIKR"))]
    Tikr,
    #[yaserde(rename = "VALO")]
    #[cfg_attr(feature = "serde", serde(rename = "VALO"))]
    Valo,
    #[yaserde(rename = "WKNR")]
    #[cfg_attr(feature = "serde", serde(rename = "WKNR"))]
    Wknr,
    #[yaserde(rename = "CCDC")]
    #[cfg_attr(feature = "serde", serde(rename = "CCDC"))]
    Ccdc,
    #[yaserde(rename = "DTID")]
    #[cfg_attr(feature = "serde", serde(rename = "DTID"))]
    Dtid,
    __Unknown__(String),
}

impl Default for FinancialInstrumentIdentificationType1Code {
    fn default() -> FinancialInstrumentIdentificationType1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for FinancialInstrumentIdentificationType1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct FinancialInstrumentQuantity33Choice {
    #[yaserde(rename = "Unit")]
    #[cfg_attr(feature = "serde", serde(rename = "Unit"))]
    pub unit: Option<DecimalNumber>,
    #[yaserde(rename = "FaceAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "FaceAmt"))]
    pub face_amt: Option<ImpliedCurrencyAndAmount>,
    #[yaserde(rename = "AmtsdVal")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtsdVal"))]
    pub amtsd_val: Option<ImpliedCurrencyAndAmount>,
    #[yaserde(rename = "DgtlTknUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "DgtlTknUnit"))]
    pub dgtl_tkn_unit: Option<Max30DecimalNumber>,
}

impl Validate for FinancialInstrumentQuantity33Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct ForeignExchangeTerms37 {
    #[yaserde(rename = "ToAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "ToAmt"))]
    pub to_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "FrAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "FrAmt"))]
    pub fr_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "UnitCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitCcy"))]
    pub unit_ccy: ActiveCurrencyCode,

    #[yaserde(rename = "QtdCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "QtdCcy"))]
    pub qtd_ccy: ActiveCurrencyCode,

    #[yaserde(rename = "XchgRate")]
    #[cfg_attr(feature = "serde", serde(rename = "XchgRate"))]
    pub xchg_rate: BaseOneRate,

    #[yaserde(rename = "QtnDt")]
    #[cfg_attr(feature = "serde", serde(rename = "QtnDt"))]
    pub qtn_dt: IsodateTime,

    #[yaserde(rename = "QtgInstn")]
    #[cfg_attr(feature = "serde", serde(rename = "QtgInstn"))]
    pub qtg_instn: PartyIdentification139,
}

impl Validate for ForeignExchangeTerms37 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum FormOfSecurity1Code {
    #[yaserde(rename = "BEAR")]
    #[cfg_attr(feature = "serde", serde(rename = "BEAR"))]
    Bear,
    #[yaserde(rename = "REGD")]
    #[cfg_attr(feature = "serde", serde(rename = "REGD"))]
    Regd,
    __Unknown__(String),
}

impl Default for FormOfSecurity1Code {
    fn default() -> FormOfSecurity1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for FormOfSecurity1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct FundSettlementParameters25 {
    #[yaserde(rename = "TradTxCond")]
    #[cfg_attr(feature = "serde", serde(rename = "TradTxCond"))]
    pub trad_tx_cond: Vec<TradeTransactionCondition8Choice>,

    #[yaserde(rename = "SttlmTxCond")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmTxCond"))]
    pub sttlm_tx_cond: Vec<SettlementTransactionCondition30Choice>,

    #[yaserde(rename = "SctiesSttlmSysId")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesSttlmSysId"))]
    pub scties_sttlm_sys_id: Max35Text,

    #[yaserde(rename = "RcvgSdDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "RcvgSdDtls"))]
    pub rcvg_sd_dtls: SettlementParties131,
}

impl Validate for FundSettlementParameters25 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct FundSettlementParameters26 {
    #[yaserde(rename = "TradTxCond")]
    #[cfg_attr(feature = "serde", serde(rename = "TradTxCond"))]
    pub trad_tx_cond: Vec<TradeTransactionCondition8Choice>,

    #[yaserde(rename = "SttlmTxCond")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmTxCond"))]
    pub sttlm_tx_cond: Vec<SettlementTransactionCondition30Choice>,

    #[yaserde(rename = "SctiesSttlmSysId")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesSttlmSysId"))]
    pub scties_sttlm_sys_id: Max35Text,

    #[yaserde(rename = "DlvrgSdDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "DlvrgSdDtls"))]
    pub dlvrg_sd_dtls: SettlementParties131,
}

impl Validate for FundSettlementParameters26 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct GenericIdentification1 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

    #[yaserde(rename = "SchmeNm")]
    #[cfg_attr(feature = "serde", serde(rename = "SchmeNm"))]
    pub schme_nm: Max35Text,

    #[yaserde(rename = "Issr")]
    #[cfg_attr(feature = "serde", serde(rename = "Issr"))]
    pub issr: Max35Text,
}

impl Validate for GenericIdentification1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct GenericIdentification27 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max4AlphaNumericText,

    #[yaserde(rename = "SchmeNm")]
    #[cfg_attr(feature = "serde", serde(rename = "SchmeNm"))]
    pub schme_nm: Max4AlphaNumericText,

    #[yaserde(rename = "Issr")]
    #[cfg_attr(feature = "serde", serde(rename = "Issr"))]
    pub issr: Max4AlphaNumericText,
}

impl Validate for GenericIdentification27 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct GenericIdentification30 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Exact4AlphaNumericText,

    #[yaserde(rename = "Issr")]
    #[cfg_attr(feature = "serde", serde(rename = "Issr"))]
    pub issr: Max35Text,

    #[yaserde(rename = "SchmeNm")]
    #[cfg_attr(feature = "serde", serde(rename = "SchmeNm"))]
    pub schme_nm: Max35Text,
}

impl Validate for GenericIdentification30 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct GenericIdentification36 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

    #[yaserde(rename = "Issr")]
    #[cfg_attr(feature = "serde", serde(rename = "Issr"))]
    pub issr: Max35Text,

    #[yaserde(rename = "SchmeNm")]
    #[cfg_attr(feature = "serde", serde(rename = "SchmeNm"))]
    pub schme_nm: Max35Text,
}

impl Validate for GenericIdentification36 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct GenericIdentification47 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Exact4AlphaNumericText,

    #[yaserde(rename = "Issr")]
    #[cfg_attr(feature = "serde", serde(rename = "Issr"))]
    pub issr: Max4AlphaNumericText,

    #[yaserde(rename = "SchmeNm")]
    #[cfg_attr(feature = "serde", serde(rename = "SchmeNm"))]
    pub schme_nm: Max4AlphaNumericText,
}

impl Validate for GenericIdentification47 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct GenericIdentification78 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: GenericIdentification30,

    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,
}

impl Validate for GenericIdentification78 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum HoldingsPlanType1Code {
    #[yaserde(rename = "INVP")]
    #[cfg_attr(feature = "serde", serde(rename = "INVP"))]
    Invp,
    #[yaserde(rename = "SWIP")]
    #[cfg_attr(feature = "serde", serde(rename = "SWIP"))]
    Swip,
    #[yaserde(rename = "PLAR")]
    #[cfg_attr(feature = "serde", serde(rename = "PLAR"))]
    Plar,
    __Unknown__(String),
}

impl Default for HoldingsPlanType1Code {
    fn default() -> HoldingsPlanType1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for HoldingsPlanType1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Isinoct2015Identifier (pub String);
crate::simple_type!(Isinoct2015Identifier);

impl Validate for Isinoct2015Identifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Isodate (pub String);
crate::simple_type!(Isodate);

impl Validate for Isodate {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct IsodateTime (pub String);
crate::simple_type!(IsodateTime);

impl Validate for IsodateTime {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct IsoyearMonth (pub String);
crate::simple_type!(IsoyearMonth);

impl Validate for IsoyearMonth {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct IdentificationSource1Choice {
    #[yaserde(rename = "Dmst")]
    #[cfg_attr(feature = "serde", serde(rename = "Dmst"))]
    pub dmst: Option<CountryCode>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max35Text>,
}

impl Validate for IdentificationSource1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct IdentificationSource6Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<FinancialInstrumentIdentificationType1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max35Text>,
}

impl Validate for IdentificationSource6Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct IdentificationType42Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<TypeOfIdentification1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification30>,
}

impl Validate for IdentificationType42Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ImpliedCurrencyAndAmount (pub String);
crate::simple_type!(ImpliedCurrencyAndAmount);

impl Validate for ImpliedCurrencyAndAmount {
    fn validate(&self) -> Result<(), String> { 
        if self.0 < "0".parse::<String>().unwrap() {
            return Err(format!("MinInclusive validation error: invalid value of 0! \nExpected: 0 >= 0.\nActual: 0 == {}", self.0));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum IncomePreference2Code {
    #[yaserde(rename = "CASH")]
    #[cfg_attr(feature = "serde", serde(rename = "CASH"))]
    Cash,
    #[yaserde(rename = "SECU")]
    #[cfg_attr(feature = "serde", serde(rename = "SECU"))]
    Secu,
    __Unknown__(String),
}

impl Default for IncomePreference2Code {
    fn default() -> IncomePreference2Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for IncomePreference2Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct Intermediary43 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: PartyIdentification139,

    #[yaserde(rename = "Acct")]
    #[cfg_attr(feature = "serde", serde(rename = "Acct"))]
    pub acct: Account27,

    #[yaserde(rename = "Role")]
    #[cfg_attr(feature = "serde", serde(rename = "Role"))]
    pub role: Role4Choice,

    #[yaserde(rename = "CtctPrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "CtctPrsn"))]
    pub ctct_prsn: ContactIdentification2,
}

impl Validate for Intermediary43 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct InvestmentAccount83 {
    #[yaserde(rename = "OwnrId")]
    #[cfg_attr(feature = "serde", serde(rename = "OwnrId"))]
    pub ownr_id: Vec<PartyIdentification139>,

    #[yaserde(rename = "AcctId")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctId"))]
    pub acct_id: Max35Text,

    #[yaserde(rename = "AcctNm")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctNm"))]
    pub acct_nm: Max35Text,

    #[yaserde(rename = "AcctDsgnt")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctDsgnt"))]
    pub acct_dsgnt: Max35Text,

    #[yaserde(rename = "AcctSvcr")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctSvcr"))]
    pub acct_svcr: PartyIdentification139,

    #[yaserde(rename = "SubAcctDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "SubAcctDtls"))]
    pub sub_acct_dtls: SubAccount5,

    #[yaserde(rename = "BlckChainAdrOrWllt")]
    #[cfg_attr(feature = "serde", serde(rename = "BlckChainAdrOrWllt"))]
    pub blck_chain_adr_or_wllt: BlockChainAddressWallet3,

    #[yaserde(rename = "IntrmyInf")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrmyInf"))]
    pub intrmy_inf: Vec<Intermediary43>,

    #[yaserde(rename = "SctiesForm")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesForm"))]
    pub scties_form: FormOfSecurity1Code,

    #[yaserde(rename = "DmtrlsdInd")]
    #[cfg_attr(feature = "serde", serde(rename = "DmtrlsdInd"))]
    pub dmtrlsd_ind: YesNoIndicator,

    #[yaserde(rename = "IncmPref")]
    #[cfg_attr(feature = "serde", serde(rename = "IncmPref"))]
    pub incm_pref: IncomePreference2Code,

    #[yaserde(rename = "BnfcryCertfctnCmpltn")]
    #[cfg_attr(feature = "serde", serde(rename = "BnfcryCertfctnCmpltn"))]
    pub bnfcry_certfctn_cmpltn: BeneficiaryCertificationCompletion1Code,

    #[yaserde(rename = "SfkpgPlc")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgPlc"))]
    pub sfkpg_plc: SafekeepingPlaceFormat42Choice,

    #[yaserde(rename = "SttlmPtiesDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmPtiesDtls"))]
    pub sttlm_pties_dtls: FundSettlementParameters25,
}

impl Validate for InvestmentAccount83 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum InvestmentFundFee2Code {
    #[yaserde(rename = "BEND")]
    #[cfg_attr(feature = "serde", serde(rename = "BEND"))]
    Bend,
    #[yaserde(rename = "FEND")]
    #[cfg_attr(feature = "serde", serde(rename = "FEND"))]
    Fend,
    #[yaserde(rename = "TRAN")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAN"))]
    Tran,
    #[yaserde(rename = "POST")]
    #[cfg_attr(feature = "serde", serde(rename = "POST"))]
    Post,
    #[yaserde(rename = "REGF")]
    #[cfg_attr(feature = "serde", serde(rename = "REGF"))]
    Regf,
    #[yaserde(rename = "SHIP")]
    #[cfg_attr(feature = "serde", serde(rename = "SHIP"))]
    Ship,
    #[yaserde(rename = "SPCN")]
    #[cfg_attr(feature = "serde", serde(rename = "SPCN"))]
    Spcn,
    __Unknown__(String),
}

impl Default for InvestmentFundFee2Code {
    fn default() -> InvestmentFundFee2Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for InvestmentFundFee2Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum InvestmentFundFee3Code {
    #[yaserde(rename = "BEND")]
    #[cfg_attr(feature = "serde", serde(rename = "BEND"))]
    Bend,
    #[yaserde(rename = "BRKF")]
    #[cfg_attr(feature = "serde", serde(rename = "BRKF"))]
    Brkf,
    #[yaserde(rename = "CDSC")]
    #[cfg_attr(feature = "serde", serde(rename = "CDSC"))]
    Cdsc,
    #[yaserde(rename = "CBCH")]
    #[cfg_attr(feature = "serde", serde(rename = "CBCH"))]
    Cbch,
    #[yaserde(rename = "DLEV")]
    #[cfg_attr(feature = "serde", serde(rename = "DLEV"))]
    Dlev,
    #[yaserde(rename = "FEND")]
    #[cfg_attr(feature = "serde", serde(rename = "FEND"))]
    Fend,
    #[yaserde(rename = "INIT")]
    #[cfg_attr(feature = "serde", serde(rename = "INIT"))]
    Init,
    #[yaserde(rename = "PREM")]
    #[cfg_attr(feature = "serde", serde(rename = "PREM"))]
    Prem,
    #[yaserde(rename = "CHAR")]
    #[cfg_attr(feature = "serde", serde(rename = "CHAR"))]
    Char,
    #[yaserde(rename = "SWIT")]
    #[cfg_attr(feature = "serde", serde(rename = "SWIT"))]
    Swit,
    #[yaserde(rename = "UCIC")]
    #[cfg_attr(feature = "serde", serde(rename = "UCIC"))]
    Ucic,
    #[yaserde(rename = "COMM")]
    #[cfg_attr(feature = "serde", serde(rename = "COMM"))]
    Comm,
    #[yaserde(rename = "SHIP")]
    #[cfg_attr(feature = "serde", serde(rename = "SHIP"))]
    Ship,
    #[yaserde(rename = "POST")]
    #[cfg_attr(feature = "serde", serde(rename = "POST"))]
    Post,
    #[yaserde(rename = "CDPL")]
    #[cfg_attr(feature = "serde", serde(rename = "CDPL"))]
    Cdpl,
    #[yaserde(rename = "ADDF")]
    #[cfg_attr(feature = "serde", serde(rename = "ADDF"))]
    Addf,
    #[yaserde(rename = "REGF")]
    #[cfg_attr(feature = "serde", serde(rename = "REGF"))]
    Regf,
    #[yaserde(rename = "PENA")]
    #[cfg_attr(feature = "serde", serde(rename = "PENA"))]
    Pena,
    #[yaserde(rename = "NTWK")]
    #[cfg_attr(feature = "serde", serde(rename = "NTWK"))]
    Ntwk,
    __Unknown__(String),
}

impl Default for InvestmentFundFee3Code {
    fn default() -> InvestmentFundFee3Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for InvestmentFundFee3Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum InvestmentFundRole2Code {
    #[yaserde(rename = "FMCO")]
    #[cfg_attr(feature = "serde", serde(rename = "FMCO"))]
    Fmco,
    #[yaserde(rename = "REGI")]
    #[cfg_attr(feature = "serde", serde(rename = "REGI"))]
    Regi,
    #[yaserde(rename = "TRAG")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAG"))]
    Trag,
    #[yaserde(rename = "INTR")]
    #[cfg_attr(feature = "serde", serde(rename = "INTR"))]
    Intr,
    #[yaserde(rename = "DIST")]
    #[cfg_attr(feature = "serde", serde(rename = "DIST"))]
    Dist,
    #[yaserde(rename = "CONC")]
    #[cfg_attr(feature = "serde", serde(rename = "CONC"))]
    Conc,
    #[yaserde(rename = "UCL1")]
    #[cfg_attr(feature = "serde", serde(rename = "UCL1"))]
    Ucl1,
    #[yaserde(rename = "UCL2")]
    #[cfg_attr(feature = "serde", serde(rename = "UCL2"))]
    Ucl2,
    #[yaserde(rename = "TRAN")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAN"))]
    Tran,
    __Unknown__(String),
}

impl Default for InvestmentFundRole2Code {
    fn default() -> InvestmentFundRole2Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for InvestmentFundRole2Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Leiidentifier (pub String);
crate::simple_type!(Leiidentifier);

impl Validate for Leiidentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct MarketPracticeVersion1 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max35Text,

    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: IsoyearMonth,

    #[yaserde(rename = "Nb")]
    #[cfg_attr(feature = "serde", serde(rename = "Nb"))]
    pub nb: Max35Text,
}

impl Validate for MarketPracticeVersion1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max140Text (pub String);
crate::simple_type!(Max140Text);

impl Validate for Max140Text {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 140 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 140 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max16Text (pub String);
crate::simple_type!(Max16Text);

impl Validate for Max16Text {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 16 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 16 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max256Text (pub String);
crate::simple_type!(Max256Text);

impl Validate for Max256Text {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 256 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 256 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max30DecimalNumber (pub String);
crate::simple_type!(Max30DecimalNumber);

impl Validate for Max30DecimalNumber {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max350Text (pub String);
crate::simple_type!(Max350Text);

impl Validate for Max350Text {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 350 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 350 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max35Text (pub String);
crate::simple_type!(Max35Text);

impl Validate for Max35Text {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 35 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 35 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max4AlphaNumericText (pub String);
crate::simple_type!(Max4AlphaNumericText);

impl Validate for Max4AlphaNumericText {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 4 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 4 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max70Text (pub String);
crate::simple_type!(Max70Text);

impl Validate for Max70Text {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 70 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 70 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct MessageIdentification1 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

    #[yaserde(rename = "CreDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "CreDtTm"))]
    pub cre_dt_tm: IsodateTime,
}

impl Validate for MessageIdentification1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct NameAndAddress4 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max350Text,

    #[yaserde(rename = "Adr")]
    #[cfg_attr(feature = "serde", serde(rename = "Adr"))]
    pub adr: PostalAddress1,
}

impl Validate for NameAndAddress4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct NameAndAddress5 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max350Text,

    #[yaserde(rename = "Adr")]
    #[cfg_attr(feature = "serde", serde(rename = "Adr"))]
    pub adr: PostalAddress1,
}

impl Validate for NameAndAddress5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum NamePrefix1Code {
    #[yaserde(rename = "DOCT")]
    #[cfg_attr(feature = "serde", serde(rename = "DOCT"))]
    Doct,
    #[yaserde(rename = "MIST")]
    #[cfg_attr(feature = "serde", serde(rename = "MIST"))]
    Mist,
    #[yaserde(rename = "MISS")]
    #[cfg_attr(feature = "serde", serde(rename = "MISS"))]
    Miss,
    #[yaserde(rename = "MADM")]
    #[cfg_attr(feature = "serde", serde(rename = "MADM"))]
    Madm,
    __Unknown__(String),
}

impl Default for NamePrefix1Code {
    fn default() -> NamePrefix1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for NamePrefix1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Number (pub String);
crate::simple_type!(Number);

impl Validate for Number {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct OtherAmount1 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: OtherAmountType1Choice,

    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: ActiveCurrencyAndAmount,
}

impl Validate for OtherAmount1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct OtherAmountType1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<OtherAmountType1Code>,
    #[yaserde(rename = "PrtryCd")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryCd"))]
    pub prtry_cd: Option<GenericIdentification1>,
}

impl Validate for OtherAmountType1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum OtherAmountType1Code {
    #[yaserde(rename = "PINT")]
    #[cfg_attr(feature = "serde", serde(rename = "PINT"))]
    Pint,
    #[yaserde(rename = "SINT")]
    #[cfg_attr(feature = "serde", serde(rename = "SINT"))]
    Sint,
    __Unknown__(String),
}

impl Default for OtherAmountType1Code {
    fn default() -> OtherAmountType1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for OtherAmountType1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct OtherIdentification8 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

    #[yaserde(rename = "Sfx")]
    #[cfg_attr(feature = "serde", serde(rename = "Sfx"))]
    pub sfx: Max16Text,

    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: IdentificationSource6Choice,
}

impl Validate for OtherIdentification8 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct PartyIdentification123Choice {
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_b_i_c: Option<AnyBICDec2014Identifier>,
    #[yaserde(rename = "PrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
    pub prtry_id: Option<GenericIdentification36>,
    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: Option<NameAndAddress5>,
}

impl Validate for PartyIdentification123Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct PartyIdentification125Choice {
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_b_i_c: Option<AnyBICDec2014Identifier>,
    #[yaserde(rename = "PrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
    pub prtry_id: Option<GenericIdentification1>,
    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: Option<NameAndAddress5>,
}

impl Validate for PartyIdentification125Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct PartyIdentification139 {
    #[yaserde(rename = "Pty")]
    #[cfg_attr(feature = "serde", serde(rename = "Pty"))]
    pub pty: PartyIdentification125Choice,

    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Leiidentifier,
}

impl Validate for PartyIdentification139 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct PartyIdentification257Choice {
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_b_i_c: Option<AnyBICDec2014Identifier>,
    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: Option<NameAndAddress5>,
    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: Option<CountryCode>,
    #[yaserde(rename = "DgtlLdgrId")]
    #[cfg_attr(feature = "serde", serde(rename = "DgtlLdgrId"))]
    pub dgtl_ldgr_id: Option<Dti2024Identifier>,
}

impl Validate for PartyIdentification257Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct PartyIdentification315 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: PartyIdentification257Choice,

    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Leiidentifier,

    #[yaserde(rename = "AltrnId")]
    #[cfg_attr(feature = "serde", serde(rename = "AltrnId"))]
    pub altrn_id: AlternatePartyIdentification7,

    #[yaserde(rename = "PrcgDt")]
    #[cfg_attr(feature = "serde", serde(rename = "PrcgDt"))]
    pub prcg_dt: DateAndDateTime2Choice,

    #[yaserde(rename = "PrcgId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrcgId"))]
    pub prcg_id: Max35Text,

    #[yaserde(rename = "AddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
    pub addtl_inf: PartyTextInformation1,
}

impl Validate for PartyIdentification315 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct PartyIdentificationAndAccount194 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: PartyIdentification123Choice,

    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Leiidentifier,

    #[yaserde(rename = "AltrnId")]
    #[cfg_attr(feature = "serde", serde(rename = "AltrnId"))]
    pub altrn_id: AlternatePartyIdentification7,

    #[yaserde(rename = "SfkpgAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgAcct"))]
    pub sfkpg_acct: SecuritiesAccount19,

    #[yaserde(rename = "PrcgDt")]
    #[cfg_attr(feature = "serde", serde(rename = "PrcgDt"))]
    pub prcg_dt: DateAndDateTime2Choice,

    #[yaserde(rename = "PrcgId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrcgId"))]
    pub prcg_id: Max35Text,

    #[yaserde(rename = "AddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
    pub addtl_inf: PartyTextInformation6,
}

impl Validate for PartyIdentificationAndAccount194 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct PartyTextInformation1 {
    #[yaserde(rename = "DclrtnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "DclrtnDtls"))]
    pub dclrtn_dtls: Max350Text,

    #[yaserde(rename = "PtyCtctDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "PtyCtctDtls"))]
    pub pty_ctct_dtls: Max140Text,

    #[yaserde(rename = "RegnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "RegnDtls"))]
    pub regn_dtls: Max350Text,
}

impl Validate for PartyTextInformation1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct PartyTextInformation6 {
    #[yaserde(rename = "DclrtnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "DclrtnDtls"))]
    pub dclrtn_dtls: Max350Text,

    #[yaserde(rename = "PtyCtctDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "PtyCtctDtls"))]
    pub pty_ctct_dtls: Max140Text,

    #[yaserde(rename = "RegnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "RegnDtls"))]
    pub regn_dtls: Max350Text,

    #[yaserde(rename = "RegnAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "RegnAdr"))]
    pub regn_adr: PostalAddress1,
}

impl Validate for PartyTextInformation6 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct PercentageRate (pub String);
crate::simple_type!(PercentageRate);

impl Validate for PercentageRate {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct PhoneNumber (pub String);
crate::simple_type!(PhoneNumber);

impl Validate for PhoneNumber {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum PhysicalTransferType1Code {
    #[yaserde(rename = "DEMT")]
    #[cfg_attr(feature = "serde", serde(rename = "DEMT"))]
    Demt,
    #[yaserde(rename = "PHYS")]
    #[cfg_attr(feature = "serde", serde(rename = "PHYS"))]
    Phys,
    __Unknown__(String),
}

impl Default for PhysicalTransferType1Code {
    fn default() -> PhysicalTransferType1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for PhysicalTransferType1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct PostalAddress1 {
    #[yaserde(rename = "AdrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "AdrTp"))]
    pub adr_tp: AddressType2Code,

    #[yaserde(rename = "AdrLine")]
    #[cfg_attr(feature = "serde", serde(rename = "AdrLine"))]
    pub adr_line: Vec<Max70Text>,

    #[yaserde(rename = "StrtNm")]
    #[cfg_attr(feature = "serde", serde(rename = "StrtNm"))]
    pub strt_nm: Max70Text,

    #[yaserde(rename = "BldgNb")]
    #[cfg_attr(feature = "serde", serde(rename = "BldgNb"))]
    pub bldg_nb: Max16Text,

    #[yaserde(rename = "PstCd")]
    #[cfg_attr(feature = "serde", serde(rename = "PstCd"))]
    pub pst_cd: Max16Text,

    #[yaserde(rename = "TwnNm")]
    #[cfg_attr(feature = "serde", serde(rename = "TwnNm"))]
    pub twn_nm: Max35Text,

    #[yaserde(rename = "CtrySubDvsn")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrySubDvsn"))]
    pub ctry_sub_dvsn: Max35Text,

    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: CountryCode,
}

impl Validate for PostalAddress1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum PriceMethod1Code {
    #[yaserde(rename = "FORW")]
    #[cfg_attr(feature = "serde", serde(rename = "FORW"))]
    Forw,
    #[yaserde(rename = "HIST")]
    #[cfg_attr(feature = "serde", serde(rename = "HIST"))]
    Hist,
    __Unknown__(String),
}

impl Default for PriceMethod1Code {
    fn default() -> PriceMethod1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for PriceMethod1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct PriceValue1 {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: ActiveCurrencyAnd13DecimalAmount,
}

impl Validate for PriceValue1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct ProprietaryQuantity8 {
    #[yaserde(rename = "Qty")]
    #[cfg_attr(feature = "serde", serde(rename = "Qty"))]
    pub qty: DecimalNumber,

    #[yaserde(rename = "QtyTp")]
    #[cfg_attr(feature = "serde", serde(rename = "QtyTp"))]
    pub qty_tp: Exact4AlphaNumericText,

    #[yaserde(rename = "Issr")]
    #[cfg_attr(feature = "serde", serde(rename = "Issr"))]
    pub issr: Max35Text,

    #[yaserde(rename = "SchmeNm")]
    #[cfg_attr(feature = "serde", serde(rename = "SchmeNm"))]
    pub schme_nm: Max35Text,
}

impl Validate for ProprietaryQuantity8 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Quickidentifier (pub String);
crate::simple_type!(Quickidentifier);

impl Validate for Quickidentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct Quantity48Choice {
    #[yaserde(rename = "Qty")]
    #[cfg_attr(feature = "serde", serde(rename = "Qty"))]
    pub qty: Option<FinancialInstrumentQuantity33Choice>,
    #[yaserde(rename = "PrtryQty")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryQty"))]
    pub prtry_qty: Option<ProprietaryQuantity8>,
}

impl Validate for Quantity48Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Ricidentifier (pub String);
crate::simple_type!(Ricidentifier);

impl Validate for Ricidentifier {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 35 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 35 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct Role4Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<InvestmentFundRole2Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for Role4Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum RoundingDirection2Code {
    #[yaserde(rename = "RDUP")]
    #[cfg_attr(feature = "serde", serde(rename = "RDUP"))]
    Rdup,
    #[yaserde(rename = "RDWN")]
    #[cfg_attr(feature = "serde", serde(rename = "RDWN"))]
    Rdwn,
    __Unknown__(String),
}

impl Default for RoundingDirection2Code {
    fn default() -> RoundingDirection2Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for RoundingDirection2Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Sedolidentifier (pub String);
crate::simple_type!(Sedolidentifier);

impl Validate for Sedolidentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum SafekeepingPlace1Code {
    #[yaserde(rename = "CUST")]
    #[cfg_attr(feature = "serde", serde(rename = "CUST"))]
    Cust,
    #[yaserde(rename = "ICSD")]
    #[cfg_attr(feature = "serde", serde(rename = "ICSD"))]
    Icsd,
    #[yaserde(rename = "NCSD")]
    #[cfg_attr(feature = "serde", serde(rename = "NCSD"))]
    Ncsd,
    #[yaserde(rename = "SHHE")]
    #[cfg_attr(feature = "serde", serde(rename = "SHHE"))]
    Shhe,
    __Unknown__(String),
}

impl Default for SafekeepingPlace1Code {
    fn default() -> SafekeepingPlace1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for SafekeepingPlace1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum SafekeepingPlace2Code {
    #[yaserde(rename = "SHHE")]
    #[cfg_attr(feature = "serde", serde(rename = "SHHE"))]
    Shhe,
    #[yaserde(rename = "ALLP")]
    #[cfg_attr(feature = "serde", serde(rename = "ALLP"))]
    Allp,
    __Unknown__(String),
}

impl Default for SafekeepingPlace2Code {
    fn default() -> SafekeepingPlace2Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for SafekeepingPlace2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct SafekeepingPlaceFormat42Choice {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Option<SafekeepingPlaceTypeAndText6>,
    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: Option<CountryCode>,
    #[yaserde(rename = "DgtlLdgrId")]
    #[cfg_attr(feature = "serde", serde(rename = "DgtlLdgrId"))]
    pub dgtl_ldgr_id: Option<Dti2024Identifier>,
    #[yaserde(rename = "TpAndId")]
    #[cfg_attr(feature = "serde", serde(rename = "TpAndId"))]
    pub tp_and_id: Option<SafekeepingPlaceTypeAndIdentification1>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification78>,
}

impl Validate for SafekeepingPlaceFormat42Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct SafekeepingPlaceTypeAndIdentification1 {
    #[yaserde(rename = "SfkpgPlcTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgPlcTp"))]
    pub sfkpg_plc_tp: SafekeepingPlace1Code,

    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: AnyBICDec2014Identifier,
}

impl Validate for SafekeepingPlaceTypeAndIdentification1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct SafekeepingPlaceTypeAndText6 {
    #[yaserde(rename = "SfkpgPlcTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgPlcTp"))]
    pub sfkpg_plc_tp: SafekeepingPlace2Code,

    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,
}

impl Validate for SafekeepingPlaceTypeAndText6 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct SecuritiesAccount19 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: GenericIdentification30,

    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max70Text,
}

impl Validate for SecuritiesAccount19 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct SecurityIdentification46Choice {
    #[yaserde(rename = "ISIN")]
    #[cfg_attr(feature = "serde", serde(rename = "ISIN"))]
    pub isin: Option<Isinoct2015Identifier>,
    #[yaserde(rename = "SEDOL")]
    #[cfg_attr(feature = "serde", serde(rename = "SEDOL"))]
    pub sedol: Option<Sedolidentifier>,
    #[yaserde(rename = "CUSIP")]
    #[cfg_attr(feature = "serde", serde(rename = "CUSIP"))]
    pub cusip: Option<Cusipidentifier>,
    #[yaserde(rename = "RIC")]
    #[cfg_attr(feature = "serde", serde(rename = "RIC"))]
    pub ric: Option<Ricidentifier>,
    #[yaserde(rename = "TckrSymb")]
    #[cfg_attr(feature = "serde", serde(rename = "TckrSymb"))]
    pub tckr_symb: Option<TickerIdentifier>,
    #[yaserde(rename = "Blmbrg")]
    #[cfg_attr(feature = "serde", serde(rename = "Blmbrg"))]
    pub blmbrg: Option<Bloomberg2Identifier>,
    #[yaserde(rename = "CTA")]
    #[cfg_attr(feature = "serde", serde(rename = "CTA"))]
    pub cta: Option<ConsolidatedTapeAssociationIdentifier>,
    #[yaserde(rename = "QUICK")]
    #[cfg_attr(feature = "serde", serde(rename = "QUICK"))]
    pub quick: Option<Quickidentifier>,
    #[yaserde(rename = "Wrtppr")]
    #[cfg_attr(feature = "serde", serde(rename = "Wrtppr"))]
    pub wrtppr: Option<WertpapierIdentifier>,
    #[yaserde(rename = "Dtch")]
    #[cfg_attr(feature = "serde", serde(rename = "Dtch"))]
    pub dtch: Option<DutchIdentifier>,
    #[yaserde(rename = "Vlrn")]
    #[cfg_attr(feature = "serde", serde(rename = "Vlrn"))]
    pub vlrn: Option<ValorenIdentifier>,
    #[yaserde(rename = "SCVM")]
    #[cfg_attr(feature = "serde", serde(rename = "SCVM"))]
    pub scvm: Option<SicovamIdentifier>,
    #[yaserde(rename = "Belgn")]
    #[cfg_attr(feature = "serde", serde(rename = "Belgn"))]
    pub belgn: Option<BelgianIdentifier>,
    #[yaserde(rename = "Cmon")]
    #[cfg_attr(feature = "serde", serde(rename = "Cmon"))]
    pub cmon: Option<EuroclearClearstreamIdentifier>,
    #[yaserde(rename = "DTI")]
    #[cfg_attr(feature = "serde", serde(rename = "DTI"))]
    pub dti: Option<Dti2024Identifier>,
    #[yaserde(rename = "OthrPrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrPrtryId"))]
    pub othr_prtry_id: Option<AlternateSecurityIdentification7>,
}

impl Validate for SecurityIdentification46Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct SecurityIdentification50 {
    #[yaserde(rename = "ISIN")]
    #[cfg_attr(feature = "serde", serde(rename = "ISIN"))]
    pub isin: Isinoct2015Identifier,

    #[yaserde(rename = "OthrId")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrId"))]
    pub othr_id: Vec<OtherIdentification8>,

    #[yaserde(rename = "Desc")]
    #[cfg_attr(feature = "serde", serde(rename = "Desc"))]
    pub desc: Max140Text,
}

impl Validate for SecurityIdentification50 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct SettlementParties131 {
    #[yaserde(rename = "Dpstry")]
    #[cfg_attr(feature = "serde", serde(rename = "Dpstry"))]
    pub dpstry: PartyIdentification315,

    #[yaserde(rename = "Pty1")]
    #[cfg_attr(feature = "serde", serde(rename = "Pty1"))]
    pub pty_1: PartyIdentificationAndAccount194,

    #[yaserde(rename = "Pty2")]
    #[cfg_attr(feature = "serde", serde(rename = "Pty2"))]
    pub pty_2: PartyIdentificationAndAccount194,

    #[yaserde(rename = "Pty3")]
    #[cfg_attr(feature = "serde", serde(rename = "Pty3"))]
    pub pty_3: PartyIdentificationAndAccount194,

    #[yaserde(rename = "Pty4")]
    #[cfg_attr(feature = "serde", serde(rename = "Pty4"))]
    pub pty_4: PartyIdentificationAndAccount194,

    #[yaserde(rename = "Pty5")]
    #[cfg_attr(feature = "serde", serde(rename = "Pty5"))]
    pub pty_5: PartyIdentificationAndAccount194,
}

impl Validate for SettlementParties131 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum SettlementTransactionCondition11Code {
    #[yaserde(rename = "NOMC")]
    #[cfg_attr(feature = "serde", serde(rename = "NOMC"))]
    Nomc,
    __Unknown__(String),
}

impl Default for SettlementTransactionCondition11Code {
    fn default() -> SettlementTransactionCondition11Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for SettlementTransactionCondition11Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct SettlementTransactionCondition30Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<SettlementTransactionCondition11Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification30>,
}

impl Validate for SettlementTransactionCondition30Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct SicovamIdentifier (pub String);
crate::simple_type!(SicovamIdentifier);

impl Validate for SicovamIdentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum StampDutyType2Code {
    #[yaserde(rename = "ASTD")]
    #[cfg_attr(feature = "serde", serde(rename = "ASTD"))]
    Astd,
    #[yaserde(rename = "SDRN")]
    #[cfg_attr(feature = "serde", serde(rename = "SDRN"))]
    Sdrn,
    __Unknown__(String),
}

impl Default for StampDutyType2Code {
    fn default() -> StampDutyType2Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for StampDutyType2Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct SubAccount5 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max35Text,

    #[yaserde(rename = "Chrtc")]
    #[cfg_attr(feature = "serde", serde(rename = "Chrtc"))]
    pub chrtc: Max35Text,
}

impl Validate for SubAccount5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct Tax35 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: TaxType3Choice,

    #[yaserde(rename = "ApldAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "ApldAmt"))]
    pub apld_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "ApldRate")]
    #[cfg_attr(feature = "serde", serde(rename = "ApldRate"))]
    pub apld_rate: PercentageRate,

    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: CountryCode,

    #[yaserde(rename = "RcptId")]
    #[cfg_attr(feature = "serde", serde(rename = "RcptId"))]
    pub rcpt_id: PartyIdentification139,

    #[yaserde(rename = "TaxClctnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxClctnDtls"))]
    pub tax_clctn_dtls: TaxCalculationInformation10,
}

impl Validate for Tax35 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct Tax38 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: TaxType1Choice,

    #[yaserde(rename = "Bsis")]
    #[cfg_attr(feature = "serde", serde(rename = "Bsis"))]
    pub bsis: TaxBasis1Choice,

    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: CountryCode,

    #[yaserde(rename = "XmptnInd")]
    #[cfg_attr(feature = "serde", serde(rename = "XmptnInd"))]
    pub xmptn_ind: YesNoIndicator,

    #[yaserde(rename = "XmptnRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "XmptnRsn"))]
    pub xmptn_rsn: ExemptionReason1Choice,

    #[yaserde(rename = "RcptId")]
    #[cfg_attr(feature = "serde", serde(rename = "RcptId"))]
    pub rcpt_id: PartyIdentification139,

    #[yaserde(rename = "TaxClctnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxClctnDtls"))]
    pub tax_clctn_dtls: TaxCalculationInformation11,
}

impl Validate for Tax38 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct TaxBasis1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<TaxationBasis2Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for TaxBasis1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct TaxCalculationInformation10 {
    #[yaserde(rename = "Bsis")]
    #[cfg_attr(feature = "serde", serde(rename = "Bsis"))]
    pub bsis: TaxBasis1Choice,

    #[yaserde(rename = "TaxblAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxblAmt"))]
    pub taxbl_amt: ActiveCurrencyAndAmount,
}

impl Validate for TaxCalculationInformation10 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct TaxCalculationInformation11 {
    #[yaserde(rename = "Bsis")]
    #[cfg_attr(feature = "serde", serde(rename = "Bsis"))]
    pub bsis: TaxBasis1Choice,

    #[yaserde(rename = "TaxblAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxblAmt"))]
    pub taxbl_amt: ActiveCurrencyAndAmount,
}

impl Validate for TaxCalculationInformation11 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum TaxExemptReason1Code {
    #[yaserde(rename = "NONE")]
    #[cfg_attr(feature = "serde", serde(rename = "NONE"))]
    None,
    #[yaserde(rename = "MASA")]
    #[cfg_attr(feature = "serde", serde(rename = "MASA"))]
    Masa,
    #[yaserde(rename = "MISA")]
    #[cfg_attr(feature = "serde", serde(rename = "MISA"))]
    Misa,
    #[yaserde(rename = "SISA")]
    #[cfg_attr(feature = "serde", serde(rename = "SISA"))]
    Sisa,
    #[yaserde(rename = "IISA")]
    #[cfg_attr(feature = "serde", serde(rename = "IISA"))]
    Iisa,
    #[yaserde(rename = "CUYP")]
    #[cfg_attr(feature = "serde", serde(rename = "CUYP"))]
    Cuyp,
    #[yaserde(rename = "PRYP")]
    #[cfg_attr(feature = "serde", serde(rename = "PRYP"))]
    Pryp,
    #[yaserde(rename = "ASTR")]
    #[cfg_attr(feature = "serde", serde(rename = "ASTR"))]
    Astr,
    #[yaserde(rename = "EMPY")]
    #[cfg_attr(feature = "serde", serde(rename = "EMPY"))]
    Empy,
    #[yaserde(rename = "EMCY")]
    #[cfg_attr(feature = "serde", serde(rename = "EMCY"))]
    Emcy,
    #[yaserde(rename = "EPRY")]
    #[cfg_attr(feature = "serde", serde(rename = "EPRY"))]
    Epry,
    #[yaserde(rename = "ECYE")]
    #[cfg_attr(feature = "serde", serde(rename = "ECYE"))]
    Ecye,
    #[yaserde(rename = "NFPI")]
    #[cfg_attr(feature = "serde", serde(rename = "NFPI"))]
    Nfpi,
    #[yaserde(rename = "NFQP")]
    #[cfg_attr(feature = "serde", serde(rename = "NFQP"))]
    Nfqp,
    #[yaserde(rename = "DECP")]
    #[cfg_attr(feature = "serde", serde(rename = "DECP"))]
    Decp,
    #[yaserde(rename = "IRAC")]
    #[cfg_attr(feature = "serde", serde(rename = "IRAC"))]
    Irac,
    #[yaserde(rename = "IRAR")]
    #[cfg_attr(feature = "serde", serde(rename = "IRAR"))]
    Irar,
    #[yaserde(rename = "KEOG")]
    #[cfg_attr(feature = "serde", serde(rename = "KEOG"))]
    Keog,
    #[yaserde(rename = "PFSP")]
    #[cfg_attr(feature = "serde", serde(rename = "PFSP"))]
    Pfsp,
    #[yaserde(rename = "401K")]
    #[cfg_attr(feature = "serde", serde(rename = "401K"))]
    _401K,
    #[yaserde(rename = "SIRA")]
    #[cfg_attr(feature = "serde", serde(rename = "SIRA"))]
    Sira,
    #[yaserde(rename = "403B")]
    #[cfg_attr(feature = "serde", serde(rename = "403B"))]
    _403B,
    #[yaserde(rename = "457X")]
    #[cfg_attr(feature = "serde", serde(rename = "457X"))]
    _457X,
    #[yaserde(rename = "RIRA")]
    #[cfg_attr(feature = "serde", serde(rename = "RIRA"))]
    Rira,
    #[yaserde(rename = "RIAN")]
    #[cfg_attr(feature = "serde", serde(rename = "RIAN"))]
    Rian,
    #[yaserde(rename = "RCRF")]
    #[cfg_attr(feature = "serde", serde(rename = "RCRF"))]
    Rcrf,
    #[yaserde(rename = "RCIP")]
    #[cfg_attr(feature = "serde", serde(rename = "RCIP"))]
    Rcip,
    #[yaserde(rename = "EIFP")]
    #[cfg_attr(feature = "serde", serde(rename = "EIFP"))]
    Eifp,
    #[yaserde(rename = "EIOP")]
    #[cfg_attr(feature = "serde", serde(rename = "EIOP"))]
    Eiop,
    __Unknown__(String),
}

impl Default for TaxExemptReason1Code {
    fn default() -> TaxExemptReason1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for TaxExemptReason1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum TaxType16Code {
    #[yaserde(rename = "COAX")]
    #[cfg_attr(feature = "serde", serde(rename = "COAX"))]
    Coax,
    #[yaserde(rename = "CTAX")]
    #[cfg_attr(feature = "serde", serde(rename = "CTAX"))]
    Ctax,
    #[yaserde(rename = "EUTR")]
    #[cfg_attr(feature = "serde", serde(rename = "EUTR"))]
    Eutr,
    #[yaserde(rename = "LEVY")]
    #[cfg_attr(feature = "serde", serde(rename = "LEVY"))]
    Levy,
    #[yaserde(rename = "LOCL")]
    #[cfg_attr(feature = "serde", serde(rename = "LOCL"))]
    Locl,
    #[yaserde(rename = "NATI")]
    #[cfg_attr(feature = "serde", serde(rename = "NATI"))]
    Nati,
    #[yaserde(rename = "PROV")]
    #[cfg_attr(feature = "serde", serde(rename = "PROV"))]
    Prov,
    #[yaserde(rename = "STAM")]
    #[cfg_attr(feature = "serde", serde(rename = "STAM"))]
    Stam,
    #[yaserde(rename = "STAT")]
    #[cfg_attr(feature = "serde", serde(rename = "STAT"))]
    Stat,
    #[yaserde(rename = "STEX")]
    #[cfg_attr(feature = "serde", serde(rename = "STEX"))]
    Stex,
    #[yaserde(rename = "TRAN")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAN"))]
    Tran,
    #[yaserde(rename = "TRAX")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAX"))]
    Trax,
    #[yaserde(rename = "VATA")]
    #[cfg_attr(feature = "serde", serde(rename = "VATA"))]
    Vata,
    #[yaserde(rename = "WITH")]
    #[cfg_attr(feature = "serde", serde(rename = "WITH"))]
    With,
    #[yaserde(rename = "NKAP")]
    #[cfg_attr(feature = "serde", serde(rename = "NKAP"))]
    Nkap,
    #[yaserde(rename = "KAPA")]
    #[cfg_attr(feature = "serde", serde(rename = "KAPA"))]
    Kapa,
    __Unknown__(String),
}

impl Default for TaxType16Code {
    fn default() -> TaxType16Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for TaxType16Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum TaxType17Code {
    #[yaserde(rename = "PROV")]
    #[cfg_attr(feature = "serde", serde(rename = "PROV"))]
    Prov,
    #[yaserde(rename = "NATI")]
    #[cfg_attr(feature = "serde", serde(rename = "NATI"))]
    Nati,
    #[yaserde(rename = "STAT")]
    #[cfg_attr(feature = "serde", serde(rename = "STAT"))]
    Stat,
    #[yaserde(rename = "WITH")]
    #[cfg_attr(feature = "serde", serde(rename = "WITH"))]
    With,
    #[yaserde(rename = "KAPA")]
    #[cfg_attr(feature = "serde", serde(rename = "KAPA"))]
    Kapa,
    #[yaserde(rename = "NKAP")]
    #[cfg_attr(feature = "serde", serde(rename = "NKAP"))]
    Nkap,
    #[yaserde(rename = "INPO")]
    #[cfg_attr(feature = "serde", serde(rename = "INPO"))]
    Inpo,
    #[yaserde(rename = "STAM")]
    #[cfg_attr(feature = "serde", serde(rename = "STAM"))]
    Stam,
    #[yaserde(rename = "WTAX")]
    #[cfg_attr(feature = "serde", serde(rename = "WTAX"))]
    Wtax,
    #[yaserde(rename = "INHT")]
    #[cfg_attr(feature = "serde", serde(rename = "INHT"))]
    Inht,
    #[yaserde(rename = "SOSU")]
    #[cfg_attr(feature = "serde", serde(rename = "SOSU"))]
    Sosu,
    #[yaserde(rename = "CTAX")]
    #[cfg_attr(feature = "serde", serde(rename = "CTAX"))]
    Ctax,
    #[yaserde(rename = "GIFT")]
    #[cfg_attr(feature = "serde", serde(rename = "GIFT"))]
    Gift,
    #[yaserde(rename = "COAX")]
    #[cfg_attr(feature = "serde", serde(rename = "COAX"))]
    Coax,
    #[yaserde(rename = "EUTR")]
    #[cfg_attr(feature = "serde", serde(rename = "EUTR"))]
    Eutr,
    #[yaserde(rename = "AKT1")]
    #[cfg_attr(feature = "serde", serde(rename = "AKT1"))]
    Akt1,
    #[yaserde(rename = "AKT2")]
    #[cfg_attr(feature = "serde", serde(rename = "AKT2"))]
    Akt2,
    #[yaserde(rename = "ZWIS")]
    #[cfg_attr(feature = "serde", serde(rename = "ZWIS"))]
    Zwis,
    __Unknown__(String),
}

impl Default for TaxType17Code {
    fn default() -> TaxType17Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for TaxType17Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct TaxType1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<TaxType16Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for TaxType1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct TaxType3Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<TaxType17Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for TaxType3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct TaxableIncomePerShareCalculated2Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<TaxableIncomePerShareCalculated2Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for TaxableIncomePerShareCalculated2Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum TaxableIncomePerShareCalculated2Code {
    #[yaserde(rename = "TSIY")]
    #[cfg_attr(feature = "serde", serde(rename = "TSIY"))]
    Tsiy,
    #[yaserde(rename = "TSIN")]
    #[cfg_attr(feature = "serde", serde(rename = "TSIN"))]
    Tsin,
    #[yaserde(rename = "UKWN")]
    #[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
    Ukwn,
    __Unknown__(String),
}

impl Default for TaxableIncomePerShareCalculated2Code {
    fn default() -> TaxableIncomePerShareCalculated2Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for TaxableIncomePerShareCalculated2Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum TaxationBasis2Code {
    #[yaserde(rename = "FLAT")]
    #[cfg_attr(feature = "serde", serde(rename = "FLAT"))]
    Flat,
    #[yaserde(rename = "PERU")]
    #[cfg_attr(feature = "serde", serde(rename = "PERU"))]
    Peru,
    __Unknown__(String),
}

impl Default for TaxationBasis2Code {
    fn default() -> TaxationBasis2Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for TaxationBasis2Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum TaxationBasis5Code {
    #[yaserde(rename = "FLAT")]
    #[cfg_attr(feature = "serde", serde(rename = "FLAT"))]
    Flat,
    #[yaserde(rename = "GRAM")]
    #[cfg_attr(feature = "serde", serde(rename = "GRAM"))]
    Gram,
    #[yaserde(rename = "NEAM")]
    #[cfg_attr(feature = "serde", serde(rename = "NEAM"))]
    Neam,
    #[yaserde(rename = "NAVP")]
    #[cfg_attr(feature = "serde", serde(rename = "NAVP"))]
    Navp,
    #[yaserde(rename = "PERU")]
    #[cfg_attr(feature = "serde", serde(rename = "PERU"))]
    Peru,
    __Unknown__(String),
}

impl Default for TaxationBasis5Code {
    fn default() -> TaxationBasis5Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for TaxationBasis5Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct TickerIdentifier (pub String);
crate::simple_type!(TickerIdentifier);

impl Validate for TickerIdentifier {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 35 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 35 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct TotalFeesAndTaxes44 {
    #[yaserde(rename = "TtlOvrhdApld")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlOvrhdApld"))]
    pub ttl_ovrhd_apld: ActiveCurrencyAndAmount,

    #[yaserde(rename = "TtlFees")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlFees"))]
    pub ttl_fees: ActiveCurrencyAndAmount,

    #[yaserde(rename = "TtlTaxs")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlTaxs"))]
    pub ttl_taxs: ActiveCurrencyAndAmount,

    #[yaserde(rename = "ComrclAgrmtRef")]
    #[cfg_attr(feature = "serde", serde(rename = "ComrclAgrmtRef"))]
    pub comrcl_agrmt_ref: Max35Text,

    #[yaserde(rename = "IndvFee")]
    #[cfg_attr(feature = "serde", serde(rename = "IndvFee"))]
    pub indv_fee: Vec<Fee11>,

    #[yaserde(rename = "IndvTax")]
    #[cfg_attr(feature = "serde", serde(rename = "IndvTax"))]
    pub indv_tax: Vec<Tax35>,

    #[yaserde(rename = "DgtlNtwkFee")]
    #[cfg_attr(feature = "serde", serde(rename = "DgtlNtwkFee"))]
    pub dgtl_ntwk_fee: Vec<DigitalPaymentSettlement3>,
}

impl Validate for TotalFeesAndTaxes44 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum TradeTransactionCondition5Code {
    #[yaserde(rename = "XCPN")]
    #[cfg_attr(feature = "serde", serde(rename = "XCPN"))]
    Xcpn,
    #[yaserde(rename = "CCPN")]
    #[cfg_attr(feature = "serde", serde(rename = "CCPN"))]
    Ccpn,
    __Unknown__(String),
}

impl Default for TradeTransactionCondition5Code {
    fn default() -> TradeTransactionCondition5Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for TradeTransactionCondition5Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct TradeTransactionCondition8Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<TradeTransactionCondition5Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification30>,
}

impl Validate for TradeTransactionCondition8Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct Transfer38 {
    #[yaserde(rename = "TrfConfRef")]
    #[cfg_attr(feature = "serde", serde(rename = "TrfConfRef"))]
    pub trf_conf_ref: Max35Text,

    #[yaserde(rename = "TrfRef")]
    #[cfg_attr(feature = "serde", serde(rename = "TrfRef"))]
    pub trf_ref: Max35Text,

    #[yaserde(rename = "ClntRef")]
    #[cfg_attr(feature = "serde", serde(rename = "ClntRef"))]
    pub clnt_ref: AdditionalReference10,

    #[yaserde(rename = "CtrPtyRef")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrPtyRef"))]
    pub ctr_pty_ref: AdditionalReference10,

    #[yaserde(rename = "BizFlowTp")]
    #[cfg_attr(feature = "serde", serde(rename = "BizFlowTp"))]
    pub biz_flow_tp: BusinessFlowType1Code,

    #[yaserde(rename = "ReqdSttlmDt")]
    #[cfg_attr(feature = "serde", serde(rename = "ReqdSttlmDt"))]
    pub reqd_sttlm_dt: Isodate,

    #[yaserde(rename = "FctvTrfDt")]
    #[cfg_attr(feature = "serde", serde(rename = "FctvTrfDt"))]
    pub fctv_trf_dt: DateAndDateTime2Choice,

    #[yaserde(rename = "FctvSttlmDt")]
    #[cfg_attr(feature = "serde", serde(rename = "FctvSttlmDt"))]
    pub fctv_sttlm_dt: DateAndDateTime2Choice,

    #[yaserde(rename = "TradDt")]
    #[cfg_attr(feature = "serde", serde(rename = "TradDt"))]
    pub trad_dt: DateAndDateTime2Choice,

    #[yaserde(rename = "TrfOrdrDtForm")]
    #[cfg_attr(feature = "serde", serde(rename = "TrfOrdrDtForm"))]
    pub trf_ordr_dt_form: Isodate,

    #[yaserde(rename = "TrfRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "TrfRsn"))]
    pub trf_rsn: TransferReason1Choice,

    #[yaserde(rename = "HldgsPlanTp")]
    #[cfg_attr(feature = "serde", serde(rename = "HldgsPlanTp"))]
    pub hldgs_plan_tp: Vec<HoldingsPlanType1Code>,

    #[yaserde(rename = "FinInstrmDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrmDtls"))]
    pub fin_instrm_dtls: FinancialInstrument116,

    #[yaserde(rename = "TtlUnitsNb")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlUnitsNb"))]
    pub ttl_units_nb: Unit1Choice,

    #[yaserde(rename = "TrfRate")]
    #[cfg_attr(feature = "serde", serde(rename = "TrfRate"))]
    pub trf_rate: PercentageRate,

    #[yaserde(rename = "UnitsDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitsDtls"))]
    pub units_dtls: Vec<Unit14>,

    #[yaserde(rename = "Rndg")]
    #[cfg_attr(feature = "serde", serde(rename = "Rndg"))]
    pub rndg: RoundingDirection2Code,

    #[yaserde(rename = "OrgnlCost")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlCost"))]
    pub orgnl_cost: ActiveCurrencyAnd13DecimalAmount,

    #[yaserde(rename = "AvrgPric")]
    #[cfg_attr(feature = "serde", serde(rename = "AvrgPric"))]
    pub avrg_pric: ActiveOrHistoricCurrencyAnd13DecimalAmount,

    #[yaserde(rename = "NewAvrgPric")]
    #[cfg_attr(feature = "serde", serde(rename = "NewAvrgPric"))]
    pub new_avrg_pric: ActiveOrHistoricCurrencyAnd13DecimalAmount,

    #[yaserde(rename = "AvrgDt")]
    #[cfg_attr(feature = "serde", serde(rename = "AvrgDt"))]
    pub avrg_dt: Isodate,

    #[yaserde(rename = "NewAvrgDt")]
    #[cfg_attr(feature = "serde", serde(rename = "NewAvrgDt"))]
    pub new_avrg_dt: Isodate,

    #[yaserde(rename = "TrfCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "TrfCcy"))]
    pub trf_ccy: ActiveOrHistoricCurrencyCode,

    #[yaserde(rename = "OwnAcctTrfInd")]
    #[cfg_attr(feature = "serde", serde(rename = "OwnAcctTrfInd"))]
    pub own_acct_trf_ind: YesNoIndicator,

    #[yaserde(rename = "NonStdSttlmInf")]
    #[cfg_attr(feature = "serde", serde(rename = "NonStdSttlmInf"))]
    pub non_std_sttlm_inf: Max350Text,

    #[yaserde(rename = "TrfExpnssPmtTp")]
    #[cfg_attr(feature = "serde", serde(rename = "TrfExpnssPmtTp"))]
    pub trf_expnss_pmt_tp: ChargePaymentMethod1Choice,
}

impl Validate for Transfer38 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct TransferInConfirmationV10 {
    #[yaserde(rename = "MsgId")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgId"))]
    pub msg_id: MessageIdentification1,

    #[yaserde(rename = "PoolRef")]
    #[cfg_attr(feature = "serde", serde(rename = "PoolRef"))]
    pub pool_ref: AdditionalReference11,

    #[yaserde(rename = "PrvsRef")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvsRef"))]
    pub prvs_ref: AdditionalReference10,

    #[yaserde(rename = "RltdRef")]
    #[cfg_attr(feature = "serde", serde(rename = "RltdRef"))]
    pub rltd_ref: AdditionalReference10,

    #[yaserde(rename = "Fctn")]
    #[cfg_attr(feature = "serde", serde(rename = "Fctn"))]
    pub fctn: TransferInFunction2Code,

    #[yaserde(rename = "MstrRef")]
    #[cfg_attr(feature = "serde", serde(rename = "MstrRef"))]
    pub mstr_ref: Max35Text,

    #[yaserde(rename = "TrfDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "TrfDtls"))]
    pub trf_dtls: Vec<Transfer38>,

    #[yaserde(rename = "AcctDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctDtls"))]
    pub acct_dtls: InvestmentAccount83,

    #[yaserde(rename = "SttlmDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmDtls"))]
    pub sttlm_dtls: DeliverInformation23,

    #[yaserde(rename = "MktPrctcVrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "MktPrctcVrsn"))]
    pub mkt_prctc_vrsn: MarketPracticeVersion1,

    #[yaserde(rename = "CpyDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "CpyDtls"))]
    pub cpy_dtls: CopyInformation5,

    #[yaserde(rename = "Xtnsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Xtnsn"))]
    pub xtnsn: Vec<Extension1>,
}

impl Validate for TransferInConfirmationV10 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum TransferInFunction2Code {
    #[yaserde(rename = "CONF")]
    #[cfg_attr(feature = "serde", serde(rename = "CONF"))]
    Conf,
    #[yaserde(rename = "ADVI")]
    #[cfg_attr(feature = "serde", serde(rename = "ADVI"))]
    Advi,
    __Unknown__(String),
}

impl Default for TransferInFunction2Code {
    fn default() -> TransferInFunction2Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for TransferInFunction2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct TransferReason1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<TransferReason1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification27>,
}

impl Validate for TransferReason1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum TransferReason1Code {
    #[yaserde(rename = "TRAU")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAU"))]
    Trau,
    #[yaserde(rename = "TRAC")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAC"))]
    Trac,
    #[yaserde(rename = "TRAT")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAT"))]
    Trat,
    #[yaserde(rename = "TRAO")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAO"))]
    Trao,
    #[yaserde(rename = "TRAI")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAI"))]
    Trai,
    #[yaserde(rename = "TRAG")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAG"))]
    Trag,
    #[yaserde(rename = "TPLD")]
    #[cfg_attr(feature = "serde", serde(rename = "TPLD"))]
    Tpld,
    #[yaserde(rename = "TTDT")]
    #[cfg_attr(feature = "serde", serde(rename = "TTDT"))]
    Ttdt,
    #[yaserde(rename = "TRPE")]
    #[cfg_attr(feature = "serde", serde(rename = "TRPE"))]
    Trpe,
    #[yaserde(rename = "TRAF")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAF"))]
    Traf,
    #[yaserde(rename = "TRAN")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAN"))]
    Tran,
    __Unknown__(String),
}

impl Default for TransferReason1Code {
    fn default() -> TransferReason1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for TransferReason1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum TypeOfIdentification1Code {
    #[yaserde(rename = "ARNU")]
    #[cfg_attr(feature = "serde", serde(rename = "ARNU"))]
    Arnu,
    #[yaserde(rename = "CCPT")]
    #[cfg_attr(feature = "serde", serde(rename = "CCPT"))]
    Ccpt,
    #[yaserde(rename = "CHTY")]
    #[cfg_attr(feature = "serde", serde(rename = "CHTY"))]
    Chty,
    #[yaserde(rename = "CORP")]
    #[cfg_attr(feature = "serde", serde(rename = "CORP"))]
    Corp,
    #[yaserde(rename = "DRLC")]
    #[cfg_attr(feature = "serde", serde(rename = "DRLC"))]
    Drlc,
    #[yaserde(rename = "FIIN")]
    #[cfg_attr(feature = "serde", serde(rename = "FIIN"))]
    Fiin,
    #[yaserde(rename = "TXID")]
    #[cfg_attr(feature = "serde", serde(rename = "TXID"))]
    Txid,
    __Unknown__(String),
}

impl Default for TypeOfIdentification1Code {
    fn default() -> TypeOfIdentification1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for TypeOfIdentification1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum TypeOfPrice10Code {
    #[yaserde(rename = "BIDE")]
    #[cfg_attr(feature = "serde", serde(rename = "BIDE"))]
    Bide,
    #[yaserde(rename = "OFFR")]
    #[cfg_attr(feature = "serde", serde(rename = "OFFR"))]
    Offr,
    #[yaserde(rename = "NAVL")]
    #[cfg_attr(feature = "serde", serde(rename = "NAVL"))]
    Navl,
    #[yaserde(rename = "CREA")]
    #[cfg_attr(feature = "serde", serde(rename = "CREA"))]
    Crea,
    #[yaserde(rename = "CANC")]
    #[cfg_attr(feature = "serde", serde(rename = "CANC"))]
    Canc,
    #[yaserde(rename = "INTE")]
    #[cfg_attr(feature = "serde", serde(rename = "INTE"))]
    Inte,
    #[yaserde(rename = "SWNG")]
    #[cfg_attr(feature = "serde", serde(rename = "SWNG"))]
    Swng,
    #[yaserde(rename = "MIDD")]
    #[cfg_attr(feature = "serde", serde(rename = "MIDD"))]
    Midd,
    #[yaserde(rename = "RINV")]
    #[cfg_attr(feature = "serde", serde(rename = "RINV"))]
    Rinv,
    #[yaserde(rename = "SWIC")]
    #[cfg_attr(feature = "serde", serde(rename = "SWIC"))]
    Swic,
    #[yaserde(rename = "DDVR")]
    #[cfg_attr(feature = "serde", serde(rename = "DDVR"))]
    Ddvr,
    #[yaserde(rename = "ACTU")]
    #[cfg_attr(feature = "serde", serde(rename = "ACTU"))]
    Actu,
    __Unknown__(String),
}

impl Default for TypeOfPrice10Code {
    fn default() -> TypeOfPrice10Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for TypeOfPrice10Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct TypeOfPrice46Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<TypeOfPrice10Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for TypeOfPrice46Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum UktaxGroupUnit1Code {
    #[yaserde(rename = "GRP1")]
    #[cfg_attr(feature = "serde", serde(rename = "GRP1"))]
    Grp1,
    #[yaserde(rename = "GRP2")]
    #[cfg_attr(feature = "serde", serde(rename = "GRP2"))]
    Grp2,
    __Unknown__(String),
}

impl Default for UktaxGroupUnit1Code {
    fn default() -> UktaxGroupUnit1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for UktaxGroupUnit1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct Unit14 {
    #[yaserde(rename = "Units")]
    #[cfg_attr(feature = "serde", serde(rename = "Units"))]
    pub units: Unit1Choice,

    #[yaserde(rename = "OrdrDt")]
    #[cfg_attr(feature = "serde", serde(rename = "OrdrDt"))]
    pub ordr_dt: Isodate,

    #[yaserde(rename = "AcqstnDt")]
    #[cfg_attr(feature = "serde", serde(rename = "AcqstnDt"))]
    pub acqstn_dt: Isodate,

    #[yaserde(rename = "CertNb")]
    #[cfg_attr(feature = "serde", serde(rename = "CertNb"))]
    pub cert_nb: Vec<Max35Text>,

    #[yaserde(rename = "Grp1Or2Units")]
    #[cfg_attr(feature = "serde", serde(rename = "Grp1Or2Units"))]
    pub grp_1_or_2_units: UktaxGroupUnit1Code,

    #[yaserde(rename = "Ref")]
    #[cfg_attr(feature = "serde", serde(rename = "Ref"))]
    pub _ref: Max35Text,

    #[yaserde(rename = "PricDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "PricDtls"))]
    pub pric_dtls: UnitPrice23,

    #[yaserde(rename = "TxOvrhd")]
    #[cfg_attr(feature = "serde", serde(rename = "TxOvrhd"))]
    pub tx_ovrhd: TotalFeesAndTaxes44,

    #[yaserde(rename = "OthrAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrAmt"))]
    pub othr_amt: Vec<OtherAmount1>,
}

impl Validate for Unit14 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct Unit1Choice {
    #[yaserde(rename = "UnitsNb")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitsNb"))]
    pub units_nb: Option<DecimalNumber>,
    #[yaserde(rename = "DgtlTknUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "DgtlTknUnit"))]
    pub dgtl_tkn_unit: Option<Max30DecimalNumber>,
}

impl Validate for Unit1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct UnitPrice23 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: TypeOfPrice46Choice,

    #[yaserde(rename = "Val")]
    #[cfg_attr(feature = "serde", serde(rename = "Val"))]
    pub val: PriceValue1,

    #[yaserde(rename = "PricMtd")]
    #[cfg_attr(feature = "serde", serde(rename = "PricMtd"))]
    pub pric_mtd: PriceMethod1Code,

    #[yaserde(rename = "AcrdIntrstNAV")]
    #[cfg_attr(feature = "serde", serde(rename = "AcrdIntrstNAV"))]
    pub acrd_intrst_nav: ActiveOrHistoricCurrencyAndAmount,

    #[yaserde(rename = "NbOfDaysAcrd")]
    #[cfg_attr(feature = "serde", serde(rename = "NbOfDaysAcrd"))]
    pub nb_of_days_acrd: Number,

    #[yaserde(rename = "TaxblIncmPerShr")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxblIncmPerShr"))]
    pub taxbl_incm_per_shr: ActiveCurrencyAnd13DecimalAmount,

    #[yaserde(rename = "TaxblIncmPerShrClctd")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxblIncmPerShrClctd"))]
    pub taxbl_incm_per_shr_clctd: TaxableIncomePerShareCalculated2Choice,
}

impl Validate for UnitPrice23 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ValorenIdentifier (pub String);
crate::simple_type!(ValorenIdentifier);

impl Validate for ValorenIdentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]

pub enum WaivingInstruction1Code {
    #[yaserde(rename = "WICA")]
    #[cfg_attr(feature = "serde", serde(rename = "WICA"))]
    Wica,
    #[yaserde(rename = "WIUN")]
    #[cfg_attr(feature = "serde", serde(rename = "WIUN"))]
    Wiun,
    __Unknown__(String),
}

impl Default for WaivingInstruction1Code {
    fn default() -> WaivingInstruction1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for WaivingInstruction1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.007.001.10")]
pub struct WaivingInstruction2Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<WaivingInstruction1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for WaivingInstruction2Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct WertpapierIdentifier (pub String);
crate::simple_type!(WertpapierIdentifier);

impl Validate for WertpapierIdentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct YesNoIndicator (pub bool);
crate::simple_type!(YesNoIndicator);

impl Validate for YesNoIndicator {}

impl crate::MxMessage for Document {
    const BUSINESS_AREA: crate::BusinessArea = crate::BusinessArea::sese;
    const FUNCTIONALITY: &'static str = "007";
    const VARIANT: &'static str = "001";
    const VERSION: &'static str = "10";
    const MESSAGE_NAME: &'static str = "sese.007.001.10";
    const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:sese.007.001.10";
}