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

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

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

impl Validate for ActiveCurrencyAnd13DecimalAmount {}


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

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

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

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

impl Validate for ActiveOrHistoricCurrencyAndAmount {}


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

impl Validate for ActiveOrHistoricCurrencyCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.016.001.02")]
pub struct AmountAndDirection53 {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: ActiveOrHistoricCurrencyAndAmount,

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

impl Validate for AmountAndDirection53 {}


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

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

impl Validate for AmountAndDirection61 {}


#[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.016.001.02")]
pub struct AssetClassAttributes1 {
    #[yaserde(rename = "Intrst")]
    #[cfg_attr(feature = "serde", serde(rename = "Intrst"))]
    pub intrst: DerivativeInterest2,

    #[yaserde(rename = "FX")]
    #[cfg_attr(feature = "serde", serde(rename = "FX"))]
    pub fx: DerivativeForeignExchange2,
}

impl Validate for AssetClassAttributes1 {}
#[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.016.001.02")]
pub struct AssetClassAttributes1Choice {
    #[yaserde(rename = "Intrst")]
    #[cfg_attr(feature = "serde", serde(rename = "Intrst"))]
    pub intrst: Option<DerivativeInterest2>,
    #[yaserde(rename = "FX")]
    #[cfg_attr(feature = "serde", serde(rename = "FX"))]
    pub fx: Option<DerivativeForeignExchange2>,
    #[yaserde(rename = "Both")]
    #[cfg_attr(feature = "serde", serde(rename = "Both"))]
    pub both: Option<AssetClassAttributes1>,
}

impl Validate for AssetClassAttributes1Choice {}




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

    #[yaserde(rename = "Indx")]
    #[cfg_attr(feature = "serde", serde(rename = "Indx"))]
    pub indx: Vec<FinancialInstrument98>,
}

impl Validate for BasketDescription4 {}


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

pub enum BenchmarkCurveName2Code {
    #[yaserde(rename = "WIBO")]
    #[cfg_attr(feature = "serde", serde(rename = "WIBO"))]
    Wibo,
    #[yaserde(rename = "TREA")]
    #[cfg_attr(feature = "serde", serde(rename = "TREA"))]
    Trea,
    #[yaserde(rename = "TIBO")]
    #[cfg_attr(feature = "serde", serde(rename = "TIBO"))]
    Tibo,
    #[yaserde(rename = "TLBO")]
    #[cfg_attr(feature = "serde", serde(rename = "TLBO"))]
    Tlbo,
    #[yaserde(rename = "SWAP")]
    #[cfg_attr(feature = "serde", serde(rename = "SWAP"))]
    Swap,
    #[yaserde(rename = "STBO")]
    #[cfg_attr(feature = "serde", serde(rename = "STBO"))]
    Stbo,
    #[yaserde(rename = "PRBO")]
    #[cfg_attr(feature = "serde", serde(rename = "PRBO"))]
    Prbo,
    #[yaserde(rename = "PFAN")]
    #[cfg_attr(feature = "serde", serde(rename = "PFAN"))]
    Pfan,
    #[yaserde(rename = "NIBO")]
    #[cfg_attr(feature = "serde", serde(rename = "NIBO"))]
    Nibo,
    #[yaserde(rename = "MAAA")]
    #[cfg_attr(feature = "serde", serde(rename = "MAAA"))]
    Maaa,
    #[yaserde(rename = "MOSP")]
    #[cfg_attr(feature = "serde", serde(rename = "MOSP"))]
    Mosp,
    #[yaserde(rename = "LIBO")]
    #[cfg_attr(feature = "serde", serde(rename = "LIBO"))]
    Libo,
    #[yaserde(rename = "LIBI")]
    #[cfg_attr(feature = "serde", serde(rename = "LIBI"))]
    Libi,
    #[yaserde(rename = "JIBA")]
    #[cfg_attr(feature = "serde", serde(rename = "JIBA"))]
    Jiba,
    #[yaserde(rename = "ISDA")]
    #[cfg_attr(feature = "serde", serde(rename = "ISDA"))]
    Isda,
    #[yaserde(rename = "GCFR")]
    #[cfg_attr(feature = "serde", serde(rename = "GCFR"))]
    Gcfr,
    #[yaserde(rename = "FUSW")]
    #[cfg_attr(feature = "serde", serde(rename = "FUSW"))]
    Fusw,
    #[yaserde(rename = "EUCH")]
    #[cfg_attr(feature = "serde", serde(rename = "EUCH"))]
    Euch,
    #[yaserde(rename = "EUUS")]
    #[cfg_attr(feature = "serde", serde(rename = "EUUS"))]
    Euus,
    #[yaserde(rename = "EURI")]
    #[cfg_attr(feature = "serde", serde(rename = "EURI"))]
    Euri,
    #[yaserde(rename = "EONS")]
    #[cfg_attr(feature = "serde", serde(rename = "EONS"))]
    Eons,
    #[yaserde(rename = "EONA")]
    #[cfg_attr(feature = "serde", serde(rename = "EONA"))]
    Eona,
    #[yaserde(rename = "CIBO")]
    #[cfg_attr(feature = "serde", serde(rename = "CIBO"))]
    Cibo,
    #[yaserde(rename = "CDOR")]
    #[cfg_attr(feature = "serde", serde(rename = "CDOR"))]
    Cdor,
    #[yaserde(rename = "BUBO")]
    #[cfg_attr(feature = "serde", serde(rename = "BUBO"))]
    Bubo,
    #[yaserde(rename = "BBSW")]
    #[cfg_attr(feature = "serde", serde(rename = "BBSW"))]
    Bbsw,
    __Unknown__(String),
}

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

