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

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

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

impl Validate for ActiveCurrencyAnd13DecimalAmount {}


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

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

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

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

impl Validate for AgriculturalCommodityGrain1 {}


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

impl Validate for AgriculturalCommodityOliveOil1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.036.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.036.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.036.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.036.001.02")]
pub struct AmountAndDirection61 {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: ActiveCurrencyAnd13DecimalAmount,

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

impl Validate for AmountAndDirection61 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.036.001.02")]
pub struct AssetClass2 {
    #[yaserde(rename = "Cmmdty")]
    #[cfg_attr(feature = "serde", serde(rename = "Cmmdty"))]
    pub cmmdty: DerivativeCommodity2,

    #[yaserde(rename = "Intrst")]
    #[cfg_attr(feature = "serde", serde(rename = "Intrst"))]
    pub intrst: DerivativeInterest3,

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

impl Validate for AssetClass2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.036.001.02")]
pub struct AssetClassCommodity3Choice {
    #[yaserde(rename = "Agrcltrl")]
    #[cfg_attr(feature = "serde", serde(rename = "Agrcltrl"))]
    pub agrcltrl: Option<AssetClassCommodityAgricultural1Choice>,
    #[yaserde(rename = "Nrgy")]
    #[cfg_attr(feature = "serde", serde(rename = "Nrgy"))]
    pub nrgy: Option<AssetClassCommodityEnergy1Choice>,
    #[yaserde(rename = "Envttl")]
    #[cfg_attr(feature = "serde", serde(rename = "Envttl"))]
    pub envttl: Option<AssetClassCommodityEnvironmental1Choice>,
    #[yaserde(rename = "Frtlzr")]
    #[cfg_attr(feature = "serde", serde(rename = "Frtlzr"))]
    pub frtlzr: Option<AssetClassCommodityFertilizer1Choice>,
    #[yaserde(rename = "Frght")]
    #[cfg_attr(feature = "serde", serde(rename = "Frght"))]
    pub frght: Option<AssetClassCommodityFreight1Choice>,
    #[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<AssetClassCommodityPaper1Choice>,
    #[yaserde(rename = "Plprpln")]
    #[cfg_attr(feature = "serde", serde(rename = "Plprpln"))]
    pub plprpln: Option<AssetClassCommodityPolypropylene1Choice>,
    #[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 AssetClassCommodity3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.036.001.02")]
pub struct AssetClassCommodityAgricultural1Choice {
    #[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<AgriculturalCommodityOliveOil1>,
    #[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<AgriculturalCommodityGrain1>,
}

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

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

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

impl Validate for AssetClassCommodityFertilizer1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.036.001.02")]
pub struct AssetClassCommodityFreight1Choice {
    #[yaserde(rename = "Dry")]
    #[cfg_attr(feature = "serde", serde(rename = "Dry"))]
    pub dry: Option<FreightCommodityDry1>,
    #[yaserde(rename = "Wet")]
    #[cfg_attr(feature = "serde", serde(rename = "Wet"))]
    pub wet: Option<FreightCommodityWet1>,
    #[yaserde(rename = "CntnrShip")]
    #[cfg_attr(feature = "serde", serde(rename = "CntnrShip"))]
    pub cntnr_ship: Option<FreightCommodityContainerShip1>,
}

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

impl Validate for AssetClassCommodityPaper1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.036.001.02")]
pub struct AssetClassCommodityPolypropylene1Choice {
    #[yaserde(rename = "Plstc")]
    #[cfg_attr(feature = "serde", serde(rename = "Plstc"))]
    pub plstc: Option<PolypropyleneCommodityPlastic1>,
}

impl Validate for AssetClassCommodityPolypropylene1Choice {}




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

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

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

impl Validate for AssetClassDetailedSubProductType12Code {}



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

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

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

impl Validate for AssetClassDetailedSubProductType14Code {}



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

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

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

impl Validate for AssetClassDetailedSubProductType15Code {}



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

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

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

impl Validate for AssetClassDetailedSubProductType4Code {}



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

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

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

impl Validate for AssetClassDetailedSubProductType6Code {}



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

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

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

impl Validate for AssetClassDetailedSubProductType7Code {}



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

pub enum AssetClassTransactionType1Code {
    #[yaserde(rename = "CRCK")]
    #[cfg_attr(feature = "serde", serde(rename = "CRCK"))]
    Crck,
    #[yaserde(rename = "DIFF")]
    #[cfg_attr(feature = "serde", serde(rename = "DIFF"))]
    Diff,
    #[yaserde(rename = "FUTR")]
    #[cfg_attr(feature = "serde", serde(rename = "FUTR"))]
    Futr,
    #[yaserde(rename = "MINI")]
    #[cfg_attr(feature = "serde", serde(rename = "MINI"))]
    Mini,
    #[yaserde(rename = "OPTN")]
    #[cfg_attr(feature = "serde", serde(rename = "OPTN"))]
    Optn,
    #[yaserde(rename = "OTCT")]
    #[cfg_attr(feature = "serde", serde(rename = "OTCT"))]
    Otct,
    #[yaserde(rename = "ORIT")]
    #[cfg_attr(feature = "serde", serde(rename = "ORIT"))]
    Orit,
    #[yaserde(rename = "SWAP")]
    #[cfg_attr(feature = "serde", serde(rename = "SWAP"))]
    Swap,
    #[yaserde(rename = "TAPO")]
    #[cfg_attr(feature = "serde", serde(rename = "TAPO"))]
    Tapo,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    __Unknown__(String),
}

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

impl Validate for AssetClassTransactionType1Code {}



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

pub enum AssetFXSubProductType1Code {
    #[yaserde(rename = "FXCR")]
    #[cfg_attr(feature = "serde", serde(rename = "FXCR"))]
    Fxcr,
    #[yaserde(rename = "FXEM")]
    #[cfg_attr(feature = "serde", serde(rename = "FXEM"))]
    Fxem,
    #[yaserde(rename = "FXMJ")]
    #[cfg_attr(feature = "serde", serde(rename = "FXMJ"))]
    Fxmj,
    __Unknown__(String),
}

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

impl Validate for AssetFXSubProductType1Code {}



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

pub enum AssetPriceType1Code {
    #[yaserde(rename = "ARGM")]
    #[cfg_attr(feature = "serde", serde(rename = "ARGM"))]
    Argm,
    #[yaserde(rename = "BLTC")]
    #[cfg_attr(feature = "serde", serde(rename = "BLTC"))]
    Bltc,
    #[yaserde(rename = "EXOF")]
    #[cfg_attr(feature = "serde", serde(rename = "EXOF"))]
    Exof,
    #[yaserde(rename = "GBCL")]
    #[cfg_attr(feature = "serde", serde(rename = "GBCL"))]
    Gbcl,
    #[yaserde(rename = "IHSM")]
    #[cfg_attr(feature = "serde", serde(rename = "IHSM"))]
    Ihsm,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "PLAT")]
    #[cfg_attr(feature = "serde", serde(rename = "PLAT"))]
    Plat,
    __Unknown__(String),
}

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

impl Validate for AssetPriceType1Code {}



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

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

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

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

impl Validate for BenchmarkCurveName5Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.036.001.02")]
pub struct BenchmarkCurveName6Choice {
    #[yaserde(rename = "ISIN")]
    #[cfg_attr(feature = "serde", serde(rename = "ISIN"))]
    pub isin: Option<Isinoct2015Identifier>,
    #[yaserde(rename = "Indx")]
    #[cfg_attr(feature = "serde", serde(rename = "Indx"))]
    pub indx: Option<BenchmarkCurveName2Code>,
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Option<Max25Text>,
}

impl Validate for BenchmarkCurveName6Choice {}




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

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

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

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

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

