rust_iso20022 0.1.0

// @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:auth.106.001.01")]
pub struct AbnormalValuesData4 {
    #[yaserde(rename = "CtrPtyId")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrPtyId"))]
    pub ctr_pty_id: CounterpartyData92,

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

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

    #[yaserde(rename = "TxDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "TxDtls"))]
    pub tx_dtls: Vec<AbnormalValuesTransactionData2>,
}

impl Validate for AbnormalValuesData4 {}


#[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:auth.106.001.01")]
pub struct AbnormalValuesTransactionData2 {
    #[yaserde(rename = "TxId")]
    #[cfg_attr(feature = "serde", serde(rename = "TxId"))]
    pub tx_id: TradeTransactionIdentification24,

    #[yaserde(rename = "NtnlAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "NtnlAmt"))]
    pub ntnl_amt: NotionalAmountLegs5,

    #[yaserde(rename = "NtnlQty")]
    #[cfg_attr(feature = "serde", serde(rename = "NtnlQty"))]
    pub ntnl_qty: NotionalQuantityLegs5,
}

impl Validate for AbnormalValuesTransactionData2 {}


#[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 ActiveOrHistoricCurrencyAnd19DecimalAmountSimpleType (pub String);
crate::simple_type!(ActiveOrHistoricCurrencyAnd19DecimalAmountSimpleType);

impl Validate for ActiveOrHistoricCurrencyAnd19DecimalAmountSimpleType {
    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:auth.106.001.01")]
pub struct ActiveOrHistoricCurrencyAnd19DecimalAmount {
    #[yaserde(text)]
    pub value: String,
    #[yaserde(attribute, rename = "Ccy")]
    #[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
    pub ccy: ActiveCurrencyCode,
}

impl Validate for ActiveOrHistoricCurrencyAnd19DecimalAmount {}


#[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:auth.106.001.01")]
pub struct AgreementType2Choice {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: Option<ExternalAgreementType1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max50Text>,
}

impl Validate for AgreementType2Choice {}




#[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:auth.106.001.01")]
pub struct AmountAndDirection106 {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: ActiveOrHistoricCurrencyAnd19DecimalAmount,

    #[yaserde(rename = "Sgn")]
    #[cfg_attr(feature = "serde", serde(rename = "Sgn"))]
    pub sgn: PlusOrMinusIndicator,
}

impl Validate for AmountAndDirection106 {}


#[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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.106.001.01")]
pub struct CollateralPortfolioCode5Choice {
    #[yaserde(rename = "Prtfl")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtfl"))]
    pub prtfl: Option<PortfolioCode3Choice>,
    #[yaserde(rename = "MrgnPrtflCd")]
    #[cfg_attr(feature = "serde", serde(rename = "MrgnPrtflCd"))]
    pub mrgn_prtfl_cd: Option<MarginPortfolio3>,
}

impl Validate for CollateralPortfolioCode5Choice {}




#[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:auth.106.001.01")]
pub struct CounterpartyData92 {
    #[yaserde(rename = "RptgCtrPty")]
    #[cfg_attr(feature = "serde", serde(rename = "RptgCtrPty"))]
    pub rptg_ctr_pty: OrganisationIdentification15Choice,

    #[yaserde(rename = "RptSubmitgNtty")]
    #[cfg_attr(feature = "serde", serde(rename = "RptSubmitgNtty"))]
    pub rpt_submitg_ntty: OrganisationIdentification15Choice,