impl Validate for BenchmarkCurveName2Code {}
#[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.016.001.02")]
pub struct BenchmarkCurveName5Choice {
    #[yaserde(rename = "Indx")]
    #[cfg_attr(feature = "serde", serde(rename = "Indx"))]
    pub indx: Option<BenchmarkCurveName2Code>,
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Option<Max25Text>,
}

impl Validate for BenchmarkCurveName5Choice {}




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

pub enum CancelledStatusReason15Code {
    #[yaserde(rename = "CANI")]
    #[cfg_attr(feature = "serde", serde(rename = "CANI"))]
    Cani,
    #[yaserde(rename = "CSUB")]
    #[cfg_attr(feature = "serde", serde(rename = "CSUB"))]
    Csub,
    __Unknown__(String),
}

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

impl Validate for CancelledStatusReason15Code {}



#[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.016.001.02")]
pub struct DebtInstrument4 {
    #[yaserde(rename = "MtrtyDt")]
    #[cfg_attr(feature = "serde", serde(rename = "MtrtyDt"))]
    pub mtrty_dt: Isodate,
}

impl Validate for DebtInstrument4 {}


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

impl Validate for DecimalNumber {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.016.001.02")]
pub struct DerivativeForeignExchange2 {
    #[yaserde(rename = "OthrNtnlCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrNtnlCcy"))]
    pub othr_ntnl_ccy: ActiveOrHistoricCurrencyCode,
}

impl Validate for DerivativeForeignExchange2 {}


#[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.016.001.02")]
pub struct DerivativeInstrument9 {
    #[yaserde(rename = "XpryDt")]
    #[cfg_attr(feature = "serde", serde(rename = "XpryDt"))]
    pub xpry_dt: Isodate,

    #[yaserde(rename = "PricMltplr")]
    #[cfg_attr(feature = "serde", serde(rename = "PricMltplr"))]
    pub pric_mltplr: NonNegativeDecimalNumber,

    #[yaserde(rename = "UndrlygInstrm")]
    #[cfg_attr(feature = "serde", serde(rename = "UndrlygInstrm"))]
    pub undrlyg_instrm: UnderlyingIdentification3Choice,

    #[yaserde(rename = "OptnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "OptnTp"))]
    pub optn_tp: OptionType2Code,

    #[yaserde(rename = "StrkPric")]
    #[cfg_attr(feature = "serde", serde(rename = "StrkPric"))]
    pub strk_pric: SecuritiesTransactionPrice4Choice,

    #[yaserde(rename = "OptnExrcStyle")]
    #[cfg_attr(feature = "serde", serde(rename = "OptnExrcStyle"))]
    pub optn_exrc_style: OptionStyle7Code,

    #[yaserde(rename = "DlvryTp")]
    #[cfg_attr(feature = "serde", serde(rename = "DlvryTp"))]
    pub dlvry_tp: PhysicalTransferType4Code,

