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

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

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

impl Validate for AddressType2Code {}



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

impl Validate for AnyBICDec2014Identifier {}
#[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.029.001.05")]

pub enum AnyMIC1Code {
    #[yaserde(rename = "ANYM")]
    #[cfg_attr(feature = "serde", serde(rename = "ANYM"))]
    Anym,
    __Unknown__(String),
}

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

impl Validate for AnyMIC1Code {}



#[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.029.001.05")]
pub struct BasketQuery1 {
    #[yaserde(rename = "Strr")]
    #[cfg_attr(feature = "serde", serde(rename = "Strr"))]
    pub strr: Leiidentifier,

    #[yaserde(rename = "Idr")]
    #[cfg_attr(feature = "serde", serde(rename = "Idr"))]
    pub idr: Max52Text,

    #[yaserde(rename = "ISIN")]
    #[cfg_attr(feature = "serde", serde(rename = "ISIN"))]
    pub isin: Isinoct2015Identifier,
}

impl Validate for BasketQuery1 {}


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

impl Validate for Cfioct2015Identifier {}
#[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.029.001.05")]
pub struct CorporateSectorCriteria6 {
    #[yaserde(rename = "FISctr")]
    #[cfg_attr(feature = "serde", serde(rename = "FISctr"))]
    pub fi_sctr: Vec<FinancialPartySectorType2Code>,

    #[yaserde(rename = "NFISctr")]
    #[cfg_attr(feature = "serde", serde(rename = "NFISctr"))]
    pub nfi_sctr: Vec<NonFinancialPartySector1Code>,

    #[yaserde(rename = "NotRptd")]
    #[cfg_attr(feature = "serde", serde(rename = "NotRptd"))]
    pub not_rptd: NotReported1Code,
}

impl Validate for CorporateSectorCriteria6 {}


#[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.029.001.05")]
pub struct DateOrBlankQuery2Choice {
    #[yaserde(rename = "Rg")]
    #[cfg_attr(feature = "serde", serde(rename = "Rg"))]
    pub rg: Option<DatePeriod1>,
    #[yaserde(rename = "NotRptd")]
    #[cfg_attr(feature = "serde", serde(rename = "NotRptd"))]
    pub not_rptd: Option<NotReported1Code>,
}

impl Validate for DateOrBlankQuery2Choice {}




#[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.029.001.05")]
pub struct DatePeriod1 {
    #[yaserde(rename = "FrDt")]
    #[cfg_attr(feature = "serde", serde(rename = "FrDt"))]
    pub fr_dt: Isodate,

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

impl Validate for DatePeriod1 {}
#[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.029.001.05")]
pub struct DateTimeOrBlankQuery1Choice {
    #[yaserde(rename = "Rg")]
    #[cfg_attr(feature = "serde", serde(rename = "Rg"))]
    pub rg: Option<DateTimePeriod1>,
    #[yaserde(rename = "NotRptd")]
    #[cfg_attr(feature = "serde", serde(rename = "NotRptd"))]
    pub not_rptd: Option<NotReported1Code>,
}

impl Validate for DateTimeOrBlankQuery1Choice {}




#[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.029.001.05")]
pub struct DateTimePeriod1 {
    #[yaserde(rename = "FrDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "FrDtTm"))]
    pub fr_dt_tm: IsodateTime,

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

impl Validate for DateTimePeriod1 {}


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

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

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

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.029.001.05")]
pub struct DerivativesTradeReportQueryV05 {
    #[yaserde(rename = "RqstngAuthrty")]
    #[cfg_attr(feature = "serde", serde(rename = "RqstngAuthrty"))]
    pub rqstng_authrty: PartyIdentification121Choice,