    #[yaserde(rename = "DebtSnrty")]
    #[cfg_attr(feature = "serde", serde(rename = "DebtSnrty"))]
    pub debt_snrty: DebtInstrumentSeniorityType1Code,
}

impl Validate for DebtInstrument2 {}


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

pub enum DebtInstrumentSeniorityType1Code {
    #[yaserde(rename = "SBOD")]
    #[cfg_attr(feature = "serde", serde(rename = "SBOD"))]
    Sbod,
    #[yaserde(rename = "SNDB")]
    #[cfg_attr(feature = "serde", serde(rename = "SNDB"))]
    Sndb,
    #[yaserde(rename = "MZZD")]
    #[cfg_attr(feature = "serde", serde(rename = "MZZD"))]
    Mzzd,
    #[yaserde(rename = "JUND")]
    #[cfg_attr(feature = "serde", serde(rename = "JUND"))]
    Jund,
    __Unknown__(String),
}

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

impl Validate for DebtInstrumentSeniorityType1Code {}



#[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.036.001.02")]
pub struct DerivativeCommodity2 {
    #[yaserde(rename = "Pdct")]
    #[cfg_attr(feature = "serde", serde(rename = "Pdct"))]
    pub pdct: AssetClassCommodity3Choice,

    #[yaserde(rename = "TxTp")]
    #[cfg_attr(feature = "serde", serde(rename = "TxTp"))]
    pub tx_tp: AssetClassTransactionType1Code,