    #[yaserde(rename = "AsstClssSpcfcAttrbts")]
    #[cfg_attr(feature = "serde", serde(rename = "AsstClssSpcfcAttrbts"))]
    pub asst_clss_spcfc_attrbts: AssetClassAttributes1Choice,
}

impl Validate for DerivativeInstrument9 {}


#[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.016.001.02")]
pub struct DerivativeInterest2 {
    #[yaserde(rename = "OthrNtnlCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrNtnlCcy"))]
    pub othr_ntnl_ccy: ActiveOrHistoricCurrencyCode,
}

impl Validate for DerivativeInterest2 {}


#[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.016.001.02")]
pub struct Document {
    #[yaserde(rename = "FinInstrmRptgTxRpt")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrmRptgTxRpt"))]
    pub fin_instrm_rptg_tx_rpt: FinancialInstrumentReportingTransactionReportV02,
}

impl Validate for 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.016.001.02")]
pub struct ExecutingParty1Choice {
    #[yaserde(rename = "Prsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Prsn"))]
    pub prsn: Option<PersonIdentification12>,
    #[yaserde(rename = "Algo")]
    #[cfg_attr(feature = "serde", serde(rename = "Algo"))]
    pub algo: Option<Max50Text>,
    #[yaserde(rename = "Clnt")]
    #[cfg_attr(feature = "serde", serde(rename = "Clnt"))]
    pub clnt: Option<NoReasonCode>,
}

impl Validate for ExecutingParty1Choice {}




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

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

impl Validate for ExternalPersonIdentification1Code {
    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.016.001.02")]
pub struct FinancialInstrument98 {
    #[yaserde(rename = "ISIN")]
    #[cfg_attr(feature = "serde", serde(rename = "ISIN"))]
    pub isin: Isin2021Identifier,

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

impl Validate for FinancialInstrument98 {}
#[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.016.001.02")]
pub struct FinancialInstrumentAttributes4Choice {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Option<Isin2021Identifier>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<SecurityInstrumentDescription19>,
}

impl Validate for FinancialInstrumentAttributes4Choice {}
#[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.016.001.02")]
pub struct FinancialInstrumentIdentification8Choice {
    #[yaserde(rename = "Sngl")]
    #[cfg_attr(feature = "serde", serde(rename = "Sngl"))]
    pub sngl: Option<FinancialInstrumentIdentification9Choice>,
    #[yaserde(rename = "Bskt")]
    #[cfg_attr(feature = "serde", serde(rename = "Bskt"))]
    pub bskt: Option<BasketDescription4>,
}

impl Validate for FinancialInstrumentIdentification8Choice {}
#[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.016.001.02")]
pub struct FinancialInstrumentIdentification9Choice {
    #[yaserde(rename = "ISIN")]
    #[cfg_attr(feature = "serde", serde(rename = "ISIN"))]
    pub isin: Option<Isin2021Identifier>,
    #[yaserde(rename = "Indx")]
    #[cfg_attr(feature = "serde", serde(rename = "Indx"))]
    pub indx: Option<FinancialInstrument98>,
}

impl Validate for FinancialInstrumentIdentification9Choice {}
#[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.016.001.02")]
pub struct FinancialInstrumentQuantity25Choice {
    #[yaserde(rename = "Unit")]
    #[cfg_attr(feature = "serde", serde(rename = "Unit"))]
    pub unit: Option<DecimalNumber>,
    #[yaserde(rename = "NmnlVal")]
    #[cfg_attr(feature = "serde", serde(rename = "NmnlVal"))]
    pub nmnl_val: Option<ActiveOrHistoricCurrencyAndAmount>,
    #[yaserde(rename = "MntryVal")]
    #[cfg_attr(feature = "serde", serde(rename = "MntryVal"))]
    pub mntry_val: Option<ActiveOrHistoricCurrencyAndAmount>,
}

impl Validate for FinancialInstrumentQuantity25Choice {}




#[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.016.001.02")]
pub struct FinancialInstrumentReportingTransactionReportV02 {
    #[yaserde(rename = "Tx")]
    #[cfg_attr(feature = "serde", serde(rename = "Tx"))]
    pub tx: Vec<ReportingTransactionType2Choice>,

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

impl Validate for FinancialInstrumentReportingTransactionReportV02 {}


#[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.016.001.02")]
pub struct FloatingInterestRate8 {
    #[yaserde(rename = "RefRate")]
    #[cfg_attr(feature = "serde", serde(rename = "RefRate"))]
    pub ref_rate: BenchmarkCurveName5Choice,