    #[yaserde(rename = "TradQryData")]
    #[cfg_attr(feature = "serde", serde(rename = "TradQryData"))]
    pub trad_qry_data: TradeReportQuery18Choice,

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

impl Validate for DerivativesTradeReportQueryV05 {}


#[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.029.001.05")]
pub struct Document {
    #[yaserde(rename = "DerivsTradRptQry")]
    #[cfg_attr(feature = "serde", serde(rename = "DerivsTradRptQry"))]
    pub derivs_trad_rpt_qry: DerivativesTradeReportQueryV05,
}

impl Validate for Document {}


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

pub enum FinancialInstrumentContractType2Code {
    #[yaserde(rename = "CFDS")]
    #[cfg_attr(feature = "serde", serde(rename = "CFDS"))]
    Cfds,
    #[yaserde(rename = "FRAS")]
    #[cfg_attr(feature = "serde", serde(rename = "FRAS"))]
    Fras,
    #[yaserde(rename = "FUTR")]
    #[cfg_attr(feature = "serde", serde(rename = "FUTR"))]
    Futr,
    #[yaserde(rename = "FORW")]
    #[cfg_attr(feature = "serde", serde(rename = "FORW"))]
    Forw,
    #[yaserde(rename = "OPTN")]
    #[cfg_attr(feature = "serde", serde(rename = "OPTN"))]
    Optn,
    #[yaserde(rename = "SPDB")]
    #[cfg_attr(feature = "serde", serde(rename = "SPDB"))]
    Spdb,
    #[yaserde(rename = "SWAP")]
    #[cfg_attr(feature = "serde", serde(rename = "SWAP"))]
    Swap,
    #[yaserde(rename = "SWPT")]
    #[cfg_attr(feature = "serde", serde(rename = "SWPT"))]
    Swpt,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    __Unknown__(String),
}

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

impl Validate for FinancialInstrumentContractType2Code {}



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

pub enum FinancialPartySectorType2Code {
    #[yaserde(rename = "AIFD")]
    #[cfg_attr(feature = "serde", serde(rename = "AIFD"))]
    Aifd,
    #[yaserde(rename = "CSDS")]
    #[cfg_attr(feature = "serde", serde(rename = "CSDS"))]
    Csds,
    #[yaserde(rename = "CCPS")]
    #[cfg_attr(feature = "serde", serde(rename = "CCPS"))]
    Ccps,
    #[yaserde(rename = "CDTI")]
    #[cfg_attr(feature = "serde", serde(rename = "CDTI"))]
    Cdti,
    #[yaserde(rename = "INUN")]
    #[cfg_attr(feature = "serde", serde(rename = "INUN"))]
    Inun,
    #[yaserde(rename = "ORPI")]
    #[cfg_attr(feature = "serde", serde(rename = "ORPI"))]
    Orpi,
    #[yaserde(rename = "INVF")]
    #[cfg_attr(feature = "serde", serde(rename = "INVF"))]
    Invf,
    #[yaserde(rename = "REIN")]
    #[cfg_attr(feature = "serde", serde(rename = "REIN"))]
    Rein,
    #[yaserde(rename = "UCIT")]
    #[cfg_attr(feature = "serde", serde(rename = "UCIT"))]
    Ucit,
    __Unknown__(String),
}

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

impl Validate for FinancialPartySectorType2Code {}



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

pub enum Frequency14Code {
    #[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 = "ADHO")]
    #[cfg_attr(feature = "serde", serde(rename = "ADHO"))]
    Adho,
    __Unknown__(String),
}

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

impl Validate for Frequency14Code {}



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

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

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

impl Validate for GenericIdentification1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.029.001.05")]
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 Isinoct2015Identifier (pub String);
crate::simple_type!(Isinoct2015Identifier);

impl Validate for Isinoct2015Identifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.029.001.05")]
pub struct IsinqueryCriteria1 {
    #[yaserde(rename = "Idr")]
    #[cfg_attr(feature = "serde", serde(rename = "Idr"))]
    pub idr: Vec<Isinoct2015Identifier>,