    #[yaserde(rename = "NttyRspnsblForRpt")]
    #[cfg_attr(feature = "serde", serde(rename = "NttyRspnsblForRpt"))]
    pub ntty_rspnsbl_for_rpt: OrganisationIdentification15Choice,
}

impl Validate for CounterpartyData92 {}


#[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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.106.001.01")]
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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.106.001.01")]

pub enum DerivativeEventType3Code {
    #[yaserde(rename = "ALOC")]
    #[cfg_attr(feature = "serde", serde(rename = "ALOC"))]
    Aloc,
    #[yaserde(rename = "CLRG")]
    #[cfg_attr(feature = "serde", serde(rename = "CLRG"))]
    Clrg,
    #[yaserde(rename = "CLAL")]
    #[cfg_attr(feature = "serde", serde(rename = "CLAL"))]
    Clal,
    #[yaserde(rename = "COMP")]
    #[cfg_attr(feature = "serde", serde(rename = "COMP"))]
    Comp,
    #[yaserde(rename = "CORP")]
    #[cfg_attr(feature = "serde", serde(rename = "CORP"))]
    Corp,
    #[yaserde(rename = "CREV")]
    #[cfg_attr(feature = "serde", serde(rename = "CREV"))]
    Crev,
    #[yaserde(rename = "ETRM")]
    #[cfg_attr(feature = "serde", serde(rename = "ETRM"))]
    Etrm,
    #[yaserde(rename = "EXER")]
    #[cfg_attr(feature = "serde", serde(rename = "EXER"))]
    Exer,
    #[yaserde(rename = "INCP")]
    #[cfg_attr(feature = "serde", serde(rename = "INCP"))]
    Incp,
    #[yaserde(rename = "NOVA")]
    #[cfg_attr(feature = "serde", serde(rename = "NOVA"))]
    Nova,
    #[yaserde(rename = "PTNG")]
    #[cfg_attr(feature = "serde", serde(rename = "PTNG"))]
    Ptng,
    #[yaserde(rename = "TRAD")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAD"))]
    Trad,
    #[yaserde(rename = "UPDT")]
    #[cfg_attr(feature = "serde", serde(rename = "UPDT"))]
    Updt,
    __Unknown__(String),
}

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

impl Validate for DerivativeEventType3Code {}



#[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:auth.106.001.01")]
pub struct DerivativesTradeWarningsReportV01 {
    #[yaserde(rename = "WrnngsSttstcs")]
    #[cfg_attr(feature = "serde", serde(rename = "WrnngsSttstcs"))]
    pub wrnngs_sttstcs: StatisticsPerCounterparty16Choice,

    #[yaserde(rename = "SplmtryData")]
    #[cfg_attr(feature = "serde", serde(rename = "SplmtryData"))]
    pub splmtry_data: Vec<SupplementaryData1>,
}

impl Validate for DerivativesTradeWarningsReportV01 {}
#[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:auth.106.001.01")]
pub struct DetailedAbnormalValuesStatistics4Choice {
    #[yaserde(rename = "DataSetActn")]
    #[cfg_attr(feature = "serde", serde(rename = "DataSetActn"))]
    pub data_set_actn: Option<ReportPeriodActivity1Code>,
    #[yaserde(rename = "Rpt")]
    #[cfg_attr(feature = "serde", serde(rename = "Rpt"))]
    pub rpt: Option<DetailedTransactionStatistics28>,
}

impl Validate for DetailedAbnormalValuesStatistics4Choice {}
#[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:auth.106.001.01")]
pub struct DetailedMissingMarginInformationStatistics4Choice {
    #[yaserde(rename = "DataSetActn")]
    #[cfg_attr(feature = "serde", serde(rename = "DataSetActn"))]
    pub data_set_actn: Option<ReportPeriodActivity1Code>,
    #[yaserde(rename = "Rpt")]
    #[cfg_attr(feature = "serde", serde(rename = "Rpt"))]
    pub rpt: Option<DetailedTransactionStatistics26>,
}

impl Validate for DetailedMissingMarginInformationStatistics4Choice {}
#[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:auth.106.001.01")]
pub struct DetailedMissingValuationsStatistics4Choice {
    #[yaserde(rename = "DataSetActn")]
    #[cfg_attr(feature = "serde", serde(rename = "DataSetActn"))]
    pub data_set_actn: Option<ReportPeriodActivity1Code>,
    #[yaserde(rename = "Rpt")]
    #[cfg_attr(feature = "serde", serde(rename = "Rpt"))]
    pub rpt: Option<DetailedTransactionStatistics27>,
}

impl Validate for DetailedMissingValuationsStatistics4Choice {}




#[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:auth.106.001.01")]
pub struct DetailedStatisticsPerCounterparty17 {
    #[yaserde(rename = "RefDt")]
    #[cfg_attr(feature = "serde", serde(rename = "RefDt"))]
    pub ref_dt: Isodate,