    #[yaserde(rename = "Term")]
    #[cfg_attr(feature = "serde", serde(rename = "Term"))]
    pub term: InterestRateContractTerm2,
}

impl Validate for FloatingInterestRate8 {}


#[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.016.001.02")]
pub struct GenericPersonIdentification1 {
    #[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: PersonIdentificationSchemeName1Choice,

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

impl Validate for GenericPersonIdentification1 {}


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

impl Validate for Isin2021Identifier {}
#[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 ImpliedCurrencyAndAmount (pub String);
crate::simple_type!(ImpliedCurrencyAndAmount);

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

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.016.001.02")]
pub struct InterestRateContractTerm2 {
    #[yaserde(rename = "Unit")]
    #[cfg_attr(feature = "serde", serde(rename = "Unit"))]
    pub unit: RateBasis1Code,

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

impl Validate for InterestRateContractTerm2 {}


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

pub enum InternalPartyRole1Code {
    #[yaserde(rename = "INTC")]
    #[cfg_attr(feature = "serde", serde(rename = "INTC"))]
    Intc,
    __Unknown__(String),
}

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

impl Validate for InternalPartyRole1Code {}
#[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.016.001.02")]
pub struct InvestmentParty1Choice {
    #[yaserde(rename = "Prsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Prsn"))]
    pub prsn: Option<PersonIdentification12>,
    #[yaserde(rename = "Algo")]
    #[cfg_attr(feature = "serde", serde(rename = "Algo"))]
    pub algo: Option<Max50Text>,
}

impl Validate for InvestmentParty1Choice {}




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

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

pub enum NoReasonCode {
    #[yaserde(rename = "NORE")]
    #[cfg_attr(feature = "serde", serde(rename = "NORE"))]
    Nore,
    __Unknown__(String),
}

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

impl Validate for NoReasonCode {}



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

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

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

pub enum OptionStyle7Code {
    #[yaserde(rename = "AMER")]
    #[cfg_attr(feature = "serde", serde(rename = "AMER"))]
    Amer,
    #[yaserde(rename = "ASIA")]
    #[cfg_attr(feature = "serde", serde(rename = "ASIA"))]
    Asia,
    #[yaserde(rename = "BERM")]
    #[cfg_attr(feature = "serde", serde(rename = "BERM"))]
    Berm,
    #[yaserde(rename = "EURO")]
    #[cfg_attr(feature = "serde", serde(rename = "EURO"))]
    Euro,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    __Unknown__(String),
}

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

impl Validate for OptionStyle7Code {}



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

pub enum OptionType2Code {
    #[yaserde(rename = "CALL")]
    #[cfg_attr(feature = "serde", serde(rename = "CALL"))]
    Call,
    #[yaserde(rename = "PUTO")]
    #[cfg_attr(feature = "serde", serde(rename = "PUTO"))]
    Puto,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    __Unknown__(String),
}

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

impl Validate for OptionType2Code {}



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

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

impl Validate for PartyIdentification76 {}


#[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.016.001.02")]
pub struct PartyIdentification79 {
    #[yaserde(rename = "AcctOwnr")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctOwnr"))]
    pub acct_ownr: Vec<PartyIdentification76>,