    #[yaserde(rename = "NotRptd")]
    #[cfg_attr(feature = "serde", serde(rename = "NotRptd"))]
    pub not_rptd: NotReported1Code,
}

impl Validate for IsinqueryCriteria1 {}


#[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.029.001.05")]
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 Micidentifier (pub String);
crate::simple_type!(Micidentifier);

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

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

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

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

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

impl Validate for Max25Text {
    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() > 25 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 25 \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 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 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 Max70Text (pub String);
crate::simple_type!(Max70Text);

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

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.029.001.05")]

pub enum ModificationLevel1Code {
    #[yaserde(rename = "PSTN")]
    #[cfg_attr(feature = "serde", serde(rename = "PSTN"))]
    Pstn,
    #[yaserde(rename = "TCTN")]
    #[cfg_attr(feature = "serde", serde(rename = "TCTN"))]
    Tctn,
    __Unknown__(String),
}

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

impl Validate for ModificationLevel1Code {}



#[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.029.001.05")]
pub struct NameAndAddress5 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max350Text,

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

impl Validate for NameAndAddress5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.029.001.05")]
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.029.001.05")]
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.029.001.05")]

pub enum NonFinancialPartySector1Code {
    #[yaserde(rename = "WTER")]
    #[cfg_attr(feature = "serde", serde(rename = "WTER"))]
    Wter,
    #[yaserde(rename = "MING")]
    #[cfg_attr(feature = "serde", serde(rename = "MING"))]
    Ming,
    #[yaserde(rename = "MAFG")]
    #[cfg_attr(feature = "serde", serde(rename = "MAFG"))]
    Mafg,
    #[yaserde(rename = "SPLY")]
    #[cfg_attr(feature = "serde", serde(rename = "SPLY"))]
    Sply,
    #[yaserde(rename = "CSTR")]
    #[cfg_attr(feature = "serde", serde(rename = "CSTR"))]
    Cstr,
    #[yaserde(rename = "AGRI")]
    #[cfg_attr(feature = "serde", serde(rename = "AGRI"))]
    Agri,
    #[yaserde(rename = "ACAF")]
    #[cfg_attr(feature = "serde", serde(rename = "ACAF"))]
    Acaf,
    #[yaserde(rename = "EDUC")]
    #[cfg_attr(feature = "serde", serde(rename = "EDUC"))]
    Educ,
    #[yaserde(rename = "AEAR")]
    #[cfg_attr(feature = "serde", serde(rename = "AEAR"))]
    Aear,
    #[yaserde(rename = "FINA")]
    #[cfg_attr(feature = "serde", serde(rename = "FINA"))]
    Fina,
    #[yaserde(rename = "HHSW")]
    #[cfg_attr(feature = "serde", serde(rename = "HHSW"))]
    Hhsw,
    #[yaserde(rename = "INCO")]
    #[cfg_attr(feature = "serde", serde(rename = "INCO"))]
    Inco,
    #[yaserde(rename = "WRRM")]
    #[cfg_attr(feature = "serde", serde(rename = "WRRM"))]
    Wrrm,
    #[yaserde(rename = "OTSA")]
    #[cfg_attr(feature = "serde", serde(rename = "OTSA"))]
    Otsa,
    #[yaserde(rename = "PSTA")]
    #[cfg_attr(feature = "serde", serde(rename = "PSTA"))]
    Psta,
    #[yaserde(rename = "PADS")]
    #[cfg_attr(feature = "serde", serde(rename = "PADS"))]
    Pads,
    #[yaserde(rename = "RESA")]
    #[cfg_attr(feature = "serde", serde(rename = "RESA"))]
    Resa,
    #[yaserde(rename = "TRAS")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAS"))]
    Tras,
    #[yaserde(rename = "ASSA")]
    #[cfg_attr(feature = "serde", serde(rename = "ASSA"))]
    Assa,
    #[yaserde(rename = "AHAE")]
    #[cfg_attr(feature = "serde", serde(rename = "AHAE"))]
    Ahae,
    #[yaserde(rename = "AEOB")]
    #[cfg_attr(feature = "serde", serde(rename = "AEOB"))]
    Aeob,
    __Unknown__(String),
}

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

impl Validate for NonFinancialPartySector1Code {}



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

pub enum NotAvailable1Code {
    #[yaserde(rename = "NTAV")]
    #[cfg_attr(feature = "serde", serde(rename = "NTAV"))]
    Ntav,
    __Unknown__(String),
}

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

impl Validate for NotAvailable1Code {}



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

pub enum NotReported1Code {
    #[yaserde(rename = "NORP")]
    #[cfg_attr(feature = "serde", serde(rename = "NORP"))]
    Norp,
    __Unknown__(String),
}

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

impl Validate for NotReported1Code {}



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

pub enum Operation3Code {
    #[yaserde(rename = "ANDD")]
    #[cfg_attr(feature = "serde", serde(rename = "ANDD"))]
    Andd,
    #[yaserde(rename = "ORRR")]
    #[cfg_attr(feature = "serde", serde(rename = "ORRR"))]
    Orrr,
    __Unknown__(String),
}

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

impl Validate for Operation3Code {}
#[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.029.001.05")]
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.029.001.05")]
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.029.001.05")]
pub struct PartyIdentification121Choice {
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_b_i_c: Option<AnyBICDec2014Identifier>,
    #[yaserde(rename = "LglNttyIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "LglNttyIdr"))]
    pub lgl_ntty_idr: Option<Leiidentifier>,
    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: Option<NameAndAddress5>,
    #[yaserde(rename = "PrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
    pub prtry_id: Option<GenericIdentification1>,
}

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

pub enum PartyNatureType1Code {
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "NFIN")]
    #[cfg_attr(feature = "serde", serde(rename = "NFIN"))]
    Nfin,
    #[yaserde(rename = "FIIN")]
    #[cfg_attr(feature = "serde", serde(rename = "FIIN"))]
    Fiin,
    #[yaserde(rename = "CCPS")]
    #[cfg_attr(feature = "serde", serde(rename = "CCPS"))]
    Ccps,
    __Unknown__(String),
}

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

impl Validate for PartyNatureType1Code {}



#[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.029.001.05")]
pub struct PostalAddress1 {
    #[yaserde(rename = "AdrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "AdrTp"))]
    pub adr_tp: AddressType2Code,

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

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

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

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

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

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

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

impl Validate for PostalAddress1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.029.001.05")]
pub struct ProductClassificationCriteria1 {
    #[yaserde(rename = "ClssfctnFinInstrm")]
    #[cfg_attr(feature = "serde", serde(rename = "ClssfctnFinInstrm"))]
    pub clssfctn_fin_instrm: Vec<Cfioct2015Identifier>,

