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

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

impl Validate for AmountAndDirection53 {}


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

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

impl Validate for AmountHaircutMargin1 {}


#[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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.079.001.02")]
pub struct Branch5Choice {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Option<OrganisationIdentification15Choice>,
    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: Option<CountryCode>,
}

impl Validate for Branch5Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.079.001.02")]
pub struct Branch6Choice {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Option<PartyIdentification236Choice>,
    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: Option<CountryCode>,
}

impl Validate for Branch6Choice {}




#[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.079.001.02")]
pub struct Cleared16Choice {
    #[yaserde(rename = "Clrd")]
    #[cfg_attr(feature = "serde", serde(rename = "Clrd"))]
    pub clrd: Option<ClearingPartyAndTime14>,
    #[yaserde(rename = "NonClrd")]
    #[cfg_attr(feature = "serde", serde(rename = "NonClrd"))]
    pub non_clrd: Option<NoReasonCode>,
}

impl Validate for Cleared16Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.079.001.02")]
pub struct ClearingPartyAndTime14 {
    #[yaserde(rename = "CCP")]
    #[cfg_attr(feature = "serde", serde(rename = "CCP"))]
    pub ccp: OrganisationIdentification15Choice,

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

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

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

impl Validate for ClearingPartyAndTime14 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.079.001.02")]
pub struct Collateral52 {
    #[yaserde(rename = "CollValDt")]
    #[cfg_attr(feature = "serde", serde(rename = "CollValDt"))]
    pub coll_val_dt: Isodate,

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

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

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

impl Validate for Collateral52 {}


#[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.079.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.079.001.02")]
pub struct CollateralFlag13Choice {
    #[yaserde(rename = "Collsd")]
    #[cfg_attr(feature = "serde", serde(rename = "Collsd"))]
    pub collsd: Option<CollaterisedData12>,
    #[yaserde(rename = "Uncollsd")]
    #[cfg_attr(feature = "serde", serde(rename = "Uncollsd"))]
    pub uncollsd: Option<NoReasonCode>,
}

impl Validate for CollateralFlag13Choice {}




#[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.079.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.079.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.079.001.02")]
pub struct CollateralType21 {
    #[yaserde(rename = "Scty")]
    #[cfg_attr(feature = "serde", serde(rename = "Scty"))]
    pub scty: Vec<Security52>,

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

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

impl Validate for CollateralType21 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.079.001.02")]
pub struct CollaterisedData12 {
    #[yaserde(rename = "CollValDt")]
    #[cfg_attr(feature = "serde", serde(rename = "CollValDt"))]
    pub coll_val_dt: Isodate,

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

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

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

impl Validate for CollaterisedData12 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.079.001.02")]
pub struct Commodity43 {
    #[yaserde(rename = "Clssfctn")]
    #[cfg_attr(feature = "serde", serde(rename = "Clssfctn"))]
    pub clssfctn: AssetClassCommodity5Choice,

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

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

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

impl Validate for Commodity43 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.079.001.02")]
pub struct ContractModification3 {
    #[yaserde(rename = "ActnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ActnTp"))]
    pub actn_tp: TransactionOperationType6Code,

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

impl Validate for ContractModification3 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.079.001.02")]
pub struct ContractTerm7Choice {
    #[yaserde(rename = "Opn")]
    #[cfg_attr(feature = "serde", serde(rename = "Opn"))]
    pub opn: Option<FixedOpenTermContract2>,
    #[yaserde(rename = "Fxd")]
    #[cfg_attr(feature = "serde", serde(rename = "Fxd"))]
    pub fxd: Option<FixedOpenTermContract2>,
}

impl Validate for ContractTerm7Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.079.001.02")]
pub struct CounterpartyData88 {
    #[yaserde(rename = "RptgDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "RptgDtTm"))]
    pub rptg_dt_tm: IsodateTime,

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

    #[yaserde(rename = "CtrPty")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrPty"))]
    pub ctr_pty: Vec<CounterpartyData89>,
}

impl Validate for CounterpartyData88 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.079.001.02")]
pub struct CounterpartyData89 {
    #[yaserde(rename = "RptgCtrPty")]
    #[cfg_attr(feature = "serde", serde(rename = "RptgCtrPty"))]
    pub rptg_ctr_pty: CounterpartyIdentification11,

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

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

    #[yaserde(rename = "OthrPtyData")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrPtyData"))]
    pub othr_pty_data: TransactionCounterpartyData11,
}

impl Validate for CounterpartyData89 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.079.001.02")]
pub struct CounterpartyIdentification11 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: OrganisationIdentification15Choice,