    #[yaserde(rename = "DcsnMakr")]
    #[cfg_attr(feature = "serde", serde(rename = "DcsnMakr"))]
    pub dcsn_makr: Vec<PersonOrOrganisation2Choice>,
}

impl Validate for PartyIdentification79 {}


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

impl Validate for PercentageRate {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.016.001.02")]
pub struct PersonIdentification10 {
    #[yaserde(rename = "FrstNm")]
    #[cfg_attr(feature = "serde", serde(rename = "FrstNm"))]
    pub frst_nm: Max140Text,

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

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

    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: GenericPersonIdentification1,
}

impl Validate for PersonIdentification10 {}


#[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.016.001.02")]
pub struct PersonIdentification12 {
    #[yaserde(rename = "CtryOfBrnch")]
    #[cfg_attr(feature = "serde", serde(rename = "CtryOfBrnch"))]
    pub ctry_of_brnch: CountryCode,

    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: GenericPersonIdentification1,
}

impl Validate for PersonIdentification12 {}
#[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.016.001.02")]
pub struct PersonIdentificationSchemeName1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ExternalPersonIdentification1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max35Text>,
}

impl Validate for PersonIdentificationSchemeName1Choice {}
#[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.016.001.02")]
pub struct PersonOrOrganisation1Choice {
    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Option<Leiidentifier>,
    #[yaserde(rename = "MIC")]
    #[cfg_attr(feature = "serde", serde(rename = "MIC"))]
    pub mic: Option<Micidentifier>,
    #[yaserde(rename = "Prsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Prsn"))]
    pub prsn: Option<PersonIdentification10>,
    #[yaserde(rename = "Intl")]
    #[cfg_attr(feature = "serde", serde(rename = "Intl"))]
    pub intl: Option<InternalPartyRole1Code>,
}

impl Validate for PersonOrOrganisation1Choice {}
#[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.016.001.02")]
pub struct PersonOrOrganisation2Choice {
    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Option<Leiidentifier>,
    #[yaserde(rename = "Prsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Prsn"))]
    pub prsn: Option<PersonIdentification10>,
}

impl Validate for PersonOrOrganisation2Choice {}




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

pub enum PhysicalTransferType4Code {
    #[yaserde(rename = "PHYS")]
    #[cfg_attr(feature = "serde", serde(rename = "PHYS"))]
    Phys,
    #[yaserde(rename = "OPTL")]
    #[cfg_attr(feature = "serde", serde(rename = "OPTL"))]
    Optl,
    #[yaserde(rename = "CASH")]
    #[cfg_attr(feature = "serde", serde(rename = "CASH"))]
    Cash,
    __Unknown__(String),
}

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

impl Validate for PhysicalTransferType4Code {}



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

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

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

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

impl Validate for PriceStatus1Code {}



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

pub enum RateBasis1Code {
    #[yaserde(rename = "DAYS")]
    #[cfg_attr(feature = "serde", serde(rename = "DAYS"))]
    Days,
    #[yaserde(rename = "MNTH")]
    #[cfg_attr(feature = "serde", serde(rename = "MNTH"))]
    Mnth,
    #[yaserde(rename = "WEEK")]
    #[cfg_attr(feature = "serde", serde(rename = "WEEK"))]
    Week,
    #[yaserde(rename = "YEAR")]
    #[cfg_attr(feature = "serde", serde(rename = "YEAR"))]
    Year,
    __Unknown__(String),
}

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

impl Validate for RateBasis1Code {}



#[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.016.001.02")]
pub struct RecordTechnicalData2 {
    #[yaserde(rename = "RctDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "RctDtTm"))]
    pub rct_dt_tm: IsodateTime,

    #[yaserde(rename = "CxlRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "CxlRsn"))]
    pub cxl_rsn: CancelledStatusReason15Code,
}

impl Validate for RecordTechnicalData2 {}


#[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.016.001.02")]
pub struct RecordTechnicalData5 {
    #[yaserde(rename = "RctDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "RctDtTm"))]
    pub rct_dt_tm: IsodateTime,