    #[yaserde(rename = "FnlPricTp")]
    #[cfg_attr(feature = "serde", serde(rename = "FnlPricTp"))]
    pub fnl_pric_tp: AssetPriceType1Code,
}

impl Validate for DerivativeCommodity2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.036.001.02")]
pub struct DerivativeForeignExchange3 {
    #[yaserde(rename = "FxTp")]
    #[cfg_attr(feature = "serde", serde(rename = "FxTp"))]
    pub fx_tp: AssetFXSubProductType1Code,

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

impl Validate for DerivativeForeignExchange3 {}


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

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

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

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

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

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

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

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

impl Validate for DerivativeInstrument5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.036.001.02")]
pub struct DerivativeInterest3 {
    #[yaserde(rename = "IntrstRate")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstRate"))]
    pub intrst_rate: FloatingInterestRate8,

    #[yaserde(rename = "FrstLegIntrstRate")]
    #[cfg_attr(feature = "serde", serde(rename = "FrstLegIntrstRate"))]
    pub frst_leg_intrst_rate: InterestRate8Choice,

    #[yaserde(rename = "OthrNtnlCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrNtnlCcy"))]
    pub othr_ntnl_ccy: ActiveOrHistoricCurrencyCode,

    #[yaserde(rename = "OthrLegIntrstRate")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrLegIntrstRate"))]
    pub othr_leg_intrst_rate: InterestRate8Choice,
}

impl Validate for DerivativeInterest3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.036.001.02")]
pub struct Document {
    #[yaserde(rename = "FinInstrmRptgRefDataDltaRpt")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrmRptgRefDataDltaRpt"))]
    pub fin_instrm_rptg_ref_data_dlta_rpt: FinancialInstrumentReportingReferenceDataDeltaReportV02,
}

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.036.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.036.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.036.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.036.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.036.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.036.001.02")]
pub struct EnergyCommodityNaturalGas1 {
    #[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: AssetClassDetailedSubProductType6Code,
}

impl Validate for EnergyCommodityNaturalGas1 {}


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

impl Validate for EnergyCommodityOil1 {}


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


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.036.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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.036.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.036.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.036.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.036.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.036.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.036.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.036.001.02")]
pub struct FinancialInstrument48Choice {
    #[yaserde(rename = "ISIN")]
    #[cfg_attr(feature = "serde", serde(rename = "ISIN"))]
    pub isin: Option<Isinoct2015Identifier>,
    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Option<Leiidentifier>,
    #[yaserde(rename = "Indx")]
    #[cfg_attr(feature = "serde", serde(rename = "Indx"))]
    pub indx: Option<FinancialInstrument58>,
}

impl Validate for FinancialInstrument48Choice {}




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

    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Vec<Leiidentifier>,
}

impl Validate for FinancialInstrument53 {}


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

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

impl Validate for FinancialInstrument58 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.036.001.02")]
pub struct FinancialInstrumentIdentification5Choice {
    #[yaserde(rename = "Sngl")]
    #[cfg_attr(feature = "serde", serde(rename = "Sngl"))]
    pub sngl: Option<FinancialInstrument48Choice>,
    #[yaserde(rename = "Bskt")]
    #[cfg_attr(feature = "serde", serde(rename = "Bskt"))]
    pub bskt: Option<FinancialInstrument53>,
}