    #[yaserde(rename = "UnqPdctIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "UnqPdctIdr"))]
    pub unq_pdct_idr: Vec<Max52Text>,
}

impl Validate for ProductClassificationCriteria1 {}


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

pub enum ProductType4Code {
    #[yaserde(rename = "CRDT")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDT"))]
    Crdt,
    #[yaserde(rename = "CURR")]
    #[cfg_attr(feature = "serde", serde(rename = "CURR"))]
    Curr,
    #[yaserde(rename = "EQUI")]
    #[cfg_attr(feature = "serde", serde(rename = "EQUI"))]
    Equi,
    #[yaserde(rename = "INTR")]
    #[cfg_attr(feature = "serde", serde(rename = "INTR"))]
    Intr,
    #[yaserde(rename = "COMM")]
    #[cfg_attr(feature = "serde", serde(rename = "COMM"))]
    Comm,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    __Unknown__(String),
}

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

impl Validate for ProductType4Code {}
#[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.029.001.05")]
pub struct SecuritiesTradeVenueCriteria1Choice {
    #[yaserde(rename = "MIC")]
    #[cfg_attr(feature = "serde", serde(rename = "MIC"))]
    pub mic: Vec<Micidentifier>,
    #[yaserde(rename = "AnyMIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyMIC"))]
    pub any_m_i_c: Option<AnyMIC1Code>,
}

impl Validate for SecuritiesTradeVenueCriteria1Choice {}
#[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.029.001.05")]
pub struct SecurityIdentification20Choice {
    #[yaserde(rename = "ISIN")]
    #[cfg_attr(feature = "serde", serde(rename = "ISIN"))]
    pub isin: Option<Isinoct2015Identifier>,
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Option<Max25Text>,
}

impl Validate for SecurityIdentification20Choice {}
#[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.029.001.05")]
pub struct SecurityIdentificationQuery4Choice {
    #[yaserde(rename = "ISIN")]
    #[cfg_attr(feature = "serde", serde(rename = "ISIN"))]
    pub isin: Vec<Isinoct2015Identifier>,
    #[yaserde(rename = "AltrntvInstrmId")]
    #[cfg_attr(feature = "serde", serde(rename = "AltrntvInstrmId"))]
    pub altrntv_instrm_id: Vec<Max52Text>,
    #[yaserde(rename = "NotAvlbl")]
    #[cfg_attr(feature = "serde", serde(rename = "NotAvlbl"))]
    pub not_avlbl: Option<NotAvailable1Code>,
    #[yaserde(rename = "UnqPdctIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "UnqPdctIdr"))]
    pub unq_pdct_idr: Vec<Max52Text>,
    #[yaserde(rename = "Indx")]
    #[cfg_attr(feature = "serde", serde(rename = "Indx"))]
    pub indx: Vec<SecurityIdentification20Choice>,
    #[yaserde(rename = "Bskt")]
    #[cfg_attr(feature = "serde", serde(rename = "Bskt"))]
    pub bskt: Vec<BasketQuery1>,
    #[yaserde(rename = "NotRptd")]
    #[cfg_attr(feature = "serde", serde(rename = "NotRptd"))]
    pub not_rptd: Option<NotReported1Code>,
}

impl Validate for SecurityIdentificationQuery4Choice {}




#[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.029.001.05")]
pub struct SecurityIdentificationQueryCriteria1 {
    #[yaserde(rename = "ISIN")]
    #[cfg_attr(feature = "serde", serde(rename = "ISIN"))]
    pub isin: Vec<Isinoct2015Identifier>,