    #[yaserde(rename = "XchgRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "XchgRsn"))]
    pub xchg_rsn: Vec<ExternalAuthorityExchangeReason1Code>,
}

impl Validate for RecordTechnicalData5 {}


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

pub enum RegulatoryTradingCapacity1Code {
    #[yaserde(rename = "MTCH")]
    #[cfg_attr(feature = "serde", serde(rename = "MTCH"))]
    Mtch,
    #[yaserde(rename = "DEAL")]
    #[cfg_attr(feature = "serde", serde(rename = "DEAL"))]
    Deal,
    #[yaserde(rename = "AOTC")]
    #[cfg_attr(feature = "serde", serde(rename = "AOTC"))]
    Aotc,
    __Unknown__(String),
}

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

impl Validate for RegulatoryTradingCapacity1Code {}
#[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.016.001.02")]
pub struct ReportingTransactionType2Choice {
    #[yaserde(rename = "New")]
    #[cfg_attr(feature = "serde", serde(rename = "New"))]
    pub new: Option<SecuritiesTransactionReport6>,
    #[yaserde(rename = "Cxl")]
    #[cfg_attr(feature = "serde", serde(rename = "Cxl"))]
    pub cxl: Option<SecuritiesTransactionReport2>,
    #[yaserde(rename = "SplmtryData")]
    #[cfg_attr(feature = "serde", serde(rename = "SplmtryData"))]
    pub splmtry_data: Vec<SupplementaryData1>,
}

impl Validate for ReportingTransactionType2Choice {}




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

pub enum ReportingWaiverType1Code {
    #[yaserde(rename = "OILQ")]
    #[cfg_attr(feature = "serde", serde(rename = "OILQ"))]
    Oilq,
    #[yaserde(rename = "NLIQ")]
    #[cfg_attr(feature = "serde", serde(rename = "NLIQ"))]
    Nliq,
    #[yaserde(rename = "PRIC")]
    #[cfg_attr(feature = "serde", serde(rename = "PRIC"))]
    Pric,
    #[yaserde(rename = "ILQD")]
    #[cfg_attr(feature = "serde", serde(rename = "ILQD"))]
    Ilqd,
    #[yaserde(rename = "RFPT")]
    #[cfg_attr(feature = "serde", serde(rename = "RFPT"))]
    Rfpt,
    #[yaserde(rename = "SIZE")]
    #[cfg_attr(feature = "serde", serde(rename = "SIZE"))]
    Size,
    __Unknown__(String),
}

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

impl Validate for ReportingWaiverType1Code {}



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

pub enum ReportingWaiverType3Code {
    #[yaserde(rename = "BENC")]
    #[cfg_attr(feature = "serde", serde(rename = "BENC"))]
    Benc,
    #[yaserde(rename = "ACTX")]
    #[cfg_attr(feature = "serde", serde(rename = "ACTX"))]
    Actx,
    #[yaserde(rename = "ILQD")]
    #[cfg_attr(feature = "serde", serde(rename = "ILQD"))]
    Ilqd,
    #[yaserde(rename = "SIZE")]
    #[cfg_attr(feature = "serde", serde(rename = "SIZE"))]
    Size,
    #[yaserde(rename = "CANC")]
    #[cfg_attr(feature = "serde", serde(rename = "CANC"))]
    Canc,
    #[yaserde(rename = "AMND")]
    #[cfg_attr(feature = "serde", serde(rename = "AMND"))]
    Amnd,
    #[yaserde(rename = "SDIV")]
    #[cfg_attr(feature = "serde", serde(rename = "SDIV"))]
    Sdiv,
    #[yaserde(rename = "RPRI")]
    #[cfg_attr(feature = "serde", serde(rename = "RPRI"))]
    Rpri,
    #[yaserde(rename = "DUPL")]
    #[cfg_attr(feature = "serde", serde(rename = "DUPL"))]
    Dupl,
    #[yaserde(rename = "LRGS")]
    #[cfg_attr(feature = "serde", serde(rename = "LRGS"))]
    Lrgs,
    #[yaserde(rename = "TNCP")]
    #[cfg_attr(feature = "serde", serde(rename = "TNCP"))]
    Tncp,
    #[yaserde(rename = "TPAC")]
    #[cfg_attr(feature = "serde", serde(rename = "TPAC"))]
    Tpac,
    #[yaserde(rename = "XFPH")]
    #[cfg_attr(feature = "serde", serde(rename = "XFPH"))]
    Xfph,
    __Unknown__(String),
}

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

impl Validate for ReportingWaiverType3Code {}



#[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.016.001.02")]
pub struct SecuritiesTransaction1 {
    #[yaserde(rename = "TradDt")]
    #[cfg_attr(feature = "serde", serde(rename = "TradDt"))]
    pub trad_dt: IsodateTime,

    #[yaserde(rename = "TradgCpcty")]
    #[cfg_attr(feature = "serde", serde(rename = "TradgCpcty"))]
    pub tradg_cpcty: RegulatoryTradingCapacity1Code,

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

    #[yaserde(rename = "DerivNtnlChng")]
    #[cfg_attr(feature = "serde", serde(rename = "DerivNtnlChng"))]
    pub deriv_ntnl_chng: VariationType1Code,