    #[yaserde(rename = "MssngValtn")]
    #[cfg_attr(feature = "serde", serde(rename = "MssngValtn"))]
    pub mssng_valtn: DetailedMissingValuationsStatistics4Choice,

    #[yaserde(rename = "MssngMrgnInf")]
    #[cfg_attr(feature = "serde", serde(rename = "MssngMrgnInf"))]
    pub mssng_mrgn_inf: DetailedMissingMarginInformationStatistics4Choice,

    #[yaserde(rename = "AbnrmlVals")]
    #[cfg_attr(feature = "serde", serde(rename = "AbnrmlVals"))]
    pub abnrml_vals: DetailedAbnormalValuesStatistics4Choice,
}

impl Validate for DetailedStatisticsPerCounterparty17 {}


#[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:auth.106.001.01")]
pub struct DetailedTransactionStatistics26 {
    #[yaserde(rename = "NbOfOutsdngDerivs")]
    #[cfg_attr(feature = "serde", serde(rename = "NbOfOutsdngDerivs"))]
    pub nb_of_outsdng_derivs: Number,

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

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

    #[yaserde(rename = "Wrnngs")]
    #[cfg_attr(feature = "serde", serde(rename = "Wrnngs"))]
    pub wrnngs: Vec<MissingMarginData2>,
}

impl Validate for DetailedTransactionStatistics26 {}


#[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:auth.106.001.01")]
pub struct DetailedTransactionStatistics27 {
    #[yaserde(rename = "NbOfOutsdngDerivs")]
    #[cfg_attr(feature = "serde", serde(rename = "NbOfOutsdngDerivs"))]
    pub nb_of_outsdng_derivs: Number,

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

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

    #[yaserde(rename = "Wrnngs")]
    #[cfg_attr(feature = "serde", serde(rename = "Wrnngs"))]
    pub wrnngs: Vec<MissingValuationsData2>,
}

impl Validate for DetailedTransactionStatistics27 {}


#[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:auth.106.001.01")]
pub struct DetailedTransactionStatistics28 {
    #[yaserde(rename = "NbOfDerivsRptd")]
    #[cfg_attr(feature = "serde", serde(rename = "NbOfDerivsRptd"))]
    pub nb_of_derivs_rptd: Number,

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

    #[yaserde(rename = "Wrnngs")]
    #[cfg_attr(feature = "serde", serde(rename = "Wrnngs"))]
    pub wrnngs: Vec<AbnormalValuesData4>,
}

impl Validate for DetailedTransactionStatistics28 {}


#[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:auth.106.001.01")]
pub struct Document {
    #[yaserde(rename = "DerivsTradWrnngsRpt")]
    #[cfg_attr(feature = "serde", serde(rename = "DerivsTradWrnngsRpt"))]
    pub derivs_trad_wrnngs_rpt: DerivativesTradeWarningsReportV01,
}

impl Validate for Document {}


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

impl Validate for ExternalAgreementType1Code {
    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 ExternalUnitOfMeasure1Code (pub String);
crate::simple_type!(ExternalUnitOfMeasure1Code);

impl Validate for ExternalUnitOfMeasure1Code {
    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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.106.001.01")]

pub enum Frequency19Code {
    #[yaserde(rename = "DAIL")]
    #[cfg_attr(feature = "serde", serde(rename = "DAIL"))]
    Dail,
    #[yaserde(rename = "WEEK")]
    #[cfg_attr(feature = "serde", serde(rename = "WEEK"))]
    Week,
    #[yaserde(rename = "MNTH")]
    #[cfg_attr(feature = "serde", serde(rename = "MNTH"))]
    Mnth,
    #[yaserde(rename = "YEAR")]
    #[cfg_attr(feature = "serde", serde(rename = "YEAR"))]
    Year,
    #[yaserde(rename = "ADHO")]
    #[cfg_attr(feature = "serde", serde(rename = "ADHO"))]
    Adho,
    #[yaserde(rename = "EXPI")]
    #[cfg_attr(feature = "serde", serde(rename = "EXPI"))]
    Expi,
    #[yaserde(rename = "MIAN")]
    #[cfg_attr(feature = "serde", serde(rename = "MIAN"))]
    Mian,
    #[yaserde(rename = "QURT")]
    #[cfg_attr(feature = "serde", serde(rename = "QURT"))]
    Qurt,
    #[yaserde(rename = "HOUL")]
    #[cfg_attr(feature = "serde", serde(rename = "HOUL"))]
    Houl,
    #[yaserde(rename = "ODMD")]
    #[cfg_attr(feature = "serde", serde(rename = "ODMD"))]
    Odmd,
    __Unknown__(String),
}

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

impl Validate for Frequency19Code {}



#[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:auth.106.001.01")]
pub struct GenericIdentification175 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max72Text,