impl Validate for FinancialInstrumentIdentification5Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.036.001.02")]
pub struct FinancialInstrumentReportingReferenceDataDeltaReportV02 {
    #[yaserde(rename = "RptHdr")]
    #[cfg_attr(feature = "serde", serde(rename = "RptHdr"))]
    pub rpt_hdr: SecuritiesMarketReportHeader1,

    #[yaserde(rename = "FinInstrm")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrm"))]
    pub fin_instrm: Vec<SecuritiesReferenceDeltaStatusReport3Choice>,

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

impl Validate for FinancialInstrumentReportingReferenceDataDeltaReportV02 {}


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

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

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

impl Validate for FloatingInterestRate6 {}


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

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

impl Validate for FloatingInterestRate8 {}


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

impl Validate for FreightCommodityDry1 {}


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

impl Validate for FreightCommodityWet1 {}


#[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.036.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.036.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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.036.001.02")]
pub struct InterestRate6Choice {
    #[yaserde(rename = "Fxd")]
    #[cfg_attr(feature = "serde", serde(rename = "Fxd"))]
    pub fxd: Option<PercentageRate>,
    #[yaserde(rename = "Fltg")]
    #[cfg_attr(feature = "serde", serde(rename = "Fltg"))]
    pub fltg: Option<FloatingInterestRate6>,
}

impl Validate for InterestRate6Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.036.001.02")]
pub struct InterestRate8Choice {
    #[yaserde(rename = "Fxd")]
    #[cfg_attr(feature = "serde", serde(rename = "Fxd"))]
    pub fxd: Option<PercentageRate>,
    #[yaserde(rename = "Fltg")]
    #[cfg_attr(feature = "serde", serde(rename = "Fltg"))]
    pub fltg: Option<FloatingInterestRate8>,
}

impl Validate for InterestRate8Choice {}




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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Validate for OptionStyle7Code {}



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

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

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

impl Validate for OptionType2Code {}



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

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

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

impl Validate for Period2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.036.001.02")]
pub struct Period4Choice {
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Option<Isodate>,
    #[yaserde(rename = "FrDt")]
    #[cfg_attr(feature = "serde", serde(rename = "FrDt"))]
    pub fr_dt: Option<Isodate>,
    #[yaserde(rename = "ToDt")]
    #[cfg_attr(feature = "serde", serde(rename = "ToDt"))]
    pub to_dt: Option<Isodate>,
    #[yaserde(rename = "FrDtToDt")]
    #[cfg_attr(feature = "serde", serde(rename = "FrDtToDt"))]
    pub fr_dt_to_dt: Option<Period2>,
}

impl Validate for Period4Choice {}




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

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

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

impl Validate for PhysicalTransferType4Code {}



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

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

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

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

impl Validate for PriceStatus1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.036.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.036.001.02")]
pub struct RecordTechnicalData4 {
    #[yaserde(rename = "IncnsstncyInd")]
    #[cfg_attr(feature = "serde", serde(rename = "IncnsstncyInd"))]
    pub incnsstncy_ind: TrueFalseIndicator,

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

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

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

    #[yaserde(rename = "PblctnPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "PblctnPrd"))]
    pub pblctn_prd: Period4Choice,

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

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

impl Validate for RecordTechnicalData4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.036.001.02")]
pub struct SecuritiesMarketReportHeader1 {
    #[yaserde(rename = "RptgNtty")]
    #[cfg_attr(feature = "serde", serde(rename = "RptgNtty"))]
    pub rptg_ntty: TradingVenueIdentification1Choice,

    #[yaserde(rename = "RptgPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "RptgPrd"))]
    pub rptg_prd: Period4Choice,

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

impl Validate for SecuritiesMarketReportHeader1 {}


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

    #[yaserde(rename = "FinInstrmGnlAttrbts")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrmGnlAttrbts"))]
    pub fin_instrm_gnl_attrbts: SecurityInstrumentDescription9,

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

