rust_iso20022 0.1.1

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

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

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

impl Validate for ActiveOrHistoricCurrencyAnd20DecimalAmount {}


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

impl Validate for AgreementType1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct AgreementType2Choice {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: Option<ExternalAgreementType1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max50Text>,
}

impl Validate for AgreementType2Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.080.001.02")]
pub struct AgriculturalCommodityDairy1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType1Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType20Code,
}

impl Validate for AgriculturalCommodityDairy1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct AgriculturalCommodityForestry1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType1Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType21Code,
}

impl Validate for AgriculturalCommodityForestry1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct AgriculturalCommodityGrain2 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType1Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType5Code,

    #[yaserde(rename = "AddtlSubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlSubPdct"))]
    pub addtl_sub_pdct: AssetClassDetailedSubProductType30Code,
}

impl Validate for AgriculturalCommodityGrain2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct AgriculturalCommodityLiveStock1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType1Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType22Code,
}

impl Validate for AgriculturalCommodityLiveStock1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct AgriculturalCommodityOilSeed1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType1Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType1Code,

    #[yaserde(rename = "AddtlSubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlSubPdct"))]
    pub addtl_sub_pdct: AssetClassDetailedSubProductType1Code,
}

impl Validate for AgriculturalCommodityOilSeed1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct AgriculturalCommodityOliveOil2 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType1Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType3Code,

    #[yaserde(rename = "AddtlSubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlSubPdct"))]
    pub addtl_sub_pdct: AssetClassDetailedSubProductType29Code,
}

impl Validate for AgriculturalCommodityOliveOil2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct AgriculturalCommodityOther1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType1Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType49Code,
}

impl Validate for AgriculturalCommodityOther1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct AgriculturalCommodityPotato1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType1Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType45Code,
}

impl Validate for AgriculturalCommodityPotato1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct AgriculturalCommoditySeafood1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType1Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType23Code,
}

impl Validate for AgriculturalCommoditySeafood1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct AgriculturalCommoditySoft1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType1Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType2Code,

    #[yaserde(rename = "AddtlSubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlSubPdct"))]
    pub addtl_sub_pdct: AssetClassDetailedSubProductType2Code,
}

impl Validate for AgriculturalCommoditySoft1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct AmountAndDirection107 {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: ActiveOrHistoricCurrencyAnd20DecimalAmount,

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

impl Validate for AmountAndDirection107 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.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)]
pub struct AnyBICDec2014Identifier (pub String);
crate::simple_type!(AnyBICDec2014Identifier);

impl Validate for AnyBICDec2014Identifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.080.001.02")]
pub struct AssetClassCommodity5Choice {
    #[yaserde(rename = "Agrcltrl")]
    #[cfg_attr(feature = "serde", serde(rename = "Agrcltrl"))]
    pub agrcltrl: Option<AssetClassCommodityAgricultural5Choice>,
    #[yaserde(rename = "Nrgy")]
    #[cfg_attr(feature = "serde", serde(rename = "Nrgy"))]
    pub nrgy: Option<AssetClassCommodityEnergy2Choice>,
    #[yaserde(rename = "Envttl")]
    #[cfg_attr(feature = "serde", serde(rename = "Envttl"))]
    pub envttl: Option<AssetClassCommodityEnvironmental2Choice>,
    #[yaserde(rename = "Frtlzr")]
    #[cfg_attr(feature = "serde", serde(rename = "Frtlzr"))]
    pub frtlzr: Option<AssetClassCommodityFertilizer3Choice>,
    #[yaserde(rename = "Frght")]
    #[cfg_attr(feature = "serde", serde(rename = "Frght"))]
    pub frght: Option<AssetClassCommodityFreight3Choice>,
    #[yaserde(rename = "IndstrlPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "IndstrlPdct"))]
    pub indstrl_pdct: Option<AssetClassCommodityIndustrialProduct1Choice>,
    #[yaserde(rename = "Metl")]
    #[cfg_attr(feature = "serde", serde(rename = "Metl"))]
    pub metl: Option<AssetClassCommodityMetal1Choice>,
    #[yaserde(rename = "OthrC10")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrC10"))]
    pub othr_c10: Option<AssetClassCommodityOtherC102Choice>,
    #[yaserde(rename = "Ppr")]
    #[cfg_attr(feature = "serde", serde(rename = "Ppr"))]
    pub ppr: Option<AssetClassCommodityPaper3Choice>,
    #[yaserde(rename = "Plprpln")]
    #[cfg_attr(feature = "serde", serde(rename = "Plprpln"))]
    pub plprpln: Option<AssetClassCommodityPolypropylene3Choice>,
    #[yaserde(rename = "Infltn")]
    #[cfg_attr(feature = "serde", serde(rename = "Infltn"))]
    pub infltn: Option<AssetClassCommodityInflation1>,
    #[yaserde(rename = "MultiCmmdtyExtc")]
    #[cfg_attr(feature = "serde", serde(rename = "MultiCmmdtyExtc"))]
    pub multi_cmmdty_extc: Option<AssetClassCommodityMultiCommodityExotic1>,
    #[yaserde(rename = "OffclEcnmcSttstcs")]
    #[cfg_attr(feature = "serde", serde(rename = "OffclEcnmcSttstcs"))]
    pub offcl_ecnmc_sttstcs: Option<AssetClassCommodityOfficialEconomicStatistics1>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<AssetClassCommodityOther1>,
}

impl Validate for AssetClassCommodity5Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct AssetClassCommodityAgricultural5Choice {
    #[yaserde(rename = "GrnOilSeed")]
    #[cfg_attr(feature = "serde", serde(rename = "GrnOilSeed"))]
    pub grn_oil_seed: Option<AgriculturalCommodityOilSeed1>,
    #[yaserde(rename = "Soft")]
    #[cfg_attr(feature = "serde", serde(rename = "Soft"))]
    pub soft: Option<AgriculturalCommoditySoft1>,
    #[yaserde(rename = "Ptt")]
    #[cfg_attr(feature = "serde", serde(rename = "Ptt"))]
    pub ptt: Option<AgriculturalCommodityPotato1>,
    #[yaserde(rename = "OlvOil")]
    #[cfg_attr(feature = "serde", serde(rename = "OlvOil"))]
    pub olv_oil: Option<AgriculturalCommodityOliveOil2>,
    #[yaserde(rename = "Dairy")]
    #[cfg_attr(feature = "serde", serde(rename = "Dairy"))]
    pub dairy: Option<AgriculturalCommodityDairy1>,
    #[yaserde(rename = "Frstry")]
    #[cfg_attr(feature = "serde", serde(rename = "Frstry"))]
    pub frstry: Option<AgriculturalCommodityForestry1>,
    #[yaserde(rename = "Sfd")]
    #[cfg_attr(feature = "serde", serde(rename = "Sfd"))]
    pub sfd: Option<AgriculturalCommoditySeafood1>,
    #[yaserde(rename = "LiveStock")]
    #[cfg_attr(feature = "serde", serde(rename = "LiveStock"))]
    pub live_stock: Option<AgriculturalCommodityLiveStock1>,
    #[yaserde(rename = "Grn")]
    #[cfg_attr(feature = "serde", serde(rename = "Grn"))]
    pub grn: Option<AgriculturalCommodityGrain2>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<AgriculturalCommodityOther1>,
}

impl Validate for AssetClassCommodityAgricultural5Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct AssetClassCommodityEnergy2Choice {
    #[yaserde(rename = "Elctrcty")]
    #[cfg_attr(feature = "serde", serde(rename = "Elctrcty"))]
    pub elctrcty: Option<EnergyCommodityElectricity1>,
    #[yaserde(rename = "NtrlGas")]
    #[cfg_attr(feature = "serde", serde(rename = "NtrlGas"))]
    pub ntrl_gas: Option<EnergyCommodityNaturalGas2>,
    #[yaserde(rename = "Oil")]
    #[cfg_attr(feature = "serde", serde(rename = "Oil"))]
    pub oil: Option<EnergyCommodityOil2>,
    #[yaserde(rename = "Coal")]
    #[cfg_attr(feature = "serde", serde(rename = "Coal"))]
    pub coal: Option<EnergyCommodityCoal1>,
    #[yaserde(rename = "IntrNrgy")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrNrgy"))]
    pub intr_nrgy: Option<EnergyCommodityInterEnergy1>,
    #[yaserde(rename = "RnwblNrgy")]
    #[cfg_attr(feature = "serde", serde(rename = "RnwblNrgy"))]
    pub rnwbl_nrgy: Option<EnergyCommodityRenewableEnergy1>,
    #[yaserde(rename = "LghtEnd")]
    #[cfg_attr(feature = "serde", serde(rename = "LghtEnd"))]
    pub lght_end: Option<EnergyCommodityLightEnd1>,
    #[yaserde(rename = "Dstllts")]
    #[cfg_attr(feature = "serde", serde(rename = "Dstllts"))]
    pub dstllts: Option<EnergyCommodityDistillates1>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<EnergyCommodityOther1>,
}

impl Validate for AssetClassCommodityEnergy2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct AssetClassCommodityEnvironmental2Choice {
    #[yaserde(rename = "Emssns")]
    #[cfg_attr(feature = "serde", serde(rename = "Emssns"))]
    pub emssns: Option<EnvironmentalCommodityEmission2>,
    #[yaserde(rename = "Wthr")]
    #[cfg_attr(feature = "serde", serde(rename = "Wthr"))]
    pub wthr: Option<EnvironmentalCommodityWeather1>,
    #[yaserde(rename = "CrbnRltd")]
    #[cfg_attr(feature = "serde", serde(rename = "CrbnRltd"))]
    pub crbn_rltd: Option<EnvironmentalCommodityCarbonRelated1>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<EnvironmentCommodityOther1>,
}

impl Validate for AssetClassCommodityEnvironmental2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct AssetClassCommodityFertilizer3Choice {
    #[yaserde(rename = "Ammn")]
    #[cfg_attr(feature = "serde", serde(rename = "Ammn"))]
    pub ammn: Option<FertilizerCommodityAmmonia1>,
    #[yaserde(rename = "DmmnmPhspht")]
    #[cfg_attr(feature = "serde", serde(rename = "DmmnmPhspht"))]
    pub dmmnm_phspht: Option<FertilizerCommodityDiammoniumPhosphate1>,
    #[yaserde(rename = "Ptsh")]
    #[cfg_attr(feature = "serde", serde(rename = "Ptsh"))]
    pub ptsh: Option<FertilizerCommodityPotash1>,
    #[yaserde(rename = "Slphr")]
    #[cfg_attr(feature = "serde", serde(rename = "Slphr"))]
    pub slphr: Option<FertilizerCommoditySulphur1>,
    #[yaserde(rename = "Urea")]
    #[cfg_attr(feature = "serde", serde(rename = "Urea"))]
    pub urea: Option<FertilizerCommodityUrea1>,
    #[yaserde(rename = "UreaAndAmmnmNtrt")]
    #[cfg_attr(feature = "serde", serde(rename = "UreaAndAmmnmNtrt"))]
    pub urea_and_ammnm_ntrt: Option<FertilizerCommodityUreaAndAmmoniumNitrate1>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<FertilizerCommodityOther1>,
}

impl Validate for AssetClassCommodityFertilizer3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct AssetClassCommodityFreight3Choice {
    #[yaserde(rename = "Dry")]
    #[cfg_attr(feature = "serde", serde(rename = "Dry"))]
    pub dry: Option<FreightCommodityDry2>,
    #[yaserde(rename = "Wet")]
    #[cfg_attr(feature = "serde", serde(rename = "Wet"))]
    pub wet: Option<FreightCommodityWet2>,
    #[yaserde(rename = "CntnrShip")]
    #[cfg_attr(feature = "serde", serde(rename = "CntnrShip"))]
    pub cntnr_ship: Option<FreightCommodityContainerShip1>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<FreightCommodityOther1>,
}