    #[yaserde(rename = "Pric")]
    #[cfg_attr(feature = "serde", serde(rename = "Pric"))]
    pub pric: SecuritiesTransactionPrice4Choice,

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

    #[yaserde(rename = "TradVn")]
    #[cfg_attr(feature = "serde", serde(rename = "TradVn"))]
    pub trad_vn: Micidentifier,

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

    #[yaserde(rename = "UpFrntPmt")]
    #[cfg_attr(feature = "serde", serde(rename = "UpFrntPmt"))]
    pub up_frnt_pmt: AmountAndDirection53,

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

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

impl Validate for SecuritiesTransaction1 {}


#[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.016.001.02")]
pub struct SecuritiesTransactionIndicator2 {
    #[yaserde(rename = "WvrInd")]
    #[cfg_attr(feature = "serde", serde(rename = "WvrInd"))]
    pub wvr_ind: Vec<ReportingWaiverType1Code>,

    #[yaserde(rename = "ShrtSellgInd")]
    #[cfg_attr(feature = "serde", serde(rename = "ShrtSellgInd"))]
    pub shrt_sellg_ind: Side5Code,

    #[yaserde(rename = "OTCPstTradInd")]
    #[cfg_attr(feature = "serde", serde(rename = "OTCPstTradInd"))]
    pub otc_pst_trad_ind: Vec<ReportingWaiverType3Code>,

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

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

impl Validate for SecuritiesTransactionIndicator2 {}


#[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.016.001.02")]
pub struct SecuritiesTransactionPrice1 {
    #[yaserde(rename = "Pdg")]
    #[cfg_attr(feature = "serde", serde(rename = "Pdg"))]
    pub pdg: PriceStatus1Code,

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

impl Validate for SecuritiesTransactionPrice1 {}
#[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.016.001.02")]
pub struct SecuritiesTransactionPrice2Choice {
    #[yaserde(rename = "MntryVal")]
    #[cfg_attr(feature = "serde", serde(rename = "MntryVal"))]
    pub mntry_val: Option<AmountAndDirection61>,
    #[yaserde(rename = "Pctg")]
    #[cfg_attr(feature = "serde", serde(rename = "Pctg"))]
    pub pctg: Option<PercentageRate>,
    #[yaserde(rename = "Yld")]
    #[cfg_attr(feature = "serde", serde(rename = "Yld"))]
    pub yld: Option<PercentageRate>,
    #[yaserde(rename = "BsisPts")]
    #[cfg_attr(feature = "serde", serde(rename = "BsisPts"))]
    pub bsis_pts: Option<DecimalNumber>,
}

impl Validate for SecuritiesTransactionPrice2Choice {}
#[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.016.001.02")]
pub struct SecuritiesTransactionPrice4Choice {
    #[yaserde(rename = "Pric")]
    #[cfg_attr(feature = "serde", serde(rename = "Pric"))]
    pub pric: Option<SecuritiesTransactionPrice2Choice>,
    #[yaserde(rename = "NoPric")]
    #[cfg_attr(feature = "serde", serde(rename = "NoPric"))]
    pub no_pric: Option<SecuritiesTransactionPrice1>,
}

impl Validate for SecuritiesTransactionPrice4Choice {}




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

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

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

    #[yaserde(rename = "TechAttrbts")]
    #[cfg_attr(feature = "serde", serde(rename = "TechAttrbts"))]
    pub tech_attrbts: RecordTechnicalData2,

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

impl Validate for SecuritiesTransactionReport2 {}


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

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

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

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

    #[yaserde(rename = "Buyr")]
    #[cfg_attr(feature = "serde", serde(rename = "Buyr"))]
    pub buyr: PartyIdentification79,

    #[yaserde(rename = "Sellr")]
    #[cfg_attr(feature = "serde", serde(rename = "Sellr"))]
    pub sellr: PartyIdentification79,

    #[yaserde(rename = "OrdrTrnsmssn")]
    #[cfg_attr(feature = "serde", serde(rename = "OrdrTrnsmssn"))]
    pub ordr_trnsmssn: SecuritiesTransactionTransmission2,

    #[yaserde(rename = "Tx")]
    #[cfg_attr(feature = "serde", serde(rename = "Tx"))]
    pub tx: SecuritiesTransaction1,

    #[yaserde(rename = "FinInstrm")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrm"))]
    pub fin_instrm: FinancialInstrumentAttributes4Choice,

    #[yaserde(rename = "InvstmtDcsnPrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "InvstmtDcsnPrsn"))]
    pub invstmt_dcsn_prsn: InvestmentParty1Choice,

    #[yaserde(rename = "ExctgPrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "ExctgPrsn"))]
    pub exctg_prsn: ExecutingParty1Choice,

    #[yaserde(rename = "AddtlAttrbts")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlAttrbts"))]
    pub addtl_attrbts: SecuritiesTransactionIndicator2,

    #[yaserde(rename = "TechAttrbts")]
    #[cfg_attr(feature = "serde", serde(rename = "TechAttrbts"))]
    pub tech_attrbts: RecordTechnicalData5,

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

impl Validate for SecuritiesTransactionReport6 {}


#[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.016.001.02")]
pub struct SecuritiesTransactionTransmission2 {
    #[yaserde(rename = "TrnsmssnInd")]
    #[cfg_attr(feature = "serde", serde(rename = "TrnsmssnInd"))]
    pub trnsmssn_ind: TrueFalseIndicator,

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

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

impl Validate for SecuritiesTransactionTransmission2 {}


#[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.016.001.02")]
pub struct SecurityInstrumentDescription19 {
    #[yaserde(rename = "FinInstrmGnlAttrbts")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrmGnlAttrbts"))]
    pub fin_instrm_gnl_attrbts: SecurityInstrumentDescription20,

    #[yaserde(rename = "DebtInstrmAttrbts")]
    #[cfg_attr(feature = "serde", serde(rename = "DebtInstrmAttrbts"))]
    pub debt_instrm_attrbts: DebtInstrument4,

    #[yaserde(rename = "DerivInstrmAttrbts")]
    #[cfg_attr(feature = "serde", serde(rename = "DerivInstrmAttrbts"))]
    pub deriv_instrm_attrbts: DerivativeInstrument9,
}

impl Validate for SecurityInstrumentDescription19 {}


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

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

    #[yaserde(rename = "ClssfctnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ClssfctnTp"))]
    pub clssfctn_tp: Cfioct2015Identifier,

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

impl Validate for SecurityInstrumentDescription20 {}


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

pub enum Side5Code {
    #[yaserde(rename = "SESH")]
    #[cfg_attr(feature = "serde", serde(rename = "SESH"))]
    Sesh,
    #[yaserde(rename = "SELL")]
    #[cfg_attr(feature = "serde", serde(rename = "SELL"))]
    Sell,
    #[yaserde(rename = "SSEX")]
    #[cfg_attr(feature = "serde", serde(rename = "SSEX"))]
    Ssex,
    #[yaserde(rename = "UNDI")]
    #[cfg_attr(feature = "serde", serde(rename = "UNDI"))]
    Undi,
    __Unknown__(String),
}

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

impl Validate for Side5Code {}



#[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.016.001.02")]
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.016.001.02")]
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.016.001.02")]
pub struct SwapLegIdentification3 {
    #[yaserde(rename = "SwpIn")]
    #[cfg_attr(feature = "serde", serde(rename = "SwpIn"))]
    pub swp_in: FinancialInstrumentIdentification8Choice,

    #[yaserde(rename = "SwpOut")]
    #[cfg_attr(feature = "serde", serde(rename = "SwpOut"))]
    pub swp_out: FinancialInstrumentIdentification8Choice,
}

impl Validate for SwapLegIdentification3 {}


#[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.016.001.02")]
pub struct UnderlyingIdentification3Choice {
    #[yaserde(rename = "Swp")]
    #[cfg_attr(feature = "serde", serde(rename = "Swp"))]
    pub swp: Option<SwapLegIdentification3>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<FinancialInstrumentIdentification8Choice>,
}

impl Validate for UnderlyingIdentification3Choice {}




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

pub enum VariationType1Code {
    #[yaserde(rename = "DECR")]
    #[cfg_attr(feature = "serde", serde(rename = "DECR"))]
    Decr,
    #[yaserde(rename = "INCR")]
    #[cfg_attr(feature = "serde", serde(rename = "INCR"))]
    Incr,
    __Unknown__(String),
}

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

impl Validate for VariationType1Code {}

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