    #[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 GenericIdentification175 {}


#[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 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:auth.106.001.01")]
pub struct LegalPersonIdentification1 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: OrganisationIdentification15Choice,

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

impl Validate for LegalPersonIdentification1 {}


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

impl Validate for LongFraction19DecimalNumber {}
#[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:auth.106.001.01")]
pub struct MarginPortfolio3 {
    #[yaserde(rename = "InitlMrgnPrtflCd")]
    #[cfg_attr(feature = "serde", serde(rename = "InitlMrgnPrtflCd"))]
    pub initl_mrgn_prtfl_cd: PortfolioCode5Choice,

    #[yaserde(rename = "VartnMrgnPrtflCd")]
    #[cfg_attr(feature = "serde", serde(rename = "VartnMrgnPrtflCd"))]
    pub vartn_mrgn_prtfl_cd: PortfolioCode5Choice,
}

impl Validate for MarginPortfolio3 {}


#[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:auth.106.001.01")]
pub struct MasterAgreement8 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: AgreementType2Choice,

    #[yaserde(rename = "Vrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Vrsn"))]
    pub vrsn: Max50Text,

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

impl Validate for MasterAgreement8 {}


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

impl Validate for Max105Text {
    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() > 105 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 105 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[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 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 Max3Number (pub String);
crate::simple_type!(Max3Number);

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

impl Validate for Max500Text {
    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() > 500 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 500 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

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

impl Validate for Max50Text {
    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() > 50 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 50 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

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

impl Validate for Max52Text {
    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() > 52 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 52 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

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

impl Validate for Max72Text {
    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() > 72 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 72 \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:auth.106.001.01")]
pub struct MissingMarginData2 {
    #[yaserde(rename = "CtrPtyId")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrPtyId"))]
    pub ctr_pty_id: CounterpartyData92,

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

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

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

    #[yaserde(rename = "TxDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "TxDtls"))]
    pub tx_dtls: Vec<MissingMarginTransactionData2>,
}

impl Validate for MissingMarginData2 {}


#[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:auth.106.001.01")]
pub struct MissingMarginTransactionData2 {
    #[yaserde(rename = "TxId")]
    #[cfg_attr(feature = "serde", serde(rename = "TxId"))]
    pub tx_id: TradeTransactionIdentification24,

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

impl Validate for MissingMarginTransactionData2 {}


#[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:auth.106.001.01")]
pub struct MissingValuationsData2 {
    #[yaserde(rename = "CtrPtyId")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrPtyId"))]
    pub ctr_pty_id: CounterpartyData92,

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

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

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

    #[yaserde(rename = "TxDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "TxDtls"))]
    pub tx_dtls: Vec<MissingValuationsTransactionData2>,
}

impl Validate for MissingValuationsData2 {}


#[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:auth.106.001.01")]
pub struct MissingValuationsTransactionData2 {
    #[yaserde(rename = "TxId")]
    #[cfg_attr(feature = "serde", serde(rename = "TxId"))]
    pub tx_id: TradeTransactionIdentification24,

    #[yaserde(rename = "ValtnAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "ValtnAmt"))]
    pub valtn_amt: AmountAndDirection106,

    #[yaserde(rename = "ValtnTmStmp")]
    #[cfg_attr(feature = "serde", serde(rename = "ValtnTmStmp"))]
    pub valtn_tm_stmp: DateAndDateTime2Choice,
}

impl Validate for MissingValuationsTransactionData2 {}


#[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:auth.106.001.01")]
pub struct NaturalPersonIdentification2 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: GenericIdentification175,

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

    #[yaserde(rename = "Dmcl")]
    #[cfg_attr(feature = "serde", serde(rename = "Dmcl"))]
    pub dmcl: Max500Text,
}

impl Validate for NaturalPersonIdentification2 {}


#[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:auth.106.001.01")]
pub struct NaturalPersonIdentification3 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: NaturalPersonIdentification2,

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

impl Validate for NaturalPersonIdentification3 {}


#[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:auth.106.001.01")]

pub enum NotApplicable1Code {
    #[yaserde(rename = "NOAP")]
    #[cfg_attr(feature = "serde", serde(rename = "NOAP"))]
    Noap,
    __Unknown__(String),
}

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

impl Validate for NotApplicable1Code {}



#[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:auth.106.001.01")]
pub struct NotionalAmount5 {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: AmountAndDirection106,

    #[yaserde(rename = "SchdlPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "SchdlPrd"))]
    pub schdl_prd: Vec<Schedule11>,
}

impl Validate for NotionalAmount5 {}


#[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:auth.106.001.01")]
pub struct NotionalAmount6 {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: AmountAndDirection106,

    #[yaserde(rename = "SchdlPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "SchdlPrd"))]
    pub schdl_prd: Vec<Schedule11>,

    #[yaserde(rename = "Ccy")]
    #[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
    pub ccy: ActiveOrHistoricCurrencyCode,
}

impl Validate for NotionalAmount6 {}


#[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:auth.106.001.01")]
pub struct NotionalAmountLegs5 {
    #[yaserde(rename = "FrstLeg")]
    #[cfg_attr(feature = "serde", serde(rename = "FrstLeg"))]
    pub frst_leg: NotionalAmount5,

    #[yaserde(rename = "ScndLeg")]
    #[cfg_attr(feature = "serde", serde(rename = "ScndLeg"))]
    pub scnd_leg: NotionalAmount6,
}

impl Validate for NotionalAmountLegs5 {}


#[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:auth.106.001.01")]
pub struct NotionalQuantity9 {
    #[yaserde(rename = "TtlQty")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlQty"))]
    pub ttl_qty: LongFraction19DecimalNumber,

    #[yaserde(rename = "UnitOfMeasr")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitOfMeasr"))]
    pub unit_of_measr: UnitOfMeasure8Choice,

    #[yaserde(rename = "Dtls")]
    #[cfg_attr(feature = "serde", serde(rename = "Dtls"))]
    pub dtls: QuantityOrTerm1Choice,
}

impl Validate for NotionalQuantity9 {}


#[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:auth.106.001.01")]
pub struct NotionalQuantityLegs5 {
    #[yaserde(rename = "FrstLeg")]
    #[cfg_attr(feature = "serde", serde(rename = "FrstLeg"))]
    pub frst_leg: NotionalQuantity9,

    #[yaserde(rename = "ScndLeg")]
    #[cfg_attr(feature = "serde", serde(rename = "ScndLeg"))]
    pub scnd_leg: NotionalQuantity9,
}

impl Validate for NotionalQuantityLegs5 {}


#[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:auth.106.001.01")]
pub struct OrganisationIdentification15Choice {
    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Option<Leiidentifier>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<OrganisationIdentification38>,
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_b_i_c: Option<AnyBICDec2014Identifier>,
}

impl Validate for OrganisationIdentification15Choice {}




#[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:auth.106.001.01")]
pub struct OrganisationIdentification38 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: GenericIdentification175,

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

    #[yaserde(rename = "Dmcl")]
    #[cfg_attr(feature = "serde", serde(rename = "Dmcl"))]
    pub dmcl: Max500Text,
}

impl Validate for OrganisationIdentification38 {}
#[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:auth.106.001.01")]
pub struct PartyIdentification248Choice {
    #[yaserde(rename = "Lgl")]
    #[cfg_attr(feature = "serde", serde(rename = "Lgl"))]
    pub lgl: Option<LegalPersonIdentification1>,
    #[yaserde(rename = "Ntrl")]
    #[cfg_attr(feature = "serde", serde(rename = "Ntrl"))]
    pub ntrl: Option<NaturalPersonIdentification3>,
}

impl Validate for PartyIdentification248Choice {}




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

impl Validate for PlusOrMinusIndicator {}
#[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:auth.106.001.01")]
pub struct PortfolioCode3Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<Max52Text>,
    #[yaserde(rename = "NoPrtfl")]
    #[cfg_attr(feature = "serde", serde(rename = "NoPrtfl"))]
    pub no_prtfl: Option<NotApplicable1Code>,
}

impl Validate for PortfolioCode3Choice {}
#[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:auth.106.001.01")]
pub struct PortfolioCode5Choice {
    #[yaserde(rename = "Prtfl")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtfl"))]
    pub prtfl: Option<PortfolioIdentification3>,
    #[yaserde(rename = "NoPrtfl")]
    #[cfg_attr(feature = "serde", serde(rename = "NoPrtfl"))]
    pub no_prtfl: Option<NotApplicable1Code>,
}

impl Validate for PortfolioCode5Choice {}




#[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:auth.106.001.01")]
pub struct PortfolioIdentification3 {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Max52Text,

    #[yaserde(rename = "PrtflTxXmptn")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtflTxXmptn"))]
    pub prtfl_tx_xmptn: TrueFalseIndicator,
}

impl Validate for PortfolioIdentification3 {}
#[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:auth.106.001.01")]
pub struct QuantityOrTerm1Choice {
    #[yaserde(rename = "SchdlPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "SchdlPrd"))]
    pub schdl_prd: Vec<Schedule10>,
    #[yaserde(rename = "Term")]
    #[cfg_attr(feature = "serde", serde(rename = "Term"))]
    pub term: Option<QuantityTerm1>,
}

impl Validate for QuantityOrTerm1Choice {}




#[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:auth.106.001.01")]
pub struct QuantityTerm1 {
    #[yaserde(rename = "Qty")]
    #[cfg_attr(feature = "serde", serde(rename = "Qty"))]
    pub qty: LongFraction19DecimalNumber,

    #[yaserde(rename = "UnitOfMeasr")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitOfMeasr"))]
    pub unit_of_measr: UnitOfMeasure8Choice,

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

    #[yaserde(rename = "TmUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "TmUnit"))]
    pub tm_unit: Frequency19Code,
}

impl Validate for QuantityTerm1 {}


#[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:auth.106.001.01")]

pub enum ReportPeriodActivity1Code {
    #[yaserde(rename = "NOTX")]
    #[cfg_attr(feature = "serde", serde(rename = "NOTX"))]
    Notx,
    __Unknown__(String),
}

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

impl Validate for ReportPeriodActivity1Code {}



#[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:auth.106.001.01")]
pub struct Schedule10 {
    #[yaserde(rename = "Qty")]
    #[cfg_attr(feature = "serde", serde(rename = "Qty"))]
    pub qty: LongFraction19DecimalNumber,

    #[yaserde(rename = "UnitOfMeasr")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitOfMeasr"))]
    pub unit_of_measr: UnitOfMeasure8Choice,

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

    #[yaserde(rename = "UadjstdEndDt")]
    #[cfg_attr(feature = "serde", serde(rename = "UadjstdEndDt"))]
    pub uadjstd_end_dt: Isodate,
}

impl Validate for Schedule10 {}


#[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:auth.106.001.01")]
pub struct Schedule11 {
    #[yaserde(rename = "UadjstdFctvDt")]
    #[cfg_attr(feature = "serde", serde(rename = "UadjstdFctvDt"))]
    pub uadjstd_fctv_dt: Isodate,

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

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

impl Validate for Schedule11 {}
#[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:auth.106.001.01")]
pub struct StatisticsPerCounterparty16Choice {
    #[yaserde(rename = "DataSetActn")]
    #[cfg_attr(feature = "serde", serde(rename = "DataSetActn"))]
    pub data_set_actn: Option<ReportPeriodActivity1Code>,
    #[yaserde(rename = "Rpt")]
    #[cfg_attr(feature = "serde", serde(rename = "Rpt"))]
    pub rpt: Option<DetailedStatisticsPerCounterparty17>,
}

impl Validate for StatisticsPerCounterparty16Choice {}




#[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:auth.106.001.01")]
pub struct SupplementaryData1 {
    #[yaserde(rename = "PlcAndNm")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcAndNm"))]
    pub plc_and_nm: Max350Text,

    #[yaserde(rename = "Envlp")]
    #[cfg_attr(feature = "serde", serde(rename = "Envlp"))]
    pub envlp: SupplementaryDataEnvelope1,
}

impl Validate for SupplementaryData1 {}


#[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:auth.106.001.01")]
pub struct SupplementaryDataEnvelope1 {}

impl Validate for SupplementaryDataEnvelope1 {}


#[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:auth.106.001.01")]
pub struct TradeTransactionIdentification24 {
    #[yaserde(rename = "TechRcrdId")]
    #[cfg_attr(feature = "serde", serde(rename = "TechRcrdId"))]
    pub tech_rcrd_id: Max140Text,

    #[yaserde(rename = "ActnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ActnTp"))]
    pub actn_tp: TransactionOperationType10Code,

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

    #[yaserde(rename = "DerivEvtTp")]
    #[cfg_attr(feature = "serde", serde(rename = "DerivEvtTp"))]
    pub deriv_evt_tp: DerivativeEventType3Code,

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

    #[yaserde(rename = "OthrCtrPty")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrCtrPty"))]
    pub othr_ctr_pty: PartyIdentification248Choice,

    #[yaserde(rename = "UnqIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "UnqIdr"))]
    pub unq_idr: UniqueTransactionIdentifier2Choice,

    #[yaserde(rename = "MstrAgrmt")]
    #[cfg_attr(feature = "serde", serde(rename = "MstrAgrmt"))]
    pub mstr_agrmt: MasterAgreement8,

    #[yaserde(rename = "CollPrtflCd")]
    #[cfg_attr(feature = "serde", serde(rename = "CollPrtflCd"))]
    pub coll_prtfl_cd: CollateralPortfolioCode5Choice,
}

impl Validate for TradeTransactionIdentification24 {}


#[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:auth.106.001.01")]

pub enum TransactionOperationType10Code {
    #[yaserde(rename = "COMP")]
    #[cfg_attr(feature = "serde", serde(rename = "COMP"))]
    Comp,
    #[yaserde(rename = "CORR")]
    #[cfg_attr(feature = "serde", serde(rename = "CORR"))]
    Corr,
    #[yaserde(rename = "EROR")]
    #[cfg_attr(feature = "serde", serde(rename = "EROR"))]
    Eror,
    #[yaserde(rename = "MODI")]
    #[cfg_attr(feature = "serde", serde(rename = "MODI"))]
    Modi,
    #[yaserde(rename = "NEWT")]
    #[cfg_attr(feature = "serde", serde(rename = "NEWT"))]
    Newt,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "POSC")]
    #[cfg_attr(feature = "serde", serde(rename = "POSC"))]
    Posc,
    #[yaserde(rename = "REVI")]
    #[cfg_attr(feature = "serde", serde(rename = "REVI"))]
    Revi,
    #[yaserde(rename = "TERM")]
    #[cfg_attr(feature = "serde", serde(rename = "TERM"))]
    Term,
    #[yaserde(rename = "VALU")]
    #[cfg_attr(feature = "serde", serde(rename = "VALU"))]
    Valu,
    #[yaserde(rename = "MARU")]
    #[cfg_attr(feature = "serde", serde(rename = "MARU"))]
    Maru,
    #[yaserde(rename = "PRTO")]
    #[cfg_attr(feature = "serde", serde(rename = "PRTO"))]
    Prto,
    __Unknown__(String),
}

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

impl Validate for TransactionOperationType10Code {}



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

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

impl Validate for Utiidentifier {}
#[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:auth.106.001.01")]
pub struct UniqueTransactionIdentifier2Choice {
    #[yaserde(rename = "UnqTxIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "UnqTxIdr"))]
    pub unq_tx_idr: Option<Utiidentifier>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification175>,
}

impl Validate for UniqueTransactionIdentifier2Choice {}
#[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:auth.106.001.01")]
pub struct UnitOfMeasure8Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ExternalUnitOfMeasure1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification175>,
}

impl Validate for UnitOfMeasure8Choice {}

impl crate::MxMessage for Document {
    const BUSINESS_AREA: crate::BusinessArea = crate::BusinessArea::auth;
    const FUNCTIONALITY: &'static str = "106";
    const VARIANT: &'static str = "001";
    const VERSION: &'static str = "01";
    const MESSAGE_NAME: &'static str = "auth.106.001.01";
    const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:auth.106.001.01";
}