impl Validate for AssetClassCommodityFreight3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct AssetClassCommodityIndustrialProduct1Choice {
    #[yaserde(rename = "Cnstrctn")]
    #[cfg_attr(feature = "serde", serde(rename = "Cnstrctn"))]
    pub cnstrctn: Option<IndustrialProductCommodityConstruction1>,
    #[yaserde(rename = "Manfctg")]
    #[cfg_attr(feature = "serde", serde(rename = "Manfctg"))]
    pub manfctg: Option<IndustrialProductCommodityManufacturing1>,
}

impl Validate for AssetClassCommodityIndustrialProduct1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct AssetClassCommodityInflation1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType12Code,
}

impl Validate for AssetClassCommodityInflation1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct AssetClassCommodityMetal1Choice {
    #[yaserde(rename = "NonPrcs")]
    #[cfg_attr(feature = "serde", serde(rename = "NonPrcs"))]
    pub non_prcs: Option<MetalCommodityNonPrecious1>,
    #[yaserde(rename = "Prcs")]
    #[cfg_attr(feature = "serde", serde(rename = "Prcs"))]
    pub prcs: Option<MetalCommodityPrecious1>,
}

impl Validate for AssetClassCommodityMetal1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct AssetClassCommodityMultiCommodityExotic1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType13Code,
}

impl Validate for AssetClassCommodityMultiCommodityExotic1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct AssetClassCommodityOfficialEconomicStatistics1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType14Code,
}

impl Validate for AssetClassCommodityOfficialEconomicStatistics1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct AssetClassCommodityOther1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType15Code,
}

impl Validate for AssetClassCommodityOther1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct AssetClassCommodityOtherC102Choice {
    #[yaserde(rename = "Dlvrbl")]
    #[cfg_attr(feature = "serde", serde(rename = "Dlvrbl"))]
    pub dlvrbl: Option<OtherC10CommodityDeliverable2>,
    #[yaserde(rename = "NonDlvrbl")]
    #[cfg_attr(feature = "serde", serde(rename = "NonDlvrbl"))]
    pub non_dlvrbl: Option<OtherC10CommodityNonDeliverable2>,
}

impl Validate for AssetClassCommodityOtherC102Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct AssetClassCommodityPaper3Choice {
    #[yaserde(rename = "CntnrBrd")]
    #[cfg_attr(feature = "serde", serde(rename = "CntnrBrd"))]
    pub cntnr_brd: Option<PaperCommodityContainerBoard1>,
    #[yaserde(rename = "Nwsprnt")]
    #[cfg_attr(feature = "serde", serde(rename = "Nwsprnt"))]
    pub nwsprnt: Option<PaperCommodityNewsprint1>,
    #[yaserde(rename = "Pulp")]
    #[cfg_attr(feature = "serde", serde(rename = "Pulp"))]
    pub pulp: Option<PaperCommodityPulp1>,
    #[yaserde(rename = "RcvrdPpr")]
    #[cfg_attr(feature = "serde", serde(rename = "RcvrdPpr"))]
    pub rcvrd_ppr: Option<PaperCommodityRecoveredPaper1>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<PaperCommodityRecoveredPaper2>,
}

impl Validate for AssetClassCommodityPaper3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct AssetClassCommodityPolypropylene3Choice {
    #[yaserde(rename = "Plstc")]
    #[cfg_attr(feature = "serde", serde(rename = "Plstc"))]
    pub plstc: Option<PolypropyleneCommodityPlastic1>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<PolypropyleneCommodityOther1>,
}

impl Validate for AssetClassCommodityPolypropylene3Choice {}




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

pub enum AssetClassDetailedSubProductType10Code {
    #[yaserde(rename = "ALUM")]
    #[cfg_attr(feature = "serde", serde(rename = "ALUM"))]
    Alum,
    #[yaserde(rename = "ALUA")]
    #[cfg_attr(feature = "serde", serde(rename = "ALUA"))]
    Alua,
    #[yaserde(rename = "CBLT")]
    #[cfg_attr(feature = "serde", serde(rename = "CBLT"))]
    Cblt,
    #[yaserde(rename = "COPR")]
    #[cfg_attr(feature = "serde", serde(rename = "COPR"))]
    Copr,
    #[yaserde(rename = "IRON")]
    #[cfg_attr(feature = "serde", serde(rename = "IRON"))]
    Iron,
    #[yaserde(rename = "MOLY")]
    #[cfg_attr(feature = "serde", serde(rename = "MOLY"))]
    Moly,
    #[yaserde(rename = "NASC")]
    #[cfg_attr(feature = "serde", serde(rename = "NASC"))]
    Nasc,
    #[yaserde(rename = "NICK")]
    #[cfg_attr(feature = "serde", serde(rename = "NICK"))]
    Nick,
    #[yaserde(rename = "STEL")]
    #[cfg_attr(feature = "serde", serde(rename = "STEL"))]
    Stel,
    #[yaserde(rename = "TINN")]
    #[cfg_attr(feature = "serde", serde(rename = "TINN"))]
    Tinn,
    #[yaserde(rename = "ZINC")]
    #[cfg_attr(feature = "serde", serde(rename = "ZINC"))]
    Zinc,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "LEAD")]
    #[cfg_attr(feature = "serde", serde(rename = "LEAD"))]
    Lead,
    __Unknown__(String),
}

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

impl Validate for AssetClassDetailedSubProductType10Code {}



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

pub enum AssetClassDetailedSubProductType11Code {
    #[yaserde(rename = "GOLD")]
    #[cfg_attr(feature = "serde", serde(rename = "GOLD"))]
    Gold,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "PLDM")]
    #[cfg_attr(feature = "serde", serde(rename = "PLDM"))]
    Pldm,
    #[yaserde(rename = "PTNM")]
    #[cfg_attr(feature = "serde", serde(rename = "PTNM"))]
    Ptnm,
    #[yaserde(rename = "SLVR")]
    #[cfg_attr(feature = "serde", serde(rename = "SLVR"))]
    Slvr,
    __Unknown__(String),
}

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

impl Validate for AssetClassDetailedSubProductType11Code {}



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

pub enum AssetClassDetailedSubProductType1Code {
    #[yaserde(rename = "FWHT")]
    #[cfg_attr(feature = "serde", serde(rename = "FWHT"))]
    Fwht,
    #[yaserde(rename = "SOYB")]
    #[cfg_attr(feature = "serde", serde(rename = "SOYB"))]
    Soyb,
    #[yaserde(rename = "RPSD")]
    #[cfg_attr(feature = "serde", serde(rename = "RPSD"))]
    Rpsd,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "CORN")]
    #[cfg_attr(feature = "serde", serde(rename = "CORN"))]
    Corn,
    #[yaserde(rename = "RICE")]
    #[cfg_attr(feature = "serde", serde(rename = "RICE"))]
    Rice,
    __Unknown__(String),
}

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

impl Validate for AssetClassDetailedSubProductType1Code {}



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

pub enum AssetClassDetailedSubProductType29Code {
    #[yaserde(rename = "LAMP")]
    #[cfg_attr(feature = "serde", serde(rename = "LAMP"))]
    Lamp,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    __Unknown__(String),
}

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

impl Validate for AssetClassDetailedSubProductType29Code {}



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

pub enum AssetClassDetailedSubProductType2Code {
    #[yaserde(rename = "ROBU")]
    #[cfg_attr(feature = "serde", serde(rename = "ROBU"))]
    Robu,
    #[yaserde(rename = "CCOA")]
    #[cfg_attr(feature = "serde", serde(rename = "CCOA"))]
    Ccoa,
    #[yaserde(rename = "BRWN")]
    #[cfg_attr(feature = "serde", serde(rename = "BRWN"))]
    Brwn,
    #[yaserde(rename = "WHSG")]
    #[cfg_attr(feature = "serde", serde(rename = "WHSG"))]
    Whsg,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    __Unknown__(String),
}

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

impl Validate for AssetClassDetailedSubProductType2Code {}



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

pub enum AssetClassDetailedSubProductType30Code {
    #[yaserde(rename = "MWHT")]
    #[cfg_attr(feature = "serde", serde(rename = "MWHT"))]
    Mwht,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    __Unknown__(String),
}

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

impl Validate for AssetClassDetailedSubProductType30Code {}



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

pub enum AssetClassDetailedSubProductType31Code {
    #[yaserde(rename = "GASP")]
    #[cfg_attr(feature = "serde", serde(rename = "GASP"))]
    Gasp,
    #[yaserde(rename = "LNGG")]
    #[cfg_attr(feature = "serde", serde(rename = "LNGG"))]
    Lngg,
    #[yaserde(rename = "NCGG")]
    #[cfg_attr(feature = "serde", serde(rename = "NCGG"))]
    Ncgg,
    #[yaserde(rename = "TTFG")]
    #[cfg_attr(feature = "serde", serde(rename = "TTFG"))]
    Ttfg,
    #[yaserde(rename = "NBPG")]
    #[cfg_attr(feature = "serde", serde(rename = "NBPG"))]
    Nbpg,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    __Unknown__(String),
}

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

impl Validate for AssetClassDetailedSubProductType31Code {}



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

pub enum AssetClassDetailedSubProductType32Code {
    #[yaserde(rename = "BAKK")]
    #[cfg_attr(feature = "serde", serde(rename = "BAKK"))]
    Bakk,
    #[yaserde(rename = "BDSL")]
    #[cfg_attr(feature = "serde", serde(rename = "BDSL"))]
    Bdsl,
    #[yaserde(rename = "BRNT")]
    #[cfg_attr(feature = "serde", serde(rename = "BRNT"))]
    Brnt,
    #[yaserde(rename = "BRNX")]
    #[cfg_attr(feature = "serde", serde(rename = "BRNX"))]
    Brnx,
    #[yaserde(rename = "CNDA")]
    #[cfg_attr(feature = "serde", serde(rename = "CNDA"))]
    Cnda,
    #[yaserde(rename = "COND")]
    #[cfg_attr(feature = "serde", serde(rename = "COND"))]
    Cond,
    #[yaserde(rename = "DSEL")]
    #[cfg_attr(feature = "serde", serde(rename = "DSEL"))]
    Dsel,
    #[yaserde(rename = "DUBA")]
    #[cfg_attr(feature = "serde", serde(rename = "DUBA"))]
    Duba,
    #[yaserde(rename = "ESPO")]
    #[cfg_attr(feature = "serde", serde(rename = "ESPO"))]
    Espo,
    #[yaserde(rename = "ETHA")]
    #[cfg_attr(feature = "serde", serde(rename = "ETHA"))]
    Etha,
    #[yaserde(rename = "FUEL")]
    #[cfg_attr(feature = "serde", serde(rename = "FUEL"))]
    Fuel,
    #[yaserde(rename = "FOIL")]
    #[cfg_attr(feature = "serde", serde(rename = "FOIL"))]
    Foil,
    #[yaserde(rename = "GOIL")]
    #[cfg_attr(feature = "serde", serde(rename = "GOIL"))]
    Goil,
    #[yaserde(rename = "GSLN")]
    #[cfg_attr(feature = "serde", serde(rename = "GSLN"))]
    Gsln,
    #[yaserde(rename = "HEAT")]
    #[cfg_attr(feature = "serde", serde(rename = "HEAT"))]
    Heat,
    #[yaserde(rename = "JTFL")]
    #[cfg_attr(feature = "serde", serde(rename = "JTFL"))]
    Jtfl,
    #[yaserde(rename = "KERO")]
    #[cfg_attr(feature = "serde", serde(rename = "KERO"))]
    Kero,
    #[yaserde(rename = "LLSO")]
    #[cfg_attr(feature = "serde", serde(rename = "LLSO"))]
    Llso,
    #[yaserde(rename = "MARS")]
    #[cfg_attr(feature = "serde", serde(rename = "MARS"))]
    Mars,
    #[yaserde(rename = "NAPH")]
    #[cfg_attr(feature = "serde", serde(rename = "NAPH"))]
    Naph,
    #[yaserde(rename = "NGLO")]
    #[cfg_attr(feature = "serde", serde(rename = "NGLO"))]
    Nglo,
    #[yaserde(rename = "TAPI")]
    #[cfg_attr(feature = "serde", serde(rename = "TAPI"))]
    Tapi,
    #[yaserde(rename = "WTIO")]
    #[cfg_attr(feature = "serde", serde(rename = "WTIO"))]
    Wtio,
    #[yaserde(rename = "URAL")]
    #[cfg_attr(feature = "serde", serde(rename = "URAL"))]
    Ural,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    __Unknown__(String),
}

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