    #[yaserde(rename = "AltrntvInstrmId")]
    #[cfg_attr(feature = "serde", serde(rename = "AltrntvInstrmId"))]
    pub altrntv_instrm_id: Vec<Max52Text>,
}

impl Validate for SecurityIdentificationQueryCriteria1 {}


#[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.029.001.05")]
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.029.001.05")]
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.029.001.05")]
pub struct TradeAdditionalQueryCriteria9 {
    #[yaserde(rename = "ActnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ActnTp"))]
    pub actn_tp: Vec<TransactionOperationType8Code>,

    #[yaserde(rename = "ExctnVn")]
    #[cfg_attr(feature = "serde", serde(rename = "ExctnVn"))]
    pub exctn_vn: SecuritiesTradeVenueCriteria1Choice,

    #[yaserde(rename = "NtrOfCtrPty")]
    #[cfg_attr(feature = "serde", serde(rename = "NtrOfCtrPty"))]
    pub ntr_of_ctr_pty: PartyNatureType1Code,

    #[yaserde(rename = "CorpSctr")]
    #[cfg_attr(feature = "serde", serde(rename = "CorpSctr"))]
    pub corp_sctr: CorporateSectorCriteria6,

    #[yaserde(rename = "AsstClss")]
    #[cfg_attr(feature = "serde", serde(rename = "AsstClss"))]
    pub asst_clss: Vec<ProductType4Code>,

    #[yaserde(rename = "PdctClssfctn")]
    #[cfg_attr(feature = "serde", serde(rename = "PdctClssfctn"))]
    pub pdct_clssfctn: ProductClassificationCriteria1,

    #[yaserde(rename = "Lvl")]
    #[cfg_attr(feature = "serde", serde(rename = "Lvl"))]
    pub lvl: ModificationLevel1Code,

    #[yaserde(rename = "EvtTp")]
    #[cfg_attr(feature = "serde", serde(rename = "EvtTp"))]
    pub evt_tp: Vec<DerivativeEventType3Code>,
}

impl Validate for TradeAdditionalQueryCriteria9 {}


#[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.029.001.05")]
pub struct TradeDateTimeQueryCriteria6 {
    #[yaserde(rename = "RptgDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "RptgDtTm"))]
    pub rptg_dt_tm: DateTimePeriod1,

    #[yaserde(rename = "ExctnDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "ExctnDtTm"))]
    pub exctn_dt_tm: DateTimePeriod1,

    #[yaserde(rename = "MtrtyDt")]
    #[cfg_attr(feature = "serde", serde(rename = "MtrtyDt"))]
    pub mtrty_dt: DateOrBlankQuery2Choice,

    #[yaserde(rename = "FctvDt")]
    #[cfg_attr(feature = "serde", serde(rename = "FctvDt"))]
    pub fctv_dt: DatePeriod1,

    #[yaserde(rename = "ValtnDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "ValtnDtTm"))]
    pub valtn_dt_tm: DateTimePeriod1,

    #[yaserde(rename = "XprtnDt")]
    #[cfg_attr(feature = "serde", serde(rename = "XprtnDt"))]
    pub xprtn_dt: DateOrBlankQuery2Choice,

    #[yaserde(rename = "EarlyTermntnDt")]
    #[cfg_attr(feature = "serde", serde(rename = "EarlyTermntnDt"))]
    pub early_termntn_dt: DatePeriod1,

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

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

impl Validate for TradeDateTimeQueryCriteria6 {}
#[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.029.001.05")]
pub struct TradePartyIdentificationQuery10Choice {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Vec<PartyIdentification248Choice>,
    #[yaserde(rename = "NotRptd")]
    #[cfg_attr(feature = "serde", serde(rename = "NotRptd"))]
    pub not_rptd: Option<NotReported1Code>,
}

impl Validate for TradePartyIdentificationQuery10Choice {}
#[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.029.001.05")]
pub struct TradePartyIdentificationQuery11Choice {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Vec<OrganisationIdentification15Choice>,
    #[yaserde(rename = "NotRptd")]
    #[cfg_attr(feature = "serde", serde(rename = "NotRptd"))]
    pub not_rptd: Option<NotReported1Code>,
}

impl Validate for TradePartyIdentificationQuery11Choice {}




#[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.029.001.05")]
pub struct TradePartyQueryCriteria7 {
    #[yaserde(rename = "Oprtr")]
    #[cfg_attr(feature = "serde", serde(rename = "Oprtr"))]
    pub oprtr: Operation3Code,

    #[yaserde(rename = "RptgCtrPty")]
    #[cfg_attr(feature = "serde", serde(rename = "RptgCtrPty"))]
    pub rptg_ctr_pty: TradePartyIdentificationQuery10Choice,

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

    #[yaserde(rename = "Bnfcry")]
    #[cfg_attr(feature = "serde", serde(rename = "Bnfcry"))]
    pub bnfcry: TradePartyIdentificationQuery10Choice,

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

    #[yaserde(rename = "SubmitgAgt")]
    #[cfg_attr(feature = "serde", serde(rename = "SubmitgAgt"))]
    pub submitg_agt: TradePartyIdentificationQuery11Choice,

    #[yaserde(rename = "Brkr")]
    #[cfg_attr(feature = "serde", serde(rename = "Brkr"))]
    pub brkr: TradePartyIdentificationQuery11Choice,

    #[yaserde(rename = "CCP")]
    #[cfg_attr(feature = "serde", serde(rename = "CCP"))]
    pub ccp: TradePartyIdentificationQuery11Choice,

    #[yaserde(rename = "ClrMmb")]
    #[cfg_attr(feature = "serde", serde(rename = "ClrMmb"))]
    pub clr_mmb: TradePartyIdentificationQuery10Choice,
}

impl Validate for TradePartyQueryCriteria7 {}


#[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.029.001.05")]
pub struct TradeQueryCriteria14 {
    #[yaserde(rename = "TradLifeCyclHstry")]
    #[cfg_attr(feature = "serde", serde(rename = "TradLifeCyclHstry"))]
    pub trad_life_cycl_hstry: TrueFalseIndicator,

    #[yaserde(rename = "MrgnLifeCyclHstry")]
    #[cfg_attr(feature = "serde", serde(rename = "MrgnLifeCyclHstry"))]
    pub mrgn_life_cycl_hstry: TrueFalseIndicator,

    #[yaserde(rename = "OutsdngTradInd")]
    #[cfg_attr(feature = "serde", serde(rename = "OutsdngTradInd"))]
    pub outsdng_trad_ind: TrueFalseIndicator,

    #[yaserde(rename = "TradPtyCrit")]
    #[cfg_attr(feature = "serde", serde(rename = "TradPtyCrit"))]
    pub trad_pty_crit: TradePartyQueryCriteria7,

    #[yaserde(rename = "FinInstrmCrit")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrmCrit"))]
    pub fin_instrm_crit: TradeSecurityIdentificationQueryCriteria3,

    #[yaserde(rename = "TmCrit")]
    #[cfg_attr(feature = "serde", serde(rename = "TmCrit"))]
    pub tm_crit: TradeDateTimeQueryCriteria6,

    #[yaserde(rename = "OthrCrit")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrCrit"))]
    pub othr_crit: TradeAdditionalQueryCriteria9,
}

impl Validate for TradeQueryCriteria14 {}


#[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.029.001.05")]
pub struct TradeQueryExecutionFrequency3 {
    #[yaserde(rename = "FrqcyTp")]
    #[cfg_attr(feature = "serde", serde(rename = "FrqcyTp"))]
    pub frqcy_tp: Frequency14Code,

    #[yaserde(rename = "DlvryDay")]
    #[cfg_attr(feature = "serde", serde(rename = "DlvryDay"))]
    pub dlvry_day: Vec<WeekDay3Code>,

    #[yaserde(rename = "DayOfMnth")]
    #[cfg_attr(feature = "serde", serde(rename = "DayOfMnth"))]
    pub day_of_mnth: Vec<DayOfMonthNumber>,
}

impl Validate for TradeQueryExecutionFrequency3 {}


#[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.029.001.05")]
pub struct TradeRecurrentQuery7 {
    #[yaserde(rename = "QryTp")]
    #[cfg_attr(feature = "serde", serde(rename = "QryTp"))]
    pub qry_tp: Max1000Text,

    #[yaserde(rename = "Frqcy")]
    #[cfg_attr(feature = "serde", serde(rename = "Frqcy"))]
    pub frqcy: Vec<TradeQueryExecutionFrequency3>,

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

impl Validate for TradeRecurrentQuery7 {}
#[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.029.001.05")]
pub struct TradeReportQuery18Choice {
    #[yaserde(rename = "AdHocQry")]
    #[cfg_attr(feature = "serde", serde(rename = "AdHocQry"))]
    pub ad_hoc_qry: Option<TradeQueryCriteria14>,
    #[yaserde(rename = "RcrntQry")]
    #[cfg_attr(feature = "serde", serde(rename = "RcrntQry"))]
    pub rcrnt_qry: Option<TradeRecurrentQuery7>,
}

impl Validate for TradeReportQuery18Choice {}




#[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.029.001.05")]
pub struct TradeSecurityIdentificationQueryCriteria3 {
    #[yaserde(rename = "Oprtr")]
    #[cfg_attr(feature = "serde", serde(rename = "Oprtr"))]
    pub oprtr: Operation3Code,

    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Vec<SecurityIdentificationQueryCriteria1>,

    #[yaserde(rename = "CtrctTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrctTp"))]
    pub ctrct_tp: Vec<FinancialInstrumentContractType2Code>,

    #[yaserde(rename = "ISIN")]
    #[cfg_attr(feature = "serde", serde(rename = "ISIN"))]
    pub isin: Vec<IsinqueryCriteria1>,

    #[yaserde(rename = "UnqPdctIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "UnqPdctIdr"))]
    pub unq_pdct_idr: Vec<UpiqueryCriteria1>,

    #[yaserde(rename = "UndrlygInstrmId")]
    #[cfg_attr(feature = "serde", serde(rename = "UndrlygInstrmId"))]
    pub undrlyg_instrm_id: Vec<SecurityIdentificationQuery4Choice>,
}

impl Validate for TradeSecurityIdentificationQueryCriteria3 {}


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

pub enum TransactionOperationType8Code {
    #[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,
    __Unknown__(String),
}

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

impl Validate for TransactionOperationType8Code {}



#[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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.029.001.05")]
pub struct UpiqueryCriteria1 {
    #[yaserde(rename = "Idr")]
    #[cfg_attr(feature = "serde", serde(rename = "Idr"))]
    pub idr: Vec<Max52Text>,

    #[yaserde(rename = "NotRptd")]
    #[cfg_attr(feature = "serde", serde(rename = "NotRptd"))]
    pub not_rptd: NotReported1Code,
}

impl Validate for UpiqueryCriteria1 {}


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

pub enum WeekDay3Code {
    #[yaserde(rename = "ALLD")]
    #[cfg_attr(feature = "serde", serde(rename = "ALLD"))]
    Alld,
    #[yaserde(rename = "XBHL")]
    #[cfg_attr(feature = "serde", serde(rename = "XBHL"))]
    Xbhl,
    #[yaserde(rename = "IBHL")]
    #[cfg_attr(feature = "serde", serde(rename = "IBHL"))]
    Ibhl,
    #[yaserde(rename = "FRID")]
    #[cfg_attr(feature = "serde", serde(rename = "FRID"))]
    Frid,
    #[yaserde(rename = "MOND")]
    #[cfg_attr(feature = "serde", serde(rename = "MOND"))]
    Mond,
    #[yaserde(rename = "SATD")]
    #[cfg_attr(feature = "serde", serde(rename = "SATD"))]
    Satd,
    #[yaserde(rename = "SUND")]
    #[cfg_attr(feature = "serde", serde(rename = "SUND"))]
    Sund,
    #[yaserde(rename = "THUD")]
    #[cfg_attr(feature = "serde", serde(rename = "THUD"))]
    Thud,
    #[yaserde(rename = "TUED")]
    #[cfg_attr(feature = "serde", serde(rename = "TUED"))]
    Tued,
    #[yaserde(rename = "WEDD")]
    #[cfg_attr(feature = "serde", serde(rename = "WEDD"))]
    Wedd,
    #[yaserde(rename = "WDAY")]
    #[cfg_attr(feature = "serde", serde(rename = "WDAY"))]
    Wday,
    #[yaserde(rename = "WEND")]
    #[cfg_attr(feature = "serde", serde(rename = "WEND"))]
    Wend,
    __Unknown__(String),
}

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

impl Validate for WeekDay3Code {}

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