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.092.001.04")]
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)]
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.092.001.04")]
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.092.001.04")]
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.092.001.04")]
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.092.001.04")]

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.092.001.04")]
pub struct DerivativesTradeRejectionStatisticalReportV04 {
    #[yaserde(rename = "RjctnSttstcs")]
    #[cfg_attr(feature = "serde", serde(rename = "RjctnSttstcs"))]
    pub rjctn_sttstcs: StatisticsPerCounterparty18Choice,

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

impl Validate for DerivativesTradeRejectionStatisticalReportV04 {}


#[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.092.001.04")]
pub struct DetailedReportStatistics7 {
    #[yaserde(rename = "TtlNbOfRpts")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlNbOfRpts"))]
    pub ttl_nb_of_rpts: Max20PositiveNumber,

    #[yaserde(rename = "TtlNbOfRptsAccptd")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlNbOfRptsAccptd"))]
    pub ttl_nb_of_rpts_accptd: Max20PositiveNumber,

    #[yaserde(rename = "TtlNbOfRptsRjctd")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlNbOfRptsRjctd"))]
    pub ttl_nb_of_rpts_rjctd: Max20PositiveNumber,

    #[yaserde(rename = "NbOfRptsRjctdPerErr")]
    #[cfg_attr(feature = "serde", serde(rename = "NbOfRptsRjctdPerErr"))]
    pub nb_of_rpts_rjctd_per_err: Vec<NumberOfTransactionsPerValidationRule6>,
}

impl Validate for DetailedReportStatistics7 {}


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

    #[yaserde(rename = "TtlNbOfRpts")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlNbOfRpts"))]
    pub ttl_nb_of_rpts: Max20PositiveNumber,

    #[yaserde(rename = "TtlNbOfRptsAccptd")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlNbOfRptsAccptd"))]
    pub ttl_nb_of_rpts_accptd: Max20PositiveNumber,

    #[yaserde(rename = "TtlNbOfRptsRjctd")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlNbOfRptsRjctd"))]
    pub ttl_nb_of_rpts_rjctd: Max20PositiveNumber,

    #[yaserde(rename = "TtlNbOfTxs")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlNbOfTxs"))]
    pub ttl_nb_of_txs: Max20PositiveNumber,

    #[yaserde(rename = "TtlNbOfTxsAccptd")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlNbOfTxsAccptd"))]
    pub ttl_nb_of_txs_accptd: Max20PositiveNumber,

    #[yaserde(rename = "TtlNbOfTxsRjctd")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlNbOfTxsRjctd"))]
    pub ttl_nb_of_txs_rjctd: Max20PositiveNumber,

    #[yaserde(rename = "TtlCrrctdRjctns")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlCrrctdRjctns"))]
    pub ttl_crrctd_rjctns: Max20PositiveNumber,

    #[yaserde(rename = "RjctnSttstcs")]
    #[cfg_attr(feature = "serde", serde(rename = "RjctnSttstcs"))]
    pub rjctn_sttstcs: Vec<RejectionStatistics9>,
}

impl Validate for DetailedStatisticsPerCounterparty19 {}


#[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.092.001.04")]
pub struct DetailedTransactionStatistics30 {
    #[yaserde(rename = "TtlNbOfTxs")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlNbOfTxs"))]
    pub ttl_nb_of_txs: Max20PositiveNumber,

    #[yaserde(rename = "TtlNbOfTxsAccptd")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlNbOfTxsAccptd"))]
    pub ttl_nb_of_txs_accptd: Max20PositiveNumber,

    #[yaserde(rename = "TtlNbOfTxsRjctd")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlNbOfTxsRjctd"))]
    pub ttl_nb_of_txs_rjctd: Max20PositiveNumber,

    #[yaserde(rename = "TtlCrrctdRjctns")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlCrrctdRjctns"))]
    pub ttl_crrctd_rjctns: Max20PositiveNumber,

    #[yaserde(rename = "TxsRjctnsRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "TxsRjctnsRsn"))]
    pub txs_rjctns_rsn: Vec<RejectionReason71>,
}

impl Validate for DetailedTransactionStatistics30 {}
#[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.092.001.04")]
pub struct DetailedTransactionStatistics7Choice {
    #[yaserde(rename = "DataSetActn")]
    #[cfg_attr(feature = "serde", serde(rename = "DataSetActn"))]
    pub data_set_actn: Option<ReportPeriodActivity1Code>,
    #[yaserde(rename = "DtldSttstcs")]
    #[cfg_attr(feature = "serde", serde(rename = "DtldSttstcs"))]
    pub dtld_sttstcs: Option<DetailedTransactionStatistics30>,
}

impl Validate for DetailedTransactionStatistics7Choice {}