impl Validate for AssetClassDetailedSubProductType32Code {}



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

pub enum AssetClassDetailedSubProductType33Code {
    #[yaserde(rename = "DBCR")]
    #[cfg_attr(feature = "serde", serde(rename = "DBCR"))]
    Dbcr,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    __Unknown__(String),
}

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

impl Validate for AssetClassDetailedSubProductType33Code {}



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

pub enum AssetClassDetailedSubProductType34Code {
    #[yaserde(rename = "TNKR")]
    #[cfg_attr(feature = "serde", serde(rename = "TNKR"))]
    Tnkr,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    __Unknown__(String),
}

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

impl Validate for AssetClassDetailedSubProductType34Code {}



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

pub enum AssetClassDetailedSubProductType5Code {
    #[yaserde(rename = "BSLD")]
    #[cfg_attr(feature = "serde", serde(rename = "BSLD"))]
    Bsld,
    #[yaserde(rename = "FITR")]
    #[cfg_attr(feature = "serde", serde(rename = "FITR"))]
    Fitr,
    #[yaserde(rename = "PKLD")]
    #[cfg_attr(feature = "serde", serde(rename = "PKLD"))]
    Pkld,
    #[yaserde(rename = "OFFP")]
    #[cfg_attr(feature = "serde", serde(rename = "OFFP"))]
    Offp,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    __Unknown__(String),
}

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

impl Validate for AssetClassDetailedSubProductType5Code {}



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

pub enum AssetClassDetailedSubProductType8Code {
    #[yaserde(rename = "CERE")]
    #[cfg_attr(feature = "serde", serde(rename = "CERE"))]
    Cere,
    #[yaserde(rename = "ERUE")]
    #[cfg_attr(feature = "serde", serde(rename = "ERUE"))]
    Erue,
    #[yaserde(rename = "EUAE")]
    #[cfg_attr(feature = "serde", serde(rename = "EUAE"))]
    Euae,
    #[yaserde(rename = "EUAA")]
    #[cfg_attr(feature = "serde", serde(rename = "EUAA"))]
    Euaa,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    __Unknown__(String),
}

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

impl Validate for AssetClassDetailedSubProductType8Code {}



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

pub enum AssetClassProductType11Code {
    #[yaserde(rename = "OTHC")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHC"))]
    Othc,
    __Unknown__(String),
}

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

impl Validate for AssetClassProductType11Code {}



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

pub enum AssetClassProductType12Code {
    #[yaserde(rename = "INFL")]
    #[cfg_attr(feature = "serde", serde(rename = "INFL"))]
    Infl,
    __Unknown__(String),
}

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

impl Validate for AssetClassProductType12Code {}



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

pub enum AssetClassProductType13Code {
    #[yaserde(rename = "MCEX")]
    #[cfg_attr(feature = "serde", serde(rename = "MCEX"))]
    Mcex,
    __Unknown__(String),
}

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

impl Validate for AssetClassProductType13Code {}



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

pub enum AssetClassProductType14Code {
    #[yaserde(rename = "OEST")]
    #[cfg_attr(feature = "serde", serde(rename = "OEST"))]
    Oest,
    __Unknown__(String),
}

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

impl Validate for AssetClassProductType14Code {}



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

pub enum AssetClassProductType15Code {
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    __Unknown__(String),
}

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

impl Validate for AssetClassProductType15Code {}



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

pub enum AssetClassProductType1Code {
    #[yaserde(rename = "AGRI")]
    #[cfg_attr(feature = "serde", serde(rename = "AGRI"))]
    Agri,
    __Unknown__(String),
}

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

impl Validate for AssetClassProductType1Code {}



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

pub enum AssetClassProductType2Code {
    #[yaserde(rename = "NRGY")]
    #[cfg_attr(feature = "serde", serde(rename = "NRGY"))]
    Nrgy,
    __Unknown__(String),
}

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

impl Validate for AssetClassProductType2Code {}



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

pub enum AssetClassProductType3Code {
    #[yaserde(rename = "ENVR")]
    #[cfg_attr(feature = "serde", serde(rename = "ENVR"))]
    Envr,
    __Unknown__(String),
}

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

impl Validate for AssetClassProductType3Code {}



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

pub enum AssetClassProductType4Code {
    #[yaserde(rename = "FRGT")]
    #[cfg_attr(feature = "serde", serde(rename = "FRGT"))]
    Frgt,
    __Unknown__(String),
}

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

impl Validate for AssetClassProductType4Code {}



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

pub enum AssetClassProductType5Code {
    #[yaserde(rename = "FRTL")]
    #[cfg_attr(feature = "serde", serde(rename = "FRTL"))]
    Frtl,
    __Unknown__(String),
}

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

impl Validate for AssetClassProductType5Code {}



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

pub enum AssetClassProductType6Code {
    #[yaserde(rename = "INDP")]
    #[cfg_attr(feature = "serde", serde(rename = "INDP"))]
    Indp,
    __Unknown__(String),
}

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

impl Validate for AssetClassProductType6Code {}



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

pub enum AssetClassProductType7Code {
    #[yaserde(rename = "METL")]
    #[cfg_attr(feature = "serde", serde(rename = "METL"))]
    Metl,
    __Unknown__(String),
}

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

impl Validate for AssetClassProductType7Code {}



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

pub enum AssetClassProductType8Code {
    #[yaserde(rename = "PAPR")]
    #[cfg_attr(feature = "serde", serde(rename = "PAPR"))]
    Papr,
    __Unknown__(String),
}

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

impl Validate for AssetClassProductType8Code {}



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

pub enum AssetClassProductType9Code {
    #[yaserde(rename = "POLY")]
    #[cfg_attr(feature = "serde", serde(rename = "POLY"))]
    Poly,
    __Unknown__(String),
}

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

impl Validate for AssetClassProductType9Code {}



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

pub enum AssetClassSubProductType10Code {
    #[yaserde(rename = "EMIS")]
    #[cfg_attr(feature = "serde", serde(rename = "EMIS"))]
    Emis,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType10Code {}



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

pub enum AssetClassSubProductType15Code {
    #[yaserde(rename = "NPRM")]
    #[cfg_attr(feature = "serde", serde(rename = "NPRM"))]
    Nprm,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType15Code {}



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

pub enum AssetClassSubProductType16Code {
    #[yaserde(rename = "PRME")]
    #[cfg_attr(feature = "serde", serde(rename = "PRME"))]
    Prme,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType16Code {}



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

pub enum AssetClassSubProductType18Code {
    #[yaserde(rename = "PLST")]
    #[cfg_attr(feature = "serde", serde(rename = "PLST"))]
    Plst,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType18Code {}



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

pub enum AssetClassSubProductType1Code {
    #[yaserde(rename = "GROS")]
    #[cfg_attr(feature = "serde", serde(rename = "GROS"))]
    Gros,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType1Code {}



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

pub enum AssetClassSubProductType20Code {
    #[yaserde(rename = "DIRY")]
    #[cfg_attr(feature = "serde", serde(rename = "DIRY"))]
    Diry,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType20Code {}



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

pub enum AssetClassSubProductType21Code {
    #[yaserde(rename = "FRST")]
    #[cfg_attr(feature = "serde", serde(rename = "FRST"))]
    Frst,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType21Code {}



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

pub enum AssetClassSubProductType22Code {
    #[yaserde(rename = "LSTK")]
    #[cfg_attr(feature = "serde", serde(rename = "LSTK"))]
    Lstk,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType22Code {}



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

pub enum AssetClassSubProductType23Code {
    #[yaserde(rename = "SEAF")]
    #[cfg_attr(feature = "serde", serde(rename = "SEAF"))]
    Seaf,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType23Code {}



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

pub enum AssetClassSubProductType24Code {
    #[yaserde(rename = "COAL")]
    #[cfg_attr(feature = "serde", serde(rename = "COAL"))]
    Coal,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType24Code {}



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

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

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

impl Validate for AssetClassSubProductType25Code {}



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

pub enum AssetClassSubProductType26Code {
    #[yaserde(rename = "INRG")]
    #[cfg_attr(feature = "serde", serde(rename = "INRG"))]
    Inrg,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType26Code {}



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

pub enum AssetClassSubProductType27Code {
    #[yaserde(rename = "LGHT")]
    #[cfg_attr(feature = "serde", serde(rename = "LGHT"))]
    Lght,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType27Code {}



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

pub enum AssetClassSubProductType28Code {
    #[yaserde(rename = "RNNG")]
    #[cfg_attr(feature = "serde", serde(rename = "RNNG"))]
    Rnng,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType28Code {}



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

pub enum AssetClassSubProductType29Code {
    #[yaserde(rename = "CRBR")]
    #[cfg_attr(feature = "serde", serde(rename = "CRBR"))]
    Crbr,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType29Code {}



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

pub enum AssetClassSubProductType2Code {
    #[yaserde(rename = "SOFT")]
    #[cfg_attr(feature = "serde", serde(rename = "SOFT"))]
    Soft,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType2Code {}



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

pub enum AssetClassSubProductType30Code {
    #[yaserde(rename = "WTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "WTHR"))]
    Wthr,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType30Code {}



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

pub enum AssetClassSubProductType31Code {
    #[yaserde(rename = "DRYF")]
    #[cfg_attr(feature = "serde", serde(rename = "DRYF"))]
    Dryf,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType31Code {}



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

pub enum AssetClassSubProductType32Code {
    #[yaserde(rename = "WETF")]
    #[cfg_attr(feature = "serde", serde(rename = "WETF"))]
    Wetf,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType32Code {}



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

pub enum AssetClassSubProductType33Code {
    #[yaserde(rename = "CSTR")]
    #[cfg_attr(feature = "serde", serde(rename = "CSTR"))]
    Cstr,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType33Code {}



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

pub enum AssetClassSubProductType34Code {
    #[yaserde(rename = "MFTG")]
    #[cfg_attr(feature = "serde", serde(rename = "MFTG"))]
    Mftg,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType34Code {}



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

pub enum AssetClassSubProductType35Code {
    #[yaserde(rename = "CBRD")]
    #[cfg_attr(feature = "serde", serde(rename = "CBRD"))]
    Cbrd,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType35Code {}



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

pub enum AssetClassSubProductType36Code {
    #[yaserde(rename = "NSPT")]
    #[cfg_attr(feature = "serde", serde(rename = "NSPT"))]
    Nspt,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType36Code {}



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

pub enum AssetClassSubProductType37Code {
    #[yaserde(rename = "PULP")]
    #[cfg_attr(feature = "serde", serde(rename = "PULP"))]
    Pulp,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType37Code {}



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

pub enum AssetClassSubProductType38Code {
    #[yaserde(rename = "RCVP")]
    #[cfg_attr(feature = "serde", serde(rename = "RCVP"))]
    Rcvp,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType38Code {}



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

pub enum AssetClassSubProductType39Code {
    #[yaserde(rename = "AMMO")]
    #[cfg_attr(feature = "serde", serde(rename = "AMMO"))]
    Ammo,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType39Code {}



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

pub enum AssetClassSubProductType3Code {
    #[yaserde(rename = "OOLI")]
    #[cfg_attr(feature = "serde", serde(rename = "OOLI"))]
    Ooli,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType3Code {}



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

pub enum AssetClassSubProductType40Code {
    #[yaserde(rename = "DAPH")]
    #[cfg_attr(feature = "serde", serde(rename = "DAPH"))]
    Daph,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType40Code {}



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

pub enum AssetClassSubProductType41Code {
    #[yaserde(rename = "PTSH")]
    #[cfg_attr(feature = "serde", serde(rename = "PTSH"))]
    Ptsh,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType41Code {}



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

pub enum AssetClassSubProductType42Code {
    #[yaserde(rename = "SLPH")]
    #[cfg_attr(feature = "serde", serde(rename = "SLPH"))]
    Slph,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType42Code {}



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

pub enum AssetClassSubProductType43Code {
    #[yaserde(rename = "UREA")]
    #[cfg_attr(feature = "serde", serde(rename = "UREA"))]
    Urea,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType43Code {}



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

pub enum AssetClassSubProductType44Code {
    #[yaserde(rename = "UAAN")]
    #[cfg_attr(feature = "serde", serde(rename = "UAAN"))]
    Uaan,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType44Code {}



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

pub enum AssetClassSubProductType45Code {
    #[yaserde(rename = "POTA")]
    #[cfg_attr(feature = "serde", serde(rename = "POTA"))]
    Pota,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType45Code {}



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

pub enum AssetClassSubProductType46Code {
    #[yaserde(rename = "CSHP")]
    #[cfg_attr(feature = "serde", serde(rename = "CSHP"))]
    Cshp,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType46Code {}



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

pub enum AssetClassSubProductType47Code {
    #[yaserde(rename = "DLVR")]
    #[cfg_attr(feature = "serde", serde(rename = "DLVR"))]
    Dlvr,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType47Code {}



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

pub enum AssetClassSubProductType48Code {
    #[yaserde(rename = "NDLV")]
    #[cfg_attr(feature = "serde", serde(rename = "NDLV"))]
    Ndlv,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType48Code {}



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

pub enum AssetClassSubProductType49Code {
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType49Code {}



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

pub enum AssetClassSubProductType5Code {
    #[yaserde(rename = "GRIN")]
    #[cfg_attr(feature = "serde", serde(rename = "GRIN"))]
    Grin,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType5Code {}



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

pub enum AssetClassSubProductType6Code {
    #[yaserde(rename = "ELEC")]
    #[cfg_attr(feature = "serde", serde(rename = "ELEC"))]
    Elec,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType6Code {}



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

pub enum AssetClassSubProductType7Code {
    #[yaserde(rename = "NGAS")]
    #[cfg_attr(feature = "serde", serde(rename = "NGAS"))]
    Ngas,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType7Code {}



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

pub enum AssetClassSubProductType8Code {
    #[yaserde(rename = "OILP")]
    #[cfg_attr(feature = "serde", serde(rename = "OILP"))]
    Oilp,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType8Code {}



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

impl Validate for BaseOneRate {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.080.001.02")]
pub struct BenchmarkCurveName10Choice {
    #[yaserde(rename = "Indx")]
    #[cfg_attr(feature = "serde", serde(rename = "Indx"))]
    pub indx: Option<BenchmarkCurveName3Code>,
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Option<Max350Text>,
}

impl Validate for BenchmarkCurveName10Choice {}




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

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

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

impl Validate for BenchmarkCurveName3Code {}



#[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.080.001.02")]
pub struct CashCompare3 {
    #[yaserde(rename = "Val")]
    #[cfg_attr(feature = "serde", serde(rename = "Val"))]
    pub val: CompareAmountAndDirection2,