    #[yaserde(rename = "Ntr")]
    #[cfg_attr(feature = "serde", serde(rename = "Ntr"))]
    pub ntr: CounterpartyTradeNature7Choice,

    #[yaserde(rename = "Brnch")]
    #[cfg_attr(feature = "serde", serde(rename = "Brnch"))]
    pub brnch: Branch5Choice,

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

impl Validate for CounterpartyIdentification11 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.079.001.02")]
pub struct CounterpartyIdentification12 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: PartyIdentification236Choice,

    #[yaserde(rename = "Brnch")]
    #[cfg_attr(feature = "serde", serde(rename = "Brnch"))]
    pub brnch: Branch6Choice,

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

impl Validate for CounterpartyIdentification12 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.079.001.02")]
pub struct CounterpartyTradeNature7Choice {
    #[yaserde(rename = "FI")]
    #[cfg_attr(feature = "serde", serde(rename = "FI"))]
    pub fi: Option<FinancialPartyClassification1>,
    #[yaserde(rename = "NFI")]
    #[cfg_attr(feature = "serde", serde(rename = "NFI"))]
    pub nfi: Vec<FinancialPartyClassification2>,
}

impl Validate for CounterpartyTradeNature7Choice {}




#[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.079.001.02")]
pub struct Document {
    #[yaserde(rename = "SctiesFincgRptgTxStatRpt")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesFincgRptgTxStatRpt"))]
    pub scties_fincg_rptg_tx_stat_rpt: SecuritiesFinancingReportingTransactionStateReportV02,
}

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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.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(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.079.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.079.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.079.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.079.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.079.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.079.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.079.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.079.001.02")]
pub struct FinancialPartyClassification1 {
    #[yaserde(rename = "Clssfctn")]
    #[cfg_attr(feature = "serde", serde(rename = "Clssfctn"))]
    pub clssfctn: Vec<FinancialPartySectorType2Code>,

    #[yaserde(rename = "InvstmtFndClssfctn")]
    #[cfg_attr(feature = "serde", serde(rename = "InvstmtFndClssfctn"))]
    pub invstmt_fnd_clssfctn: FundType2Code,
}

impl Validate for FinancialPartyClassification1 {}


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

    #[yaserde(rename = "InvstmtFndClssfctn")]
    #[cfg_attr(feature = "serde", serde(rename = "InvstmtFndClssfctn"))]
    pub invstmt_fnd_clssfctn: FundType2Code,
}

impl Validate for FinancialPartyClassification2 {}


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

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

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

impl Validate for FinancialPartySectorType2Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.079.001.02")]
pub struct FixedOpenTermContract2 {
    #[yaserde(rename = "MtrtyDt")]
    #[cfg_attr(feature = "serde", serde(rename = "MtrtyDt"))]
    pub mtrty_dt: Isodate,

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

impl Validate for FixedOpenTermContract2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.079.001.02")]
pub struct FixedRate11 {
    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: PercentageRate,

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

impl Validate for FixedRate11 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.079.001.02")]
pub struct FloatingInterestRate22 {
    #[yaserde(rename = "RefRate")]
    #[cfg_attr(feature = "serde", serde(rename = "RefRate"))]
    pub ref_rate: BenchmarkCurveName10Choice,

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

    #[yaserde(rename = "PmtFrqcy")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtFrqcy"))]
    pub pmt_frqcy: InterestRateContractTerm2,

    #[yaserde(rename = "RstFrqcy")]
    #[cfg_attr(feature = "serde", serde(rename = "RstFrqcy"))]
    pub rst_frqcy: InterestRateContractTerm2,

    #[yaserde(rename = "Sprd")]
    #[cfg_attr(feature = "serde", serde(rename = "Sprd"))]
    pub sprd: SecuritiesTransactionPrice18Choice,