    #[yaserde(rename = "TradgVnRltdAttrbts")]
    #[cfg_attr(feature = "serde", serde(rename = "TradgVnRltdAttrbts"))]
    pub tradg_vn_rltd_attrbts: Vec<TradingVenueAttributes1>,

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

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

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

impl Validate for SecuritiesReferenceDataReport6 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.036.001.02")]
pub struct SecuritiesReferenceDeltaStatusReport3Choice {
    #[yaserde(rename = "ModfdRcrd")]
    #[cfg_attr(feature = "serde", serde(rename = "ModfdRcrd"))]
    pub modfd_rcrd: Option<SecuritiesReferenceDataReport6>,
    #[yaserde(rename = "NewRcrd")]
    #[cfg_attr(feature = "serde", serde(rename = "NewRcrd"))]
    pub new_rcrd: Option<SecuritiesReferenceDataReport6>,
    #[yaserde(rename = "TermntdRcrd")]
    #[cfg_attr(feature = "serde", serde(rename = "TermntdRcrd"))]
    pub termntd_rcrd: Option<SecuritiesReferenceDataReport6>,
}

impl Validate for SecuritiesReferenceDeltaStatusReport3Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.036.001.02")]
pub struct SecuritiesTransactionPrice1 {
    #[yaserde(rename = "Pdg")]
    #[cfg_attr(feature = "serde", serde(rename = "Pdg"))]
    pub pdg: PriceStatus1Code,

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

impl Validate for SecuritiesTransactionPrice1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.036.001.02")]
pub struct SecuritiesTransactionPrice2Choice {
    #[yaserde(rename = "MntryVal")]
    #[cfg_attr(feature = "serde", serde(rename = "MntryVal"))]
    pub mntry_val: Option<AmountAndDirection61>,
    #[yaserde(rename = "Pctg")]
    #[cfg_attr(feature = "serde", serde(rename = "Pctg"))]
    pub pctg: Option<PercentageRate>,
    #[yaserde(rename = "Yld")]
    #[cfg_attr(feature = "serde", serde(rename = "Yld"))]
    pub yld: Option<PercentageRate>,
    #[yaserde(rename = "BsisPts")]
    #[cfg_attr(feature = "serde", serde(rename = "BsisPts"))]
    pub bsis_pts: Option<DecimalNumber>,
}

impl Validate for SecuritiesTransactionPrice2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.036.001.02")]
pub struct SecuritiesTransactionPrice4Choice {
    #[yaserde(rename = "Pric")]
    #[cfg_attr(feature = "serde", serde(rename = "Pric"))]
    pub pric: Option<SecuritiesTransactionPrice2Choice>,
    #[yaserde(rename = "NoPric")]
    #[cfg_attr(feature = "serde", serde(rename = "NoPric"))]
    pub no_pric: Option<SecuritiesTransactionPrice1>,
}

impl Validate for SecuritiesTransactionPrice4Choice {}




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

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

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

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

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

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

impl Validate for SecurityInstrumentDescription9 {}


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

pub enum TradingVenue2Code {
    #[yaserde(rename = "APPA")]
    #[cfg_attr(feature = "serde", serde(rename = "APPA"))]
    Appa,
    #[yaserde(rename = "CTPS")]
    #[cfg_attr(feature = "serde", serde(rename = "CTPS"))]
    Ctps,
    __Unknown__(String),
}

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

impl Validate for TradingVenue2Code {}



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

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

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

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

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

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

impl Validate for TradingVenueAttributes1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.036.001.02")]
pub struct TradingVenueIdentification1Choice {
    #[yaserde(rename = "MktIdCd")]
    #[cfg_attr(feature = "serde", serde(rename = "MktIdCd"))]
    pub mkt_id_cd: Option<Micidentifier>,
    #[yaserde(rename = "NtlCmptntAuthrty")]
    #[cfg_attr(feature = "serde", serde(rename = "NtlCmptntAuthrty"))]
    pub ntl_cmptnt_authrty: Option<CountryCode>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<TradingVenueIdentification2>,
}

impl Validate for TradingVenueIdentification1Choice {}




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

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

impl Validate for TradingVenueIdentification2 {}


#[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 {}

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