    #[yaserde(rename = "HrcutOrMrgn")]
    #[cfg_attr(feature = "serde", serde(rename = "HrcutOrMrgn"))]
    pub hrcut_or_mrgn: ComparePercentageRate3,
}

impl Validate for CashCompare3 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct Cleared4Choice {
    #[yaserde(rename = "Clrd")]
    #[cfg_attr(feature = "serde", serde(rename = "Clrd"))]
    pub clrd: Option<NoReasonCode>,
    #[yaserde(rename = "NonClrd")]
    #[cfg_attr(feature = "serde", serde(rename = "NonClrd"))]
    pub non_clrd: Option<NoReasonCode>,
}

impl Validate for Cleared4Choice {}




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

pub enum CollateralDeliveryMethod1Code {
    #[yaserde(rename = "SICA")]
    #[cfg_attr(feature = "serde", serde(rename = "SICA"))]
    Sica,
    #[yaserde(rename = "SIUR")]
    #[cfg_attr(feature = "serde", serde(rename = "SIUR"))]
    Siur,
    #[yaserde(rename = "TTCA")]
    #[cfg_attr(feature = "serde", serde(rename = "TTCA"))]
    Ttca,
    __Unknown__(String),
}

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

impl Validate for CollateralDeliveryMethod1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CollateralMatchingCriteria6 {
    #[yaserde(rename = "UncollsdFlg")]
    #[cfg_attr(feature = "serde", serde(rename = "UncollsdFlg"))]
    pub uncollsd_flg: CompareTrueFalseIndicator3,

    #[yaserde(rename = "NetXpsrCollstnInd")]
    #[cfg_attr(feature = "serde", serde(rename = "NetXpsrCollstnInd"))]
    pub net_xpsr_collstn_ind: CompareTrueFalseIndicator3,

    #[yaserde(rename = "CollValDt")]
    #[cfg_attr(feature = "serde", serde(rename = "CollValDt"))]
    pub coll_val_dt: CompareDate3,

    #[yaserde(rename = "AsstTp")]
    #[cfg_attr(feature = "serde", serde(rename = "AsstTp"))]
    pub asst_tp: SecurityCommodityCash4,

    #[yaserde(rename = "BsktIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "BsktIdr"))]
    pub bskt_idr: CompareSecurityIdentification4,
}

impl Validate for CollateralMatchingCriteria6 {}


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

pub enum CollateralQualityType1Code {
    #[yaserde(rename = "INVG")]
    #[cfg_attr(feature = "serde", serde(rename = "INVG"))]
    Invg,
    #[yaserde(rename = "NIVG")]
    #[cfg_attr(feature = "serde", serde(rename = "NIVG"))]
    Nivg,
    #[yaserde(rename = "NOTR")]
    #[cfg_attr(feature = "serde", serde(rename = "NOTR"))]
    Notr,
    #[yaserde(rename = "NOAP")]
    #[cfg_attr(feature = "serde", serde(rename = "NOAP"))]
    Noap,
    __Unknown__(String),
}

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

impl Validate for CollateralQualityType1Code {}



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

pub enum CollateralRole1Code {
    #[yaserde(rename = "GIVE")]
    #[cfg_attr(feature = "serde", serde(rename = "GIVE"))]
    Give,
    #[yaserde(rename = "TAKE")]
    #[cfg_attr(feature = "serde", serde(rename = "TAKE"))]
    Take,
    __Unknown__(String),
}

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

impl Validate for CollateralRole1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct Commodity42 {
    #[yaserde(rename = "Clssfctn")]
    #[cfg_attr(feature = "serde", serde(rename = "Clssfctn"))]
    pub clssfctn: CompareCommodityAssetClass3,

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

    #[yaserde(rename = "UnitPric")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitPric"))]
    pub unit_pric: CompareUnitPrice6,

    #[yaserde(rename = "MktVal")]
    #[cfg_attr(feature = "serde", serde(rename = "MktVal"))]
    pub mkt_val: CompareAmountAndDirection2,

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

impl Validate for Commodity42 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareActiveOrHistoricCurrencyAndAmount3 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: ActiveOrHistoricCurrencyAndAmount,

    #[yaserde(rename = "Val2")]
    #[cfg_attr(feature = "serde", serde(rename = "Val2"))]
    pub val_2: ActiveOrHistoricCurrencyAndAmount,
}

impl Validate for CompareActiveOrHistoricCurrencyAndAmount3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareAgreementType2 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: AgreementType1Choice,

    #[yaserde(rename = "Val2")]
    #[cfg_attr(feature = "serde", serde(rename = "Val2"))]
    pub val_2: AgreementType1Choice,
}

impl Validate for CompareAgreementType2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareAmountAndDirection1 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: AmountAndDirection53,

    #[yaserde(rename = "Val2")]
    #[cfg_attr(feature = "serde", serde(rename = "Val2"))]
    pub val_2: AmountAndDirection53,
}

impl Validate for CompareAmountAndDirection1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareAmountAndDirection2 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: AmountAndDirection53,

    #[yaserde(rename = "Val2")]
    #[cfg_attr(feature = "serde", serde(rename = "Val2"))]
    pub val_2: AmountAndDirection53,
}

impl Validate for CompareAmountAndDirection2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareBenchmarkCurveName3 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: BenchmarkCurveName10Choice,

    #[yaserde(rename = "Val2")]
    #[cfg_attr(feature = "serde", serde(rename = "Val2"))]
    pub val_2: BenchmarkCurveName10Choice,
}

impl Validate for CompareBenchmarkCurveName3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareCFIIdentifier3 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: Cfioct2015Identifier,

    #[yaserde(rename = "Val2")]
    #[cfg_attr(feature = "serde", serde(rename = "Val2"))]
    pub val_2: Cfioct2015Identifier,
}

impl Validate for CompareCFIIdentifier3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareClearingStatus3 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: Cleared4Choice,

    #[yaserde(rename = "Val2")]
    #[cfg_attr(feature = "serde", serde(rename = "Val2"))]
    pub val_2: Cleared4Choice,
}

impl Validate for CompareClearingStatus3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareCollateralQualityType3 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: CollateralQualityType1Code,

    #[yaserde(rename = "Val2")]
    #[cfg_attr(feature = "serde", serde(rename = "Val2"))]
    pub val_2: CollateralQualityType1Code,
}

impl Validate for CompareCollateralQualityType3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareCommodityAssetClass3 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: AssetClassCommodity5Choice,

    #[yaserde(rename = "Val2")]
    #[cfg_attr(feature = "serde", serde(rename = "Val2"))]
    pub val_2: AssetClassCommodity5Choice,
}

impl Validate for CompareCommodityAssetClass3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareCounterpartySide2 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: CollateralRole1Code,

    #[yaserde(rename = "Val2")]
    #[cfg_attr(feature = "serde", serde(rename = "Val2"))]
    pub val_2: CollateralRole1Code,
}

impl Validate for CompareCounterpartySide2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareCountryCode3 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: CountryCode,

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

impl Validate for CompareCountryCode3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareDate3 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: Isodate,

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

impl Validate for CompareDate3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareDateTime3 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: IsodateTime,

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

impl Validate for CompareDateTime3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareDecimalNumber3 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: DecimalNumber,

    #[yaserde(rename = "Val2")]
    #[cfg_attr(feature = "serde", serde(rename = "Val2"))]
    pub val_2: DecimalNumber,
}

impl Validate for CompareDecimalNumber3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareDeliveryMethod3 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: CollateralDeliveryMethod1Code,

    #[yaserde(rename = "Val2")]
    #[cfg_attr(feature = "serde", serde(rename = "Val2"))]
    pub val_2: CollateralDeliveryMethod1Code,
}

impl Validate for CompareDeliveryMethod3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareExposureType3 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: ExposureType10Code,