#[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.092.001.04")]
pub struct Document {
    #[yaserde(rename = "DerivsTradRjctnSttstclRpt")]
    #[cfg_attr(feature = "serde", serde(rename = "DerivsTradRjctnSttstclRpt"))]
    pub derivs_trad_rjctn_sttstcl_rpt: DerivativesTradeRejectionStatisticalReportV04,
}

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

impl Validate for ExternalValidationRuleIdentification1Code {
    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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.092.001.04")]
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.092.001.04")]
pub struct GenericValidationRuleIdentification1 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

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

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

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

impl Validate for GenericValidationRuleIdentification1 {}


#[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.092.001.04")]
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.092.001.04")]
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.092.001.04")]
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 Max15NumericText (pub String);
crate::simple_type!(Max15NumericText);

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

impl Validate for Max20PositiveNumber {
    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)]
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 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.092.001.04")]
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.092.001.04")]
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.092.001.04")]

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.092.001.04")]
pub struct NumberOfTransactionsPerValidationRule6 {
    #[yaserde(rename = "DtldNb")]
    #[cfg_attr(feature = "serde", serde(rename = "DtldNb"))]
    pub dtld_nb: Max15NumericText,

    #[yaserde(rename = "RptSts")]
    #[cfg_attr(feature = "serde", serde(rename = "RptSts"))]
    pub rpt_sts: Vec<RejectionReason70>,
}

impl Validate for NumberOfTransactionsPerValidationRule6 {}
#[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.092.001.04")]
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.092.001.04")]
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.092.001.04")]
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.092.001.04")]
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.092.001.04")]
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.092.001.04")]
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.092.001.04")]
pub struct RejectionReason70 {
    #[yaserde(rename = "MsgRptId")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgRptId"))]
    pub msg_rpt_id: Max140Text,

    #[yaserde(rename = "Sts")]
    #[cfg_attr(feature = "serde", serde(rename = "Sts"))]
    pub sts: ReportingMessageStatus2Code,

    #[yaserde(rename = "DtldVldtnRule")]
    #[cfg_attr(feature = "serde", serde(rename = "DtldVldtnRule"))]
    pub dtld_vldtn_rule: GenericValidationRuleIdentification1,
}

impl Validate for RejectionReason70 {}


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

    #[yaserde(rename = "Sts")]
    #[cfg_attr(feature = "serde", serde(rename = "Sts"))]
    pub sts: ReportingMessageStatus2Code,

    #[yaserde(rename = "DtldVldtnRule")]
    #[cfg_attr(feature = "serde", serde(rename = "DtldVldtnRule"))]
    pub dtld_vldtn_rule: Vec<GenericValidationRuleIdentification1>,
}

impl Validate for RejectionReason71 {}


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

    #[yaserde(rename = "RptSttstcs")]
    #[cfg_attr(feature = "serde", serde(rename = "RptSttstcs"))]
    pub rpt_sttstcs: DetailedReportStatistics7,

    #[yaserde(rename = "DerivSttstcs")]
    #[cfg_attr(feature = "serde", serde(rename = "DerivSttstcs"))]
    pub deriv_sttstcs: DetailedTransactionStatistics7Choice,
}

impl Validate for RejectionStatistics9 {}


#[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.092.001.04")]

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

pub enum ReportingMessageStatus2Code {
    #[yaserde(rename = "ACPT")]
    #[cfg_attr(feature = "serde", serde(rename = "ACPT"))]
    Acpt,
    #[yaserde(rename = "RJCT")]
    #[cfg_attr(feature = "serde", serde(rename = "RJCT"))]
    Rjct,
    #[yaserde(rename = "INCF")]
    #[cfg_attr(feature = "serde", serde(rename = "INCF"))]
    Incf,
    #[yaserde(rename = "CRPT")]
    #[cfg_attr(feature = "serde", serde(rename = "CRPT"))]
    Crpt,
    #[yaserde(rename = "NAUT")]
    #[cfg_attr(feature = "serde", serde(rename = "NAUT"))]
    Naut,
    __Unknown__(String),
}

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

impl Validate for ReportingMessageStatus2Code {}
#[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.092.001.04")]
pub struct StatisticsPerCounterparty18Choice {
    #[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<DetailedStatisticsPerCounterparty19>,
}

impl Validate for StatisticsPerCounterparty18Choice {}




#[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.092.001.04")]
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.092.001.04")]
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.092.001.04")]
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.092.001.04")]

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.092.001.04")]
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.092.001.04")]
pub struct ValidationRuleSchemeName1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ExternalValidationRuleIdentification1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max35Text>,
}

impl Validate for ValidationRuleSchemeName1Choice {}

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