    #[yaserde(rename = "RateAdjstmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "RateAdjstmnt"))]
    pub rate_adjstmnt: Vec<RateAdjustment1>,

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

impl Validate for FloatingInterestRate22 {}


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

pub enum FundType2Code {
    #[yaserde(rename = "ETFT")]
    #[cfg_attr(feature = "serde", serde(rename = "ETFT"))]
    Etft,
    #[yaserde(rename = "MMFT")]
    #[cfg_attr(feature = "serde", serde(rename = "MMFT"))]
    Mmft,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "REIT")]
    #[cfg_attr(feature = "serde", serde(rename = "REIT"))]
    Reit,
    __Unknown__(String),
}

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

impl Validate for FundType2Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.079.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.079.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.079.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.079.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.079.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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.079.001.02")]
pub struct InterestRate27Choice {
    #[yaserde(rename = "Fxd")]
    #[cfg_attr(feature = "serde", serde(rename = "Fxd"))]
    pub fxd: Option<FixedRate11>,
    #[yaserde(rename = "Fltg")]
    #[cfg_attr(feature = "serde", serde(rename = "Fltg"))]
    pub fltg: Option<FloatingInterestRate22>,
}

impl Validate for InterestRate27Choice {}




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

    #[yaserde(rename = "IntrstRate")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstRate"))]
    pub intrst_rate: InterestRate27Choice,
}

impl Validate for InterestRate6 {}


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

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

impl Validate for InterestRateContractTerm2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(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.079.001.02")]
pub struct LoanData139 {
    #[yaserde(rename = "UnqTradIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "UnqTradIdr"))]
    pub unq_trad_idr: Max52Text,

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

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

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

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

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

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

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

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

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

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

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

    #[yaserde(rename = "Term")]
    #[cfg_attr(feature = "serde", serde(rename = "Term"))]
    pub term: Vec<ContractTerm7Choice>,

    #[yaserde(rename = "IntrstRate")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstRate"))]
    pub intrst_rate: InterestRate27Choice,

    #[yaserde(rename = "PrncplAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "PrncplAmt"))]
    pub prncpl_amt: PrincipalAmount3,

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

impl Validate for LoanData139 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.079.001.02")]
pub struct LoanData140 {
    #[yaserde(rename = "UnqTradIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "UnqTradIdr"))]
    pub unq_trad_idr: Max52Text,

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

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

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

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

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

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

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

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

    #[yaserde(rename = "PrncplAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "PrncplAmt"))]
    pub prncpl_amt: PrincipalAmount3,

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

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

impl Validate for LoanData140 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.079.001.02")]
pub struct LoanData141 {
    #[yaserde(rename = "UnqTradIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "UnqTradIdr"))]
    pub unq_trad_idr: Max52Text,

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

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

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

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

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

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

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

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

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

    #[yaserde(rename = "Term")]
    #[cfg_attr(feature = "serde", serde(rename = "Term"))]
    pub term: Vec<ContractTerm7Choice>,

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

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

    #[yaserde(rename = "RbtRate")]
    #[cfg_attr(feature = "serde", serde(rename = "RbtRate"))]
    pub rbt_rate: InterestRate27Choice,

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

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

impl Validate for LoanData141 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.079.001.02")]
pub struct LoanData142 {
    #[yaserde(rename = "UnqTradIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "UnqTradIdr"))]
    pub unq_trad_idr: Max52Text,

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

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

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

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

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

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

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

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

impl Validate for LoanData142 {}


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Validate for PrincipalAmount3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.079.001.02")]
pub struct Quantity17 {
    #[yaserde(rename = "Val")]
    #[cfg_attr(feature = "serde", serde(rename = "Val"))]
    pub val: DecimalNumber,

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

impl Validate for Quantity17 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.079.001.02")]
pub struct QuantityNominalValue2Choice {
    #[yaserde(rename = "Qty")]
    #[cfg_attr(feature = "serde", serde(rename = "Qty"))]
    pub qty: Option<DecimalNumber>,
    #[yaserde(rename = "NmnlVal")]
    #[cfg_attr(feature = "serde", serde(rename = "NmnlVal"))]
    pub nmnl_val: Option<AmountAndDirection53>,
}

impl Validate for QuantityNominalValue2Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.079.001.02")]
pub struct RateAdjustment1 {
    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: PercentageRate,

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

impl Validate for RateAdjustment1 {}


#[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.079.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.079.001.02")]
pub struct ReconciliationFlag2 {
    #[yaserde(rename = "RptTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RptTp"))]
    pub rpt_tp: TradeRepositoryReportingType1Code,

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

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

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

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

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

impl Validate for ReconciliationFlag2 {}


#[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.079.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.079.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.079.001.02")]
pub struct SecuritiesFinancingReportingTransactionStateReportV02 {
    #[yaserde(rename = "TradData")]
    #[cfg_attr(feature = "serde", serde(rename = "TradData"))]
    pub trad_data: TradeStateReport5Choice,

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

impl Validate for SecuritiesFinancingReportingTransactionStateReportV02 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.079.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.079.001.02")]
pub struct SecuritiesTransactionPrice18Choice {
    #[yaserde(rename = "MntryVal")]
    #[cfg_attr(feature = "serde", serde(rename = "MntryVal"))]
    pub mntry_val: Option<AmountAndDirection107>,
    #[yaserde(rename = "Pctg")]
    #[cfg_attr(feature = "serde", serde(rename = "Pctg"))]
    pub pctg: Option<PercentageRate>,
    #[yaserde(rename = "Dcml")]
    #[cfg_attr(feature = "serde", serde(rename = "Dcml"))]
    pub dcml: Option<BaseOneRate>,
    #[yaserde(rename = "BsisPts")]
    #[cfg_attr(feature = "serde", serde(rename = "BsisPts"))]
    pub bsis_pts: Option<DecimalNumber>,
}

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

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

    #[yaserde(rename = "QtyOrNmnlVal")]
    #[cfg_attr(feature = "serde", serde(rename = "QtyOrNmnlVal"))]
    pub qty_or_nmnl_val: QuantityNominalValue2Choice,

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

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

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

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

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

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

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

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

impl Validate for Security51 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.079.001.02")]
pub struct Security52 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Isinoct2015Identifier,

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

    #[yaserde(rename = "QtyOrNmnlVal")]
    #[cfg_attr(feature = "serde", serde(rename = "QtyOrNmnlVal"))]
    pub qty_or_nmnl_val: QuantityNominalValue2Choice,

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

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

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

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

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

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

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

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

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

impl Validate for Security52 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.079.001.02")]
pub struct Security55 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Isinoct2015Identifier,

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

    #[yaserde(rename = "QtyOrNmnlVal")]
    #[cfg_attr(feature = "serde", serde(rename = "QtyOrNmnlVal"))]
    pub qty_or_nmnl_val: QuantityNominalValue2Choice,

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

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

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

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

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

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

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

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

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

impl Validate for Security55 {}


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

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

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

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

impl Validate for SecurityIssuer4 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.079.001.02")]
pub struct SettlementParties34Choice {
    #[yaserde(rename = "CntrlSctiesDpstryPtcpt")]
    #[cfg_attr(feature = "serde", serde(rename = "CntrlSctiesDpstryPtcpt"))]
    pub cntrl_scties_dpstry_ptcpt: Option<OrganisationIdentification15Choice>,
    #[yaserde(rename = "IndrctPtcpt")]
    #[cfg_attr(feature = "serde", serde(rename = "IndrctPtcpt"))]
    pub indrct_ptcpt: Option<OrganisationIdentification15Choice>,
}

impl Validate for SettlementParties34Choice {}




#[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.079.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.079.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.079.001.02")]
pub struct SupplementaryDataEnvelope1 {}

impl Validate for SupplementaryDataEnvelope1 {}


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

pub enum TradeRepositoryReportingType1Code {
    #[yaserde(rename = "SWOS")]
    #[cfg_attr(feature = "serde", serde(rename = "SWOS"))]
    Swos,
    #[yaserde(rename = "TWOS")]
    #[cfg_attr(feature = "serde", serde(rename = "TWOS"))]
    Twos,
    __Unknown__(String),
}

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

impl Validate for TradeRepositoryReportingType1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.079.001.02")]
pub struct TradeStateReport16 {
    #[yaserde(rename = "TechRcrdId")]
    #[cfg_attr(feature = "serde", serde(rename = "TechRcrdId"))]
    pub tech_rcrd_id: Max140Text,

    #[yaserde(rename = "CtrPtySpcfcData")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrPtySpcfcData"))]
    pub ctr_pty_spcfc_data: CounterpartyData88,

    #[yaserde(rename = "LnData")]
    #[cfg_attr(feature = "serde", serde(rename = "LnData"))]
    pub ln_data: TransactionLoanData31Choice,

    #[yaserde(rename = "CollData")]
    #[cfg_attr(feature = "serde", serde(rename = "CollData"))]
    pub coll_data: TransactionCollateralData18Choice,

    #[yaserde(rename = "RcncltnFlg")]
    #[cfg_attr(feature = "serde", serde(rename = "RcncltnFlg"))]
    pub rcncltn_flg: ReconciliationFlag2,

    #[yaserde(rename = "CtrctMod")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrctMod"))]
    pub ctrct_mod: ContractModification3,

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

impl Validate for TradeStateReport16 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.079.001.02")]
pub struct TradeStateReport5Choice {
    #[yaserde(rename = "DataSetActn")]
    #[cfg_attr(feature = "serde", serde(rename = "DataSetActn"))]
    pub data_set_actn: Option<ReportPeriodActivity1Code>,
    #[yaserde(rename = "Stat")]
    #[cfg_attr(feature = "serde", serde(rename = "Stat"))]
    pub stat: Vec<TradeStateReport16>,
}

impl Validate for TradeStateReport5Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.079.001.02")]
pub struct TransactionCollateralData18Choice {
    #[yaserde(rename = "RpTrad")]
    #[cfg_attr(feature = "serde", serde(rename = "RpTrad"))]
    pub rp_trad: Option<Collateral52>,
    #[yaserde(rename = "BuySellBck")]
    #[cfg_attr(feature = "serde", serde(rename = "BuySellBck"))]
    pub buy_sell_bck: Option<Collateral52>,
    #[yaserde(rename = "SctiesLndg")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesLndg"))]
    pub scties_lndg: Option<CollateralFlag13Choice>,
    #[yaserde(rename = "MrgnLndg")]
    #[cfg_attr(feature = "serde", serde(rename = "MrgnLndg"))]
    pub mrgn_lndg: Vec<Security55>,
}

impl Validate for TransactionCollateralData18Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.079.001.02")]
pub struct TransactionCounterpartyData11 {
    #[yaserde(rename = "Bnfcry")]
    #[cfg_attr(feature = "serde", serde(rename = "Bnfcry"))]
    pub bnfcry: PartyIdentification236Choice,

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

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

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

    #[yaserde(rename = "SttlmPties")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmPties"))]
    pub sttlm_pties: SettlementParties34Choice,

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

impl Validate for TransactionCounterpartyData11 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.079.001.02")]
pub struct TransactionLoanData31Choice {
    #[yaserde(rename = "RpTrad")]
    #[cfg_attr(feature = "serde", serde(rename = "RpTrad"))]
    pub rp_trad: Option<LoanData139>,
    #[yaserde(rename = "BuySellBck")]
    #[cfg_attr(feature = "serde", serde(rename = "BuySellBck"))]
    pub buy_sell_bck: Option<LoanData140>,
    #[yaserde(rename = "SctiesLndg")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesLndg"))]
    pub scties_lndg: Option<LoanData141>,
    #[yaserde(rename = "MrgnLndg")]
    #[cfg_attr(feature = "serde", serde(rename = "MrgnLndg"))]
    pub mrgn_lndg: Option<LoanData142>,
}

impl Validate for TransactionLoanData31Choice {}




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

pub enum TransactionOperationType6Code {
    #[yaserde(rename = "REUU")]
    #[cfg_attr(feature = "serde", serde(rename = "REUU"))]
    Reuu,
    #[yaserde(rename = "COLU")]
    #[cfg_attr(feature = "serde", serde(rename = "COLU"))]
    Colu,
    #[yaserde(rename = "CORR")]
    #[cfg_attr(feature = "serde", serde(rename = "CORR"))]
    Corr,
    #[yaserde(rename = "ETRM")]
    #[cfg_attr(feature = "serde", serde(rename = "ETRM"))]
    Etrm,
    #[yaserde(rename = "VALU")]
    #[cfg_attr(feature = "serde", serde(rename = "VALU"))]
    Valu,
    #[yaserde(rename = "POSC")]
    #[cfg_attr(feature = "serde", serde(rename = "POSC"))]
    Posc,
    #[yaserde(rename = "NEWT")]
    #[cfg_attr(feature = "serde", serde(rename = "NEWT"))]
    Newt,
    #[yaserde(rename = "MODI")]
    #[cfg_attr(feature = "serde", serde(rename = "MODI"))]
    Modi,
    #[yaserde(rename = "MARU")]
    #[cfg_attr(feature = "serde", serde(rename = "MARU"))]
    Maru,
    #[yaserde(rename = "EROR")]
    #[cfg_attr(feature = "serde", serde(rename = "EROR"))]
    Eror,
    __Unknown__(String),
}

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

impl Validate for TransactionOperationType6Code {}



#[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.079.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 = "079";
    const VARIANT: &'static str = "001";
    const VERSION: &'static str = "02";
    const MESSAGE_NAME: &'static str = "auth.079.001.02";
    const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:auth.079.001.02";
}