    #[yaserde(rename = "Val2")]
    #[cfg_attr(feature = "serde", serde(rename = "Val2"))]
    pub val_2: ExposureType10Code,
}

impl Validate for CompareExposureType3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareISINIdentifier4 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: Isinoct2015Identifier,

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

impl Validate for CompareISINIdentifier4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareInterestComputationMethod3 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: InterestComputationMethodFormat6Choice,

    #[yaserde(rename = "Val2")]
    #[cfg_attr(feature = "serde", serde(rename = "Val2"))]
    pub val_2: InterestComputationMethodFormat6Choice,
}

impl Validate for CompareInterestComputationMethod3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareInterestRate1 {
    #[yaserde(rename = "MrgnLnAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "MrgnLnAmt"))]
    pub mrgn_ln_amt: CompareAmountAndDirection1,

    #[yaserde(rename = "FxdIntrstRate")]
    #[cfg_attr(feature = "serde", serde(rename = "FxdIntrstRate"))]
    pub fxd_intrst_rate: ComparePercentageRate3,

    #[yaserde(rename = "DayCntBsis")]
    #[cfg_attr(feature = "serde", serde(rename = "DayCntBsis"))]
    pub day_cnt_bsis: CompareInterestComputationMethod3,

    #[yaserde(rename = "FltgIntrstRefRate")]
    #[cfg_attr(feature = "serde", serde(rename = "FltgIntrstRefRate"))]
    pub fltg_intrst_ref_rate: CompareBenchmarkCurveName3,

    #[yaserde(rename = "FltgIntrstRateTermUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "FltgIntrstRateTermUnit"))]
    pub fltg_intrst_rate_term_unit: CompareRateBasis3,

    #[yaserde(rename = "FltgIntrstRateTermVal")]
    #[cfg_attr(feature = "serde", serde(rename = "FltgIntrstRateTermVal"))]
    pub fltg_intrst_rate_term_val: CompareNumber5,

    #[yaserde(rename = "FltgIntrstRatePmtFrqcyUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "FltgIntrstRatePmtFrqcyUnit"))]
    pub fltg_intrst_rate_pmt_frqcy_unit: CompareRateBasis3,

    #[yaserde(rename = "FltgIntrstRatePmtFrqcyVal")]
    #[cfg_attr(feature = "serde", serde(rename = "FltgIntrstRatePmtFrqcyVal"))]
    pub fltg_intrst_rate_pmt_frqcy_val: CompareNumber5,

    #[yaserde(rename = "FltgIntrstRateRstFrqcyUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "FltgIntrstRateRstFrqcyUnit"))]
    pub fltg_intrst_rate_rst_frqcy_unit: CompareRateBasis3,

    #[yaserde(rename = "FltgIntrstRateRstFrqcyVal")]
    #[cfg_attr(feature = "serde", serde(rename = "FltgIntrstRateRstFrqcyVal"))]
    pub fltg_intrst_rate_rst_frqcy_val: CompareNumber6,

    #[yaserde(rename = "BsisPtSprd")]
    #[cfg_attr(feature = "serde", serde(rename = "BsisPtSprd"))]
    pub bsis_pt_sprd: CompareDecimalNumber3,
}

impl Validate for CompareInterestRate1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareMICIdentifier3 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: Micidentifier,

    #[yaserde(rename = "Val2")]
    #[cfg_attr(feature = "serde", serde(rename = "Val2"))]
    pub val_2: Micidentifier,
}

impl Validate for CompareMICIdentifier3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareNumber5 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: Max3Number,

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

impl Validate for CompareNumber5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareNumber6 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: Max5Number,

    #[yaserde(rename = "Val2")]
    #[cfg_attr(feature = "serde", serde(rename = "Val2"))]
    pub val_2: Max5Number,
}

impl Validate for CompareNumber6 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareOrganisationIdentification6 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: OrganisationIdentification15Choice,

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

impl Validate for CompareOrganisationIdentification6 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareOrganisationIdentification7 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: PartyIdentification236Choice,

    #[yaserde(rename = "Val2")]
    #[cfg_attr(feature = "serde", serde(rename = "Val2"))]
    pub val_2: PartyIdentification236Choice,
}

impl Validate for CompareOrganisationIdentification7 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct ComparePercentageRate3 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: PercentageRate,

    #[yaserde(rename = "Val2")]
    #[cfg_attr(feature = "serde", serde(rename = "Val2"))]
    pub val_2: PercentageRate,
}

impl Validate for ComparePercentageRate3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareRateBasis3 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: RateBasis1Code,

    #[yaserde(rename = "Val2")]
    #[cfg_attr(feature = "serde", serde(rename = "Val2"))]
    pub val_2: RateBasis1Code,
}

impl Validate for CompareRateBasis3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareReportingLevelType3 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: ModificationLevel1Code,

    #[yaserde(rename = "Val2")]
    #[cfg_attr(feature = "serde", serde(rename = "Val2"))]
    pub val_2: ModificationLevel1Code,
}

impl Validate for CompareReportingLevelType3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareSecuritiesLendingType3 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: SecuritiesLendingType3Choice,

    #[yaserde(rename = "Val2")]
    #[cfg_attr(feature = "serde", serde(rename = "Val2"))]
    pub val_2: SecuritiesLendingType3Choice,
}

impl Validate for CompareSecuritiesLendingType3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareSecurityIdentification4 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: SecurityIdentification26Choice,

    #[yaserde(rename = "Val2")]
    #[cfg_attr(feature = "serde", serde(rename = "Val2"))]
    pub val_2: SecurityIdentification26Choice,
}

impl Validate for CompareSecurityIdentification4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareSpecialCollateral3 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: SpecialCollateral1Code,

    #[yaserde(rename = "Val2")]
    #[cfg_attr(feature = "serde", serde(rename = "Val2"))]
    pub val_2: SpecialCollateral1Code,
}

impl Validate for CompareSpecialCollateral3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareTerminationOption3 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: RepoTerminationOption2Code,

    #[yaserde(rename = "Val2")]
    #[cfg_attr(feature = "serde", serde(rename = "Val2"))]
    pub val_2: RepoTerminationOption2Code,
}

impl Validate for CompareTerminationOption3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareText2 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: Max52Text,

    #[yaserde(rename = "Val2")]
    #[cfg_attr(feature = "serde", serde(rename = "Val2"))]
    pub val_2: Max52Text,
}

impl Validate for CompareText2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareTrueFalseIndicator3 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: TrueFalseIndicator,

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

impl Validate for CompareTrueFalseIndicator3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareUnitOfMeasure3 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: UnitOfMeasure11Code,

    #[yaserde(rename = "Val2")]
    #[cfg_attr(feature = "serde", serde(rename = "Val2"))]
    pub val_2: UnitOfMeasure11Code,
}

impl Validate for CompareUnitOfMeasure3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CompareUnitPrice6 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: SecuritiesTransactionPrice19Choice,

    #[yaserde(rename = "Val2")]
    #[cfg_attr(feature = "serde", serde(rename = "Val2"))]
    pub val_2: SecuritiesTransactionPrice19Choice,
}

impl Validate for CompareUnitPrice6 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct CounterpartyMatchingCriteria4 {
    #[yaserde(rename = "RptgCtrPty")]
    #[cfg_attr(feature = "serde", serde(rename = "RptgCtrPty"))]
    pub rptg_ctr_pty: CompareOrganisationIdentification6,

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

    #[yaserde(rename = "CtrPtySd")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrPtySd"))]
    pub ctr_pty_sd: CompareCounterpartySide2,
}

impl Validate for CounterpartyMatchingCriteria4 {}


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

impl Validate for CountryCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct 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.080.001.02")]
pub struct Document {
    #[yaserde(rename = "SctiesFincgRptgRcncltnStsAdvc")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesFincgRptgRcncltnStsAdvc"))]
    pub scties_fincg_rptg_rcncltn_sts_advc: SecuritiesFinancingReportingReconciliationStatusAdviceV02,
}

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.080.001.02")]
pub struct EnergyCommodityCoal1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType2Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType24Code,
}

impl Validate for EnergyCommodityCoal1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct EnergyCommodityDistillates1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType2Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType25Code,
}

impl Validate for EnergyCommodityDistillates1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct EnergyCommodityElectricity1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType2Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType6Code,

    #[yaserde(rename = "AddtlSubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlSubPdct"))]
    pub addtl_sub_pdct: AssetClassDetailedSubProductType5Code,
}

impl Validate for EnergyCommodityElectricity1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct EnergyCommodityInterEnergy1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType2Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType26Code,
}

impl Validate for EnergyCommodityInterEnergy1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct EnergyCommodityLightEnd1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType2Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType27Code,
}

impl Validate for EnergyCommodityLightEnd1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct EnergyCommodityNaturalGas2 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType2Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType7Code,

    #[yaserde(rename = "AddtlSubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlSubPdct"))]
    pub addtl_sub_pdct: AssetClassDetailedSubProductType31Code,
}

impl Validate for EnergyCommodityNaturalGas2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct EnergyCommodityOil2 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType2Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType8Code,

    #[yaserde(rename = "AddtlSubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlSubPdct"))]
    pub addtl_sub_pdct: AssetClassDetailedSubProductType32Code,
}

impl Validate for EnergyCommodityOil2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct EnergyCommodityOther1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType2Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType49Code,
}

impl Validate for EnergyCommodityOther1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct EnergyCommodityRenewableEnergy1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType2Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType28Code,
}

impl Validate for EnergyCommodityRenewableEnergy1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct EnvironmentCommodityOther1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType3Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType49Code,
}

impl Validate for EnvironmentCommodityOther1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct EnvironmentalCommodityCarbonRelated1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType3Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType29Code,
}

impl Validate for EnvironmentalCommodityCarbonRelated1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct EnvironmentalCommodityEmission2 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType3Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType10Code,

    #[yaserde(rename = "AddtlSubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlSubPdct"))]
    pub addtl_sub_pdct: AssetClassDetailedSubProductType8Code,
}

impl Validate for EnvironmentalCommodityEmission2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct EnvironmentalCommodityWeather1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType3Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType30Code,
}

impl Validate for EnvironmentalCommodityWeather1 {}


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

pub enum ExposureType10Code {
    #[yaserde(rename = "SBSC")]
    #[cfg_attr(feature = "serde", serde(rename = "SBSC"))]
    Sbsc,
    #[yaserde(rename = "MGLD")]
    #[cfg_attr(feature = "serde", serde(rename = "MGLD"))]
    Mgld,
    #[yaserde(rename = "SLEB")]
    #[cfg_attr(feature = "serde", serde(rename = "SLEB"))]
    Sleb,
    #[yaserde(rename = "REPO")]
    #[cfg_attr(feature = "serde", serde(rename = "REPO"))]
    Repo,
    __Unknown__(String),
}

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

impl Validate for ExposureType10Code {}



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

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

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

impl Validate for ExternalSecuritiesLendingType1Code {
    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.080.001.02")]
pub struct FertilizerCommodityAmmonia1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType5Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType39Code,
}

impl Validate for FertilizerCommodityAmmonia1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct FertilizerCommodityDiammoniumPhosphate1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType5Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType40Code,
}

impl Validate for FertilizerCommodityDiammoniumPhosphate1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct FertilizerCommodityOther1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType5Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType49Code,
}

impl Validate for FertilizerCommodityOther1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct FertilizerCommodityPotash1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType5Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType41Code,
}

impl Validate for FertilizerCommodityPotash1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct FertilizerCommoditySulphur1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType5Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType42Code,
}

impl Validate for FertilizerCommoditySulphur1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct FertilizerCommodityUrea1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType5Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType43Code,
}

impl Validate for FertilizerCommodityUrea1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct FertilizerCommodityUreaAndAmmoniumNitrate1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType5Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType44Code,
}

impl Validate for FertilizerCommodityUreaAndAmmoniumNitrate1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct FreightCommodityContainerShip1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType4Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType46Code,
}

impl Validate for FreightCommodityContainerShip1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct FreightCommodityDry2 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType4Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType31Code,

    #[yaserde(rename = "AddtlSubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlSubPdct"))]
    pub addtl_sub_pdct: AssetClassDetailedSubProductType33Code,
}

impl Validate for FreightCommodityDry2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct FreightCommodityOther1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType4Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType49Code,
}

impl Validate for FreightCommodityOther1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct FreightCommodityWet2 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType4Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType32Code,

    #[yaserde(rename = "AddtlSubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlSubPdct"))]
    pub addtl_sub_pdct: AssetClassDetailedSubProductType34Code,
}

impl Validate for FreightCommodityWet2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
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)]
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.080.001.02")]
pub struct IndustrialProductCommodityConstruction1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType6Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType33Code,
}

impl Validate for IndustrialProductCommodityConstruction1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct IndustrialProductCommodityManufacturing1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType6Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType34Code,
}

impl Validate for IndustrialProductCommodityManufacturing1 {}


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

pub enum InterestComputationMethod1Code {
    A001,
    A002,
    A003,
    A004,
    A005,
    A006,
    A007,
    A008,
    A009,
    A010,
    A011,
    A012,
    A013,
    A014,
    __Unknown__(String),
}

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

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

impl Validate for InterestComputationMethodFormat6Choice {}




#[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.080.001.02")]
pub struct LoanMatchingCriteria9 {
    #[yaserde(rename = "UnqTradIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "UnqTradIdr"))]
    pub unq_trad_idr: CompareText2,

    #[yaserde(rename = "TermntnDt")]
    #[cfg_attr(feature = "serde", serde(rename = "TermntnDt"))]
    pub termntn_dt: CompareDate3,

    #[yaserde(rename = "CtrctTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrctTp"))]
    pub ctrct_tp: CompareExposureType3,

    #[yaserde(rename = "ClrSts")]
    #[cfg_attr(feature = "serde", serde(rename = "ClrSts"))]
    pub clr_sts: CompareClearingStatus3,

    #[yaserde(rename = "ClrDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "ClrDtTm"))]
    pub clr_dt_tm: CompareDateTime3,

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

    #[yaserde(rename = "TradgVn")]
    #[cfg_attr(feature = "serde", serde(rename = "TradgVn"))]
    pub tradg_vn: CompareMICIdentifier3,

    #[yaserde(rename = "MstrAgrmtTp")]
    #[cfg_attr(feature = "serde", serde(rename = "MstrAgrmtTp"))]
    pub mstr_agrmt_tp: CompareAgreementType2,

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

    #[yaserde(rename = "ValDt")]
    #[cfg_attr(feature = "serde", serde(rename = "ValDt"))]
    pub val_dt: CompareDate3,

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

    #[yaserde(rename = "MinNtcePrd")]
    #[cfg_attr(feature = "serde", serde(rename = "MinNtcePrd"))]
    pub min_ntce_prd: CompareNumber5,

    #[yaserde(rename = "EarlstCallBckDt")]
    #[cfg_attr(feature = "serde", serde(rename = "EarlstCallBckDt"))]
    pub earlst_call_bck_dt: CompareDate3,

    #[yaserde(rename = "GnlColl")]
    #[cfg_attr(feature = "serde", serde(rename = "GnlColl"))]
    pub gnl_coll: CompareSpecialCollateral3,

    #[yaserde(rename = "DlvryByVal")]
    #[cfg_attr(feature = "serde", serde(rename = "DlvryByVal"))]
    pub dlvry_by_val: CompareTrueFalseIndicator3,

    #[yaserde(rename = "CollDlvryMtd")]
    #[cfg_attr(feature = "serde", serde(rename = "CollDlvryMtd"))]
    pub coll_dlvry_mtd: CompareDeliveryMethod3,

    #[yaserde(rename = "OpnTerm")]
    #[cfg_attr(feature = "serde", serde(rename = "OpnTerm"))]
    pub opn_term: CompareTrueFalseIndicator3,

    #[yaserde(rename = "TermntnOptn")]
    #[cfg_attr(feature = "serde", serde(rename = "TermntnOptn"))]
    pub termntn_optn: CompareTerminationOption3,

    #[yaserde(rename = "FxdIntrstRate")]
    #[cfg_attr(feature = "serde", serde(rename = "FxdIntrstRate"))]
    pub fxd_intrst_rate: ComparePercentageRate3,

    #[yaserde(rename = "DayCntBsis")]
    #[cfg_attr(feature = "serde", serde(rename = "DayCntBsis"))]
    pub day_cnt_bsis: CompareInterestComputationMethod3,

    #[yaserde(rename = "FltgIntrstRefRate")]
    #[cfg_attr(feature = "serde", serde(rename = "FltgIntrstRefRate"))]
    pub fltg_intrst_ref_rate: CompareBenchmarkCurveName3,

    #[yaserde(rename = "FltgIntrstRateTermUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "FltgIntrstRateTermUnit"))]
    pub fltg_intrst_rate_term_unit: CompareRateBasis3,

    #[yaserde(rename = "FltgIntrstRateTermVal")]
    #[cfg_attr(feature = "serde", serde(rename = "FltgIntrstRateTermVal"))]
    pub fltg_intrst_rate_term_val: CompareNumber5,

    #[yaserde(rename = "FltgIntrstRatePmtFrqcyUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "FltgIntrstRatePmtFrqcyUnit"))]
    pub fltg_intrst_rate_pmt_frqcy_unit: CompareRateBasis3,

    #[yaserde(rename = "FltgIntrstRatePmtFrqcyVal")]
    #[cfg_attr(feature = "serde", serde(rename = "FltgIntrstRatePmtFrqcyVal"))]
    pub fltg_intrst_rate_pmt_frqcy_val: CompareNumber5,

    #[yaserde(rename = "FltgIntrstRateRstFrqcyUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "FltgIntrstRateRstFrqcyUnit"))]
    pub fltg_intrst_rate_rst_frqcy_unit: CompareRateBasis3,

    #[yaserde(rename = "FltgIntrstRateRstFrqcyVal")]
    #[cfg_attr(feature = "serde", serde(rename = "FltgIntrstRateRstFrqcyVal"))]
    pub fltg_intrst_rate_rst_frqcy_val: CompareNumber6,

    #[yaserde(rename = "BsisPtSprd")]
    #[cfg_attr(feature = "serde", serde(rename = "BsisPtSprd"))]
    pub bsis_pt_sprd: CompareDecimalNumber3,

    #[yaserde(rename = "MrgnLnAttr")]
    #[cfg_attr(feature = "serde", serde(rename = "MrgnLnAttr"))]
    pub mrgn_ln_attr: Vec<CompareInterestRate1>,

    #[yaserde(rename = "PrncplAmtValDtAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "PrncplAmtValDtAmt"))]
    pub prncpl_amt_val_dt_amt: CompareActiveOrHistoricCurrencyAndAmount3,

    #[yaserde(rename = "PrncplAmtMtrtyDtAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "PrncplAmtMtrtyDtAmt"))]
    pub prncpl_amt_mtrty_dt_amt: CompareActiveOrHistoricCurrencyAndAmount3,

    #[yaserde(rename = "AsstTp")]
    #[cfg_attr(feature = "serde", serde(rename = "AsstTp"))]
    pub asst_tp: SecurityCommodity7Choice,

    #[yaserde(rename = "LnVal")]
    #[cfg_attr(feature = "serde", serde(rename = "LnVal"))]
    pub ln_val: CompareActiveOrHistoricCurrencyAndAmount3,

    #[yaserde(rename = "FxdRbtRefRate")]
    #[cfg_attr(feature = "serde", serde(rename = "FxdRbtRefRate"))]
    pub fxd_rbt_ref_rate: ComparePercentageRate3,

    #[yaserde(rename = "FltgRbtRefRate")]
    #[cfg_attr(feature = "serde", serde(rename = "FltgRbtRefRate"))]
    pub fltg_rbt_ref_rate: CompareBenchmarkCurveName3,

    #[yaserde(rename = "FltgRbtRateTermUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "FltgRbtRateTermUnit"))]
    pub fltg_rbt_rate_term_unit: CompareRateBasis3,

    #[yaserde(rename = "FltgRbtRateTermVal")]
    #[cfg_attr(feature = "serde", serde(rename = "FltgRbtRateTermVal"))]
    pub fltg_rbt_rate_term_val: CompareNumber6,

    #[yaserde(rename = "FltgRbtRatePmtFrqcyUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "FltgRbtRatePmtFrqcyUnit"))]
    pub fltg_rbt_rate_pmt_frqcy_unit: CompareRateBasis3,

    #[yaserde(rename = "FltgRbtRatePmtFrqcyVal")]
    #[cfg_attr(feature = "serde", serde(rename = "FltgRbtRatePmtFrqcyVal"))]
    pub fltg_rbt_rate_pmt_frqcy_val: CompareNumber6,

    #[yaserde(rename = "FltgRbtRateRstFrqcyUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "FltgRbtRateRstFrqcyUnit"))]
    pub fltg_rbt_rate_rst_frqcy_unit: CompareRateBasis3,

    #[yaserde(rename = "FltgRbtRateRstFrqcyVal")]
    #[cfg_attr(feature = "serde", serde(rename = "FltgRbtRateRstFrqcyVal"))]
    pub fltg_rbt_rate_rst_frqcy_val: CompareNumber6,

    #[yaserde(rename = "RbtRateBsisPtSprd")]
    #[cfg_attr(feature = "serde", serde(rename = "RbtRateBsisPtSprd"))]
    pub rbt_rate_bsis_pt_sprd: CompareDecimalNumber3,

    #[yaserde(rename = "FltgRateAdjstmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "FltgRateAdjstmnt"))]
    pub fltg_rate_adjstmnt: Vec<ComparePercentageRate3>,

    #[yaserde(rename = "FltgRateAdjstmntDt")]
    #[cfg_attr(feature = "serde", serde(rename = "FltgRateAdjstmntDt"))]
    pub fltg_rate_adjstmnt_dt: Vec<CompareDate3>,

    #[yaserde(rename = "LndgFee")]
    #[cfg_attr(feature = "serde", serde(rename = "LndgFee"))]
    pub lndg_fee: ComparePercentageRate3,

    #[yaserde(rename = "OutsdngMrgnLnAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "OutsdngMrgnLnAmt"))]
    pub outsdng_mrgn_ln_amt: CompareActiveOrHistoricCurrencyAndAmount3,

    #[yaserde(rename = "ShrtMktValAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "ShrtMktValAmt"))]
    pub shrt_mkt_val_amt: CompareActiveOrHistoricCurrencyAndAmount3,

    #[yaserde(rename = "LvlTp")]
    #[cfg_attr(feature = "serde", serde(rename = "LvlTp"))]
    pub lvl_tp: CompareReportingLevelType3,

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

impl Validate for LoanMatchingCriteria9 {}


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

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

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

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

impl Validate for MasterAgreement7 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct MatchingCriteria10 {
    #[yaserde(rename = "CtrPtyMtchgCrit")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrPtyMtchgCrit"))]
    pub ctr_pty_mtchg_crit: CounterpartyMatchingCriteria4,

    #[yaserde(rename = "LnMtchgCrit")]
    #[cfg_attr(feature = "serde", serde(rename = "LnMtchgCrit"))]
    pub ln_mtchg_crit: LoanMatchingCriteria9,

    #[yaserde(rename = "CollMtchgCrit")]
    #[cfg_attr(feature = "serde", serde(rename = "CollMtchgCrit"))]
    pub coll_mtchg_crit: CollateralMatchingCriteria6,
}

impl Validate for MatchingCriteria10 {}


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.080.001.02")]
pub struct MetalCommodityNonPrecious1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType7Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType15Code,

    #[yaserde(rename = "AddtlSubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlSubPdct"))]
    pub addtl_sub_pdct: AssetClassDetailedSubProductType10Code,
}

impl Validate for MetalCommodityNonPrecious1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct MetalCommodityPrecious1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType7Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType16Code,

    #[yaserde(rename = "AddtlSubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlSubPdct"))]
    pub addtl_sub_pdct: AssetClassDetailedSubProductType11Code,
}

impl Validate for MetalCommodityPrecious1 {}


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

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

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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.080.001.02")]
pub struct NumberOfReportsPerStatus4 {
    #[yaserde(rename = "DtldNbOfRpts")]
    #[cfg_attr(feature = "serde", serde(rename = "DtldNbOfRpts"))]
    pub dtld_nb_of_rpts: Max15NumericText,

    #[yaserde(rename = "DtldSts")]
    #[cfg_attr(feature = "serde", serde(rename = "DtldSts"))]
    pub dtld_sts: PairedReconciled3Code,
}

impl Validate for NumberOfReportsPerStatus4 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
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.080.001.02")]
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.080.001.02")]
pub struct OtherC10CommodityDeliverable2 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType11Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType47Code,
}

impl Validate for OtherC10CommodityDeliverable2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct OtherC10CommodityNonDeliverable2 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType11Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType48Code,
}

impl Validate for OtherC10CommodityNonDeliverable2 {}


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

pub enum PairedReconciled3Code {
    #[yaserde(rename = "CLRC")]
    #[cfg_attr(feature = "serde", serde(rename = "CLRC"))]
    Clrc,
    #[yaserde(rename = "LNRC")]
    #[cfg_attr(feature = "serde", serde(rename = "LNRC"))]
    Lnrc,
    #[yaserde(rename = "PARD")]
    #[cfg_attr(feature = "serde", serde(rename = "PARD"))]
    Pard,
    #[yaserde(rename = "RECO")]
    #[cfg_attr(feature = "serde", serde(rename = "RECO"))]
    Reco,
    #[yaserde(rename = "UNPR")]
    #[cfg_attr(feature = "serde", serde(rename = "UNPR"))]
    Unpr,
    __Unknown__(String),
}

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

impl Validate for PairedReconciled3Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct PaperCommodityContainerBoard1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType8Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType35Code,
}

impl Validate for PaperCommodityContainerBoard1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct PaperCommodityNewsprint1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType8Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType36Code,
}

impl Validate for PaperCommodityNewsprint1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct PaperCommodityPulp1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType8Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType37Code,
}

impl Validate for PaperCommodityPulp1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct PaperCommodityRecoveredPaper1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType8Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType38Code,
}

impl Validate for PaperCommodityRecoveredPaper1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct PaperCommodityRecoveredPaper2 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType8Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType49Code,
}

impl Validate for PaperCommodityRecoveredPaper2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct PartyIdentification236Choice {
    #[yaserde(rename = "Lgl")]
    #[cfg_attr(feature = "serde", serde(rename = "Lgl"))]
    pub lgl: Option<OrganisationIdentification15Choice>,
    #[yaserde(rename = "Ntrl")]
    #[cfg_attr(feature = "serde", serde(rename = "Ntrl"))]
    pub ntrl: Option<NaturalPersonIdentification2>,
}

impl Validate for PartyIdentification236Choice {}




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

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

impl Validate for PlusOrMinusIndicator {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.080.001.02")]
pub struct PolypropyleneCommodityOther1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType9Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType49Code,
}

impl Validate for PolypropyleneCommodityOther1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct PolypropyleneCommodityPlastic1 {
    #[yaserde(rename = "BasePdct")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
    pub base_pdct: AssetClassProductType9Code,

    #[yaserde(rename = "SubPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
    pub sub_pdct: AssetClassSubProductType18Code,
}

impl Validate for PolypropyleneCommodityPlastic1 {}


#[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.080.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.080.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.080.001.02")]
pub struct ReconciliationMatchedStatus9Choice {
    #[yaserde(rename = "Mtchd")]
    #[cfg_attr(feature = "serde", serde(rename = "Mtchd"))]
    pub mtchd: Option<NoReasonCode>,
    #[yaserde(rename = "NotMtchd")]
    #[cfg_attr(feature = "serde", serde(rename = "NotMtchd"))]
    pub not_mtchd: Option<ReconciliationResult10>,
}

impl Validate for ReconciliationMatchedStatus9Choice {}




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

    #[yaserde(rename = "TxId")]
    #[cfg_attr(feature = "serde", serde(rename = "TxId"))]
    pub tx_id: TradeTransactionIdentification19,

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

    #[yaserde(rename = "RcncltnSts")]
    #[cfg_attr(feature = "serde", serde(rename = "RcncltnSts"))]
    pub rcncltn_sts: ReconciliationStatus8Choice,
}

impl Validate for ReconciliationReport8 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct ReconciliationResult10 {
    #[yaserde(rename = "CtrPty1")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrPty1"))]
    pub ctr_pty_1: OrganisationIdentification15Choice,

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

    #[yaserde(rename = "MtchgCrit")]
    #[cfg_attr(feature = "serde", serde(rename = "MtchgCrit"))]
    pub mtchg_crit: MatchingCriteria10,
}

impl Validate for ReconciliationResult10 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct ReconciliationStatus8Choice {
    #[yaserde(rename = "NoRcncltnReqrd")]
    #[cfg_attr(feature = "serde", serde(rename = "NoRcncltnReqrd"))]
    pub no_rcncltn_reqrd: Option<NoReasonCode>,
    #[yaserde(rename = "RptgData")]
    #[cfg_attr(feature = "serde", serde(rename = "RptgData"))]
    pub rptg_data: Option<ReconciliationMatchedStatus9Choice>,
}

impl Validate for ReconciliationStatus8Choice {}




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

pub enum RepoTerminationOption2Code {
    #[yaserde(rename = "EGRN")]
    #[cfg_attr(feature = "serde", serde(rename = "EGRN"))]
    Egrn,
    #[yaserde(rename = "EGAE")]
    #[cfg_attr(feature = "serde", serde(rename = "EGAE"))]
    Egae,
    #[yaserde(rename = "ETSB")]
    #[cfg_attr(feature = "serde", serde(rename = "ETSB"))]
    Etsb,
    #[yaserde(rename = "NOAP")]
    #[cfg_attr(feature = "serde", serde(rename = "NOAP"))]
    Noap,
    __Unknown__(String),
}

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

impl Validate for RepoTerminationOption2Code {}



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

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

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

impl Validate for ReportPeriodActivity1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.080.001.02")]
pub struct SecuritiesFinancingReportingReconciliationStatusAdviceV02 {
    #[yaserde(rename = "RcncltnData")]
    #[cfg_attr(feature = "serde", serde(rename = "RcncltnData"))]
    pub rcncltn_data: TradeData34Choice,

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

impl Validate for SecuritiesFinancingReportingReconciliationStatusAdviceV02 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct SecuritiesLendingType3Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ExternalSecuritiesLendingType1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max35Text>,
}

impl Validate for SecuritiesLendingType3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct SecuritiesTransactionPrice19Choice {
    #[yaserde(rename = "MntryVal")]
    #[cfg_attr(feature = "serde", serde(rename = "MntryVal"))]
    pub mntry_val: Option<AmountAndDirection107>,
    #[yaserde(rename = "Unit")]
    #[cfg_attr(feature = "serde", serde(rename = "Unit"))]
    pub unit: Option<LongFraction19DecimalNumber>,
    #[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 = "Dcml")]
    #[cfg_attr(feature = "serde", serde(rename = "Dcml"))]
    pub dcml: Option<BaseOneRate>,
    #[yaserde(rename = "PdgPric")]
    #[cfg_attr(feature = "serde", serde(rename = "PdgPric"))]
    pub pdg_pric: Option<PriceStatus1Code>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<SecuritiesTransactionPrice5>,
}

impl Validate for SecuritiesTransactionPrice19Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct SecuritiesTransactionPrice5 {
    #[yaserde(rename = "Val")]
    #[cfg_attr(feature = "serde", serde(rename = "Val"))]
    pub val: LongFraction19DecimalNumber,

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

impl Validate for SecuritiesTransactionPrice5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct Security48 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: CompareISINIdentifier4,

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

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

    #[yaserde(rename = "NmnlVal")]
    #[cfg_attr(feature = "serde", serde(rename = "NmnlVal"))]
    pub nmnl_val: CompareAmountAndDirection2,

    #[yaserde(rename = "Qlty")]
    #[cfg_attr(feature = "serde", serde(rename = "Qlty"))]
    pub qlty: CompareCollateralQualityType3,

    #[yaserde(rename = "Mtrty")]
    #[cfg_attr(feature = "serde", serde(rename = "Mtrty"))]
    pub mtrty: CompareDate3,

    #[yaserde(rename = "IssrId")]
    #[cfg_attr(feature = "serde", serde(rename = "IssrId"))]
    pub issr_id: CompareOrganisationIdentification6,

    #[yaserde(rename = "IssrCtry")]
    #[cfg_attr(feature = "serde", serde(rename = "IssrCtry"))]
    pub issr_ctry: CompareCountryCode3,

    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: Vec<CompareSecuritiesLendingType3>,

    #[yaserde(rename = "UnitPric")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitPric"))]
    pub unit_pric: CompareUnitPrice6,

    #[yaserde(rename = "ExclsvArrgmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "ExclsvArrgmnt"))]
    pub exclsv_arrgmnt: CompareTrueFalseIndicator3,

    #[yaserde(rename = "MktVal")]
    #[cfg_attr(feature = "serde", serde(rename = "MktVal"))]
    pub mkt_val: CompareAmountAndDirection2,

    #[yaserde(rename = "AvlblForCollReuse")]
    #[cfg_attr(feature = "serde", serde(rename = "AvlblForCollReuse"))]
    pub avlbl_for_coll_reuse: CompareTrueFalseIndicator3,

    #[yaserde(rename = "HrcutOrMrgn")]
    #[cfg_attr(feature = "serde", serde(rename = "HrcutOrMrgn"))]
    pub hrcut_or_mrgn: ComparePercentageRate3,
}

impl Validate for Security48 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct SecurityCommodity7Choice {
    #[yaserde(rename = "Scty")]
    #[cfg_attr(feature = "serde", serde(rename = "Scty"))]
    pub scty: Vec<Security48>,
    #[yaserde(rename = "Cmmdty")]
    #[cfg_attr(feature = "serde", serde(rename = "Cmmdty"))]
    pub cmmdty: Vec<Commodity42>,
}

impl Validate for SecurityCommodity7Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct SecurityCommodityCash4 {
    #[yaserde(rename = "Scty")]
    #[cfg_attr(feature = "serde", serde(rename = "Scty"))]
    pub scty: Vec<Security48>,

    #[yaserde(rename = "Cmmdty")]
    #[cfg_attr(feature = "serde", serde(rename = "Cmmdty"))]
    pub cmmdty: Vec<Commodity42>,

    #[yaserde(rename = "Csh")]
    #[cfg_attr(feature = "serde", serde(rename = "Csh"))]
    pub csh: Vec<CashCompare3>,
}

impl Validate for SecurityCommodityCash4 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct SecurityIdentification26Choice {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Option<Isinoct2015Identifier>,
    #[yaserde(rename = "NotAvlbl")]
    #[cfg_attr(feature = "serde", serde(rename = "NotAvlbl"))]
    pub not_avlbl: Option<NotAvailable1Code>,
}

impl Validate for SecurityIdentification26Choice {}




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

pub enum SpecialCollateral1Code {
    #[yaserde(rename = "GENE")]
    #[cfg_attr(feature = "serde", serde(rename = "GENE"))]
    Gene,
    #[yaserde(rename = "SPEC")]
    #[cfg_attr(feature = "serde", serde(rename = "SPEC"))]
    Spec,
    __Unknown__(String),
}

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

impl Validate for SpecialCollateral1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.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.080.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.080.001.02")]
pub struct TradeData28 {
    #[yaserde(rename = "PairgRcncltnSts")]
    #[cfg_attr(feature = "serde", serde(rename = "PairgRcncltnSts"))]
    pub pairg_rcncltn_sts: Vec<NumberOfReportsPerStatus4>,

    #[yaserde(rename = "RcncltnRpt")]
    #[cfg_attr(feature = "serde", serde(rename = "RcncltnRpt"))]
    pub rcncltn_rpt: Vec<ReconciliationReport8>,

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

impl Validate for TradeData28 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.080.001.02")]
pub struct TradeData34Choice {
    #[yaserde(rename = "DataSetActn")]
    #[cfg_attr(feature = "serde", serde(rename = "DataSetActn"))]
    pub data_set_actn: Option<ReportPeriodActivity1Code>,
    #[yaserde(rename = "Rpt")]
    #[cfg_attr(feature = "serde", serde(rename = "Rpt"))]
    pub rpt: Vec<TradeData28>,
}

impl Validate for TradeData34Choice {}




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

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

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

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

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

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

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

impl Validate for TradeTransactionIdentification19 {}


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

pub enum UnitOfMeasure11Code {
    #[yaserde(rename = "ALOW")]
    #[cfg_attr(feature = "serde", serde(rename = "ALOW"))]
    Alow,
    #[yaserde(rename = "ACCY")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCY"))]
    Accy,
    #[yaserde(rename = "BARL")]
    #[cfg_attr(feature = "serde", serde(rename = "BARL"))]
    Barl,
    #[yaserde(rename = "BCUF")]
    #[cfg_attr(feature = "serde", serde(rename = "BCUF"))]
    Bcuf,
    #[yaserde(rename = "BDFT")]
    #[cfg_attr(feature = "serde", serde(rename = "BDFT"))]
    Bdft,
    #[yaserde(rename = "BUSL")]
    #[cfg_attr(feature = "serde", serde(rename = "BUSL"))]
    Busl,
    #[yaserde(rename = "CEER")]
    #[cfg_attr(feature = "serde", serde(rename = "CEER"))]
    Ceer,
    #[yaserde(rename = "CLRT")]
    #[cfg_attr(feature = "serde", serde(rename = "CLRT"))]
    Clrt,
    #[yaserde(rename = "KILO")]
    #[cfg_attr(feature = "serde", serde(rename = "KILO"))]
    Kilo,
    #[yaserde(rename = "PIEC")]
    #[cfg_attr(feature = "serde", serde(rename = "PIEC"))]
    Piec,
    #[yaserde(rename = "TONS")]
    #[cfg_attr(feature = "serde", serde(rename = "TONS"))]
    Tons,
    #[yaserde(rename = "METR")]
    #[cfg_attr(feature = "serde", serde(rename = "METR"))]
    Metr,
    #[yaserde(rename = "INCH")]
    #[cfg_attr(feature = "serde", serde(rename = "INCH"))]
    Inch,
    #[yaserde(rename = "YARD")]
    #[cfg_attr(feature = "serde", serde(rename = "YARD"))]
    Yard,
    #[yaserde(rename = "GBGA")]
    #[cfg_attr(feature = "serde", serde(rename = "GBGA"))]
    Gbga,
    #[yaserde(rename = "GRAM")]
    #[cfg_attr(feature = "serde", serde(rename = "GRAM"))]
    Gram,
    #[yaserde(rename = "CMET")]
    #[cfg_attr(feature = "serde", serde(rename = "CMET"))]
    Cmet,
    #[yaserde(rename = "SMET")]
    #[cfg_attr(feature = "serde", serde(rename = "SMET"))]
    Smet,
    #[yaserde(rename = "FOOT")]
    #[cfg_attr(feature = "serde", serde(rename = "FOOT"))]
    Foot,
    #[yaserde(rename = "MILE")]
    #[cfg_attr(feature = "serde", serde(rename = "MILE"))]
    Mile,
    #[yaserde(rename = "SQIN")]
    #[cfg_attr(feature = "serde", serde(rename = "SQIN"))]
    Sqin,
    #[yaserde(rename = "SQFO")]
    #[cfg_attr(feature = "serde", serde(rename = "SQFO"))]
    Sqfo,
    #[yaserde(rename = "SQMI")]
    #[cfg_attr(feature = "serde", serde(rename = "SQMI"))]
    Sqmi,
    #[yaserde(rename = "GBOU")]
    #[cfg_attr(feature = "serde", serde(rename = "GBOU"))]
    Gbou,
    #[yaserde(rename = "USOU")]
    #[cfg_attr(feature = "serde", serde(rename = "USOU"))]
    Usou,
    #[yaserde(rename = "GBPI")]
    #[cfg_attr(feature = "serde", serde(rename = "GBPI"))]
    Gbpi,
    #[yaserde(rename = "USPI")]
    #[cfg_attr(feature = "serde", serde(rename = "USPI"))]
    Uspi,
    #[yaserde(rename = "GBQA")]
    #[cfg_attr(feature = "serde", serde(rename = "GBQA"))]
    Gbqa,
    #[yaserde(rename = "USGA")]
    #[cfg_attr(feature = "serde", serde(rename = "USGA"))]
    Usga,
    #[yaserde(rename = "MMET")]
    #[cfg_attr(feature = "serde", serde(rename = "MMET"))]
    Mmet,
    #[yaserde(rename = "KMET")]
    #[cfg_attr(feature = "serde", serde(rename = "KMET"))]
    Kmet,
    #[yaserde(rename = "SQYA")]
    #[cfg_attr(feature = "serde", serde(rename = "SQYA"))]
    Sqya,
    #[yaserde(rename = "ACRE")]
    #[cfg_attr(feature = "serde", serde(rename = "ACRE"))]
    Acre,
    #[yaserde(rename = "ARES")]
    #[cfg_attr(feature = "serde", serde(rename = "ARES"))]
    Ares,
    #[yaserde(rename = "SMIL")]
    #[cfg_attr(feature = "serde", serde(rename = "SMIL"))]
    Smil,
    #[yaserde(rename = "SCMT")]
    #[cfg_attr(feature = "serde", serde(rename = "SCMT"))]
    Scmt,
    #[yaserde(rename = "HECT")]
    #[cfg_attr(feature = "serde", serde(rename = "HECT"))]
    Hect,
    #[yaserde(rename = "SQKI")]
    #[cfg_attr(feature = "serde", serde(rename = "SQKI"))]
    Sqki,
    #[yaserde(rename = "MILI")]
    #[cfg_attr(feature = "serde", serde(rename = "MILI"))]
    Mili,
    #[yaserde(rename = "CELI")]
    #[cfg_attr(feature = "serde", serde(rename = "CELI"))]
    Celi,
    #[yaserde(rename = "LITR")]
    #[cfg_attr(feature = "serde", serde(rename = "LITR"))]
    Litr,
    #[yaserde(rename = "PUND")]
    #[cfg_attr(feature = "serde", serde(rename = "PUND"))]
    Pund,
    #[yaserde(rename = "CBME")]
    #[cfg_attr(feature = "serde", serde(rename = "CBME"))]
    Cbme,
    #[yaserde(rename = "DAYS")]
    #[cfg_attr(feature = "serde", serde(rename = "DAYS"))]
    Days,
    #[yaserde(rename = "DMET")]
    #[cfg_attr(feature = "serde", serde(rename = "DMET"))]
    Dmet,
    #[yaserde(rename = "ENVC")]
    #[cfg_attr(feature = "serde", serde(rename = "ENVC"))]
    Envc,
    #[yaserde(rename = "ENVO")]
    #[cfg_attr(feature = "serde", serde(rename = "ENVO"))]
    Envo,
    #[yaserde(rename = "HUWG")]
    #[cfg_attr(feature = "serde", serde(rename = "HUWG"))]
    Huwg,
    #[yaserde(rename = "KWDC")]
    #[cfg_attr(feature = "serde", serde(rename = "KWDC"))]
    Kwdc,
    #[yaserde(rename = "KWHO")]
    #[cfg_attr(feature = "serde", serde(rename = "KWHO"))]
    Kwho,
    #[yaserde(rename = "KWHC")]
    #[cfg_attr(feature = "serde", serde(rename = "KWHC"))]
    Kwhc,
    #[yaserde(rename = "KMOC")]
    #[cfg_attr(feature = "serde", serde(rename = "KMOC"))]
    Kmoc,
    #[yaserde(rename = "KWMC")]
    #[cfg_attr(feature = "serde", serde(rename = "KWMC"))]
    Kwmc,
    #[yaserde(rename = "KWYC")]
    #[cfg_attr(feature = "serde", serde(rename = "KWYC"))]
    Kwyc,
    #[yaserde(rename = "MWDC")]
    #[cfg_attr(feature = "serde", serde(rename = "MWDC"))]
    Mwdc,
    #[yaserde(rename = "MWHO")]
    #[cfg_attr(feature = "serde", serde(rename = "MWHO"))]
    Mwho,
    #[yaserde(rename = "MWHC")]
    #[cfg_attr(feature = "serde", serde(rename = "MWHC"))]
    Mwhc,
    #[yaserde(rename = "MWMC")]
    #[cfg_attr(feature = "serde", serde(rename = "MWMC"))]
    Mwmc,
    #[yaserde(rename = "MMOC")]
    #[cfg_attr(feature = "serde", serde(rename = "MMOC"))]
    Mmoc,
    #[yaserde(rename = "MWYC")]
    #[cfg_attr(feature = "serde", serde(rename = "MWYC"))]
    Mwyc,
    #[yaserde(rename = "TONE")]
    #[cfg_attr(feature = "serde", serde(rename = "TONE"))]
    Tone,
    #[yaserde(rename = "MIBA")]
    #[cfg_attr(feature = "serde", serde(rename = "MIBA"))]
    Miba,
    #[yaserde(rename = "MBTU")]
    #[cfg_attr(feature = "serde", serde(rename = "MBTU"))]
    Mbtu,
    #[yaserde(rename = "OZTR")]
    #[cfg_attr(feature = "serde", serde(rename = "OZTR"))]
    Oztr,
    #[yaserde(rename = "UCWT")]
    #[cfg_attr(feature = "serde", serde(rename = "UCWT"))]
    Ucwt,
    #[yaserde(rename = "IPNT")]
    #[cfg_attr(feature = "serde", serde(rename = "IPNT"))]
    Ipnt,
    #[yaserde(rename = "PWRD")]
    #[cfg_attr(feature = "serde", serde(rename = "PWRD"))]
    Pwrd,
    #[yaserde(rename = "DGEU")]
    #[cfg_attr(feature = "serde", serde(rename = "DGEU"))]
    Dgeu,
    #[yaserde(rename = "TOCD")]
    #[cfg_attr(feature = "serde", serde(rename = "TOCD"))]
    Tocd,
    #[yaserde(rename = "GGEU")]
    #[cfg_attr(feature = "serde", serde(rename = "GGEU"))]
    Ggeu,
    #[yaserde(rename = "USQA")]
    #[cfg_attr(feature = "serde", serde(rename = "USQA"))]
    Usqa,
    __Unknown__(String),
}

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

impl Validate for UnitOfMeasure11Code {}

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