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

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

impl Validate for ActiveOrHistoricCurrencyAnd19DecimalAmount {}


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

impl Validate for AgreementType2Choice {}




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


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


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

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

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

impl Validate for AgriculturalCommodityGrain3 {}


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


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


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

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

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

impl Validate for AgriculturalCommodityOliveOil3 {}


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

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

impl Validate for AgriculturalCommodityOther2 {}


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


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


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


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

pub enum AllocationIndicator1Code {
    #[yaserde(rename = "POST")]
    #[cfg_attr(feature = "serde", serde(rename = "POST"))]
    Post,
    #[yaserde(rename = "PREA")]
    #[cfg_attr(feature = "serde", serde(rename = "PREA"))]
    Prea,
    #[yaserde(rename = "UNAL")]
    #[cfg_attr(feature = "serde", serde(rename = "UNAL"))]
    Unal,
    __Unknown__(String),
}

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

impl Validate for AllocationIndicator1Code {}



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

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

impl Validate for AmountAndDirection106 {}


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

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

impl Validate for AmountAndDirection109 {}


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

impl Validate for AnyBICDec2014Identifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct AssetClassCommodity7Choice {
    #[yaserde(rename = "Agrcltrl")]
    #[cfg_attr(feature = "serde", serde(rename = "Agrcltrl"))]
    pub agrcltrl: Option<AssetClassCommodityAgricultural6Choice>,
    #[yaserde(rename = "Nrgy")]
    #[cfg_attr(feature = "serde", serde(rename = "Nrgy"))]
    pub nrgy: Option<AssetClassCommodityEnergy3Choice>,
    #[yaserde(rename = "Envttl")]
    #[cfg_attr(feature = "serde", serde(rename = "Envttl"))]
    pub envttl: Option<AssetClassCommodityEnvironmental3Choice>,
    #[yaserde(rename = "Frtlzr")]
    #[cfg_attr(feature = "serde", serde(rename = "Frtlzr"))]
    pub frtlzr: Option<AssetClassCommodityFertilizer4Choice>,
    #[yaserde(rename = "Frght")]
    #[cfg_attr(feature = "serde", serde(rename = "Frght"))]
    pub frght: Option<AssetClassCommodityFreight4Choice>,
    #[yaserde(rename = "Indx")]
    #[cfg_attr(feature = "serde", serde(rename = "Indx"))]
    pub indx: Option<AssetClassCommodityIndex1>,
    #[yaserde(rename = "IndstrlPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "IndstrlPdct"))]
    pub indstrl_pdct: Option<AssetClassCommodityIndustrialProduct2Choice>,
    #[yaserde(rename = "Infltn")]
    #[cfg_attr(feature = "serde", serde(rename = "Infltn"))]
    pub infltn: Option<AssetClassCommodityInflation1>,
    #[yaserde(rename = "Metl")]
    #[cfg_attr(feature = "serde", serde(rename = "Metl"))]
    pub metl: Option<AssetClassCommodityMetal2Choice>,
    #[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>,
    #[yaserde(rename = "OthrC10")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrC10"))]
    pub othr_c10: Option<AssetClassCommodityC10Other1>,
    #[yaserde(rename = "Ppr")]
    #[cfg_attr(feature = "serde", serde(rename = "Ppr"))]
    pub ppr: Option<AssetClassCommodityPaper5Choice>,
    #[yaserde(rename = "Plprpln")]
    #[cfg_attr(feature = "serde", serde(rename = "Plprpln"))]
    pub plprpln: Option<AssetClassCommodityPolypropylene4Choice>,
}

impl Validate for AssetClassCommodity7Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct AssetClassCommodityAgricultural6Choice {
    #[yaserde(rename = "GrnOilSeed")]
    #[cfg_attr(feature = "serde", serde(rename = "GrnOilSeed"))]
    pub grn_oil_seed: Option<AgriculturalCommodityOilSeed2>,
    #[yaserde(rename = "Soft")]
    #[cfg_attr(feature = "serde", serde(rename = "Soft"))]
    pub soft: Option<AgriculturalCommoditySoft2>,
    #[yaserde(rename = "Ptt")]
    #[cfg_attr(feature = "serde", serde(rename = "Ptt"))]
    pub ptt: Option<AgriculturalCommodityPotato2>,
    #[yaserde(rename = "OlvOil")]
    #[cfg_attr(feature = "serde", serde(rename = "OlvOil"))]
    pub olv_oil: Option<AgriculturalCommodityOliveOil3>,
    #[yaserde(rename = "Dairy")]
    #[cfg_attr(feature = "serde", serde(rename = "Dairy"))]
    pub dairy: Option<AgriculturalCommodityDairy2>,
    #[yaserde(rename = "Frstry")]
    #[cfg_attr(feature = "serde", serde(rename = "Frstry"))]
    pub frstry: Option<AgriculturalCommodityForestry2>,
    #[yaserde(rename = "Sfd")]
    #[cfg_attr(feature = "serde", serde(rename = "Sfd"))]
    pub sfd: Option<AgriculturalCommoditySeafood2>,
    #[yaserde(rename = "LiveStock")]
    #[cfg_attr(feature = "serde", serde(rename = "LiveStock"))]
    pub live_stock: Option<AgriculturalCommodityLiveStock2>,
    #[yaserde(rename = "Grn")]
    #[cfg_attr(feature = "serde", serde(rename = "Grn"))]
    pub grn: Option<AgriculturalCommodityGrain3>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<AgriculturalCommodityOther2>,
}

impl Validate for AssetClassCommodityAgricultural6Choice {}




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

impl Validate for AssetClassCommodityC10Other1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct AssetClassCommodityEnergy3Choice {
    #[yaserde(rename = "Elctrcty")]
    #[cfg_attr(feature = "serde", serde(rename = "Elctrcty"))]
    pub elctrcty: Option<EnergyCommodityElectricity2>,
    #[yaserde(rename = "NtrlGas")]
    #[cfg_attr(feature = "serde", serde(rename = "NtrlGas"))]
    pub ntrl_gas: Option<EnergyCommodityNaturalGas3>,
    #[yaserde(rename = "Oil")]
    #[cfg_attr(feature = "serde", serde(rename = "Oil"))]
    pub oil: Option<EnergyCommodityOil3>,
    #[yaserde(rename = "Coal")]
    #[cfg_attr(feature = "serde", serde(rename = "Coal"))]
    pub coal: Option<EnergyCommodityCoal2>,
    #[yaserde(rename = "IntrNrgy")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrNrgy"))]
    pub intr_nrgy: Option<EnergyCommodityInterEnergy2>,
    #[yaserde(rename = "RnwblNrgy")]
    #[cfg_attr(feature = "serde", serde(rename = "RnwblNrgy"))]
    pub rnwbl_nrgy: Option<EnergyCommodityRenewableEnergy2>,
    #[yaserde(rename = "LghtEnd")]
    #[cfg_attr(feature = "serde", serde(rename = "LghtEnd"))]
    pub lght_end: Option<EnergyCommodityLightEnd2>,
    #[yaserde(rename = "Dstllts")]
    #[cfg_attr(feature = "serde", serde(rename = "Dstllts"))]
    pub dstllts: Option<EnergyCommodityDistillates2>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<EnergyCommodityOther2>,
}

impl Validate for AssetClassCommodityEnergy3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct AssetClassCommodityEnvironmental3Choice {
    #[yaserde(rename = "Emssns")]
    #[cfg_attr(feature = "serde", serde(rename = "Emssns"))]
    pub emssns: Option<EnvironmentalCommodityEmission3>,
    #[yaserde(rename = "Wthr")]
    #[cfg_attr(feature = "serde", serde(rename = "Wthr"))]
    pub wthr: Option<EnvironmentalCommodityWeather2>,
    #[yaserde(rename = "CrbnRltd")]
    #[cfg_attr(feature = "serde", serde(rename = "CrbnRltd"))]
    pub crbn_rltd: Option<EnvironmentalCommodityCarbonRelated2>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<EnvironmentCommodityOther2>,
}

impl Validate for AssetClassCommodityEnvironmental3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct AssetClassCommodityFertilizer4Choice {
    #[yaserde(rename = "Ammn")]
    #[cfg_attr(feature = "serde", serde(rename = "Ammn"))]
    pub ammn: Option<FertilizerCommodityAmmonia2>,
    #[yaserde(rename = "DmmnmPhspht")]
    #[cfg_attr(feature = "serde", serde(rename = "DmmnmPhspht"))]
    pub dmmnm_phspht: Option<FertilizerCommodityDiammoniumPhosphate2>,
    #[yaserde(rename = "Ptsh")]
    #[cfg_attr(feature = "serde", serde(rename = "Ptsh"))]
    pub ptsh: Option<FertilizerCommodityPotash2>,
    #[yaserde(rename = "Slphr")]
    #[cfg_attr(feature = "serde", serde(rename = "Slphr"))]
    pub slphr: Option<FertilizerCommoditySulphur2>,
    #[yaserde(rename = "Urea")]
    #[cfg_attr(feature = "serde", serde(rename = "Urea"))]
    pub urea: Option<FertilizerCommodityUrea2>,
    #[yaserde(rename = "UreaAndAmmnmNtrt")]
    #[cfg_attr(feature = "serde", serde(rename = "UreaAndAmmnmNtrt"))]
    pub urea_and_ammnm_ntrt: Option<FertilizerCommodityUreaAndAmmoniumNitrate2>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<FertilizerCommodityOther2>,
}

impl Validate for AssetClassCommodityFertilizer4Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct AssetClassCommodityFreight4Choice {
    #[yaserde(rename = "Dry")]
    #[cfg_attr(feature = "serde", serde(rename = "Dry"))]
    pub dry: Option<FreightCommodityDry3>,
    #[yaserde(rename = "Wet")]
    #[cfg_attr(feature = "serde", serde(rename = "Wet"))]
    pub wet: Option<FreightCommodityWet3>,
    #[yaserde(rename = "CntnrShip")]
    #[cfg_attr(feature = "serde", serde(rename = "CntnrShip"))]
    pub cntnr_ship: Option<FreightCommodityContainerShip2>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<FreightCommodityOther2>,
}

impl Validate for AssetClassCommodityFreight4Choice {}




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

impl Validate for AssetClassCommodityIndex1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct AssetClassCommodityIndustrialProduct2Choice {
    #[yaserde(rename = "Cnstrctn")]
    #[cfg_attr(feature = "serde", serde(rename = "Cnstrctn"))]
    pub cnstrctn: Option<IndustrialProductCommodityConstruction2>,
    #[yaserde(rename = "Manfctg")]
    #[cfg_attr(feature = "serde", serde(rename = "Manfctg"))]
    pub manfctg: Option<IndustrialProductCommodityManufacturing2>,
}

impl Validate for AssetClassCommodityIndustrialProduct2Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
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.030.001.04")]
pub struct AssetClassCommodityMetal2Choice {
    #[yaserde(rename = "NonPrcs")]
    #[cfg_attr(feature = "serde", serde(rename = "NonPrcs"))]
    pub non_prcs: Option<MetalCommodityNonPrecious2>,
    #[yaserde(rename = "Prcs")]
    #[cfg_attr(feature = "serde", serde(rename = "Prcs"))]
    pub prcs: Option<MetalCommodityPrecious2>,
}

impl Validate for AssetClassCommodityMetal2Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
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.030.001.04")]
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.030.001.04")]
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.030.001.04")]
pub struct AssetClassCommodityPaper5Choice {
    #[yaserde(rename = "CntnrBrd")]
    #[cfg_attr(feature = "serde", serde(rename = "CntnrBrd"))]
    pub cntnr_brd: Option<PaperCommodityContainerBoard2>,
    #[yaserde(rename = "Nwsprnt")]
    #[cfg_attr(feature = "serde", serde(rename = "Nwsprnt"))]
    pub nwsprnt: Option<PaperCommodityNewsprint2>,
    #[yaserde(rename = "Pulp")]
    #[cfg_attr(feature = "serde", serde(rename = "Pulp"))]
    pub pulp: Option<PaperCommodityPulp2>,
    #[yaserde(rename = "RcvrdPpr")]
    #[cfg_attr(feature = "serde", serde(rename = "RcvrdPpr"))]
    pub rcvrd_ppr: Option<PaperCommodityRecoveredPaper3>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<PaperCommodityOther1>,
}

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

impl Validate for AssetClassCommodityPolypropylene4Choice {}




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

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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

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

impl Validate for AssetClassDetailedSubProductType29Code {}



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

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.030.001.04")]

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

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

impl Validate for AssetClassDetailedSubProductType30Code {}



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

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

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

impl Validate for AssetClassDetailedSubProductType31Code {}



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

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

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

impl Validate for AssetClassDetailedSubProductType32Code {}



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

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

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

impl Validate for AssetClassDetailedSubProductType33Code {}



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

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

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

impl Validate for AssetClassDetailedSubProductType34Code {}



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

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

pub enum AssetClassProductType16Code {
    #[yaserde(rename = "INDX")]
    #[cfg_attr(feature = "serde", serde(rename = "INDX"))]
    Indx,
    __Unknown__(String),
}

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

impl Validate for AssetClassProductType16Code {}



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

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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

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

impl Validate for AssetClassSubProductType49Code {}



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

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

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

impl Validate for AssetClassSubProductType50Code {}



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

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.030.001.04")]

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.030.001.04")]

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.030.001.04")]

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

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

impl Validate for AssetClassSubProductType8Code {}



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

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

impl Validate for BaseOneRate {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct BasketConstituents3 {
    #[yaserde(rename = "InstrmId")]
    #[cfg_attr(feature = "serde", serde(rename = "InstrmId"))]
    pub instrm_id: InstrumentIdentification6Choice,

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

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

impl Validate for BasketConstituents3 {}


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

impl Validate for Cfioct2015Identifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct Cleared23Choice {
    #[yaserde(rename = "Clrd")]
    #[cfg_attr(feature = "serde", serde(rename = "Clrd"))]
    pub clrd: Option<ClearingPartyAndTime21Choice>,
    #[yaserde(rename = "IntndToClear")]
    #[cfg_attr(feature = "serde", serde(rename = "IntndToClear"))]
    pub intnd_to_clear: Option<ClearingPartyAndTime22Choice>,
    #[yaserde(rename = "NonClrd")]
    #[cfg_attr(feature = "serde", serde(rename = "NonClrd"))]
    pub non_clrd: Option<ClearingExceptionOrExemption3Choice>,
}

impl Validate for Cleared23Choice {}




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

pub enum ClearingAccountType4Code {
    #[yaserde(rename = "CLIE")]
    #[cfg_attr(feature = "serde", serde(rename = "CLIE"))]
    Clie,
    #[yaserde(rename = "HOUS")]
    #[cfg_attr(feature = "serde", serde(rename = "HOUS"))]
    Hous,
    __Unknown__(String),
}

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

impl Validate for ClearingAccountType4Code {}



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

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

impl Validate for ClearingExceptionOrExemption2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct ClearingExceptionOrExemption3Choice {
    #[yaserde(rename = "Rsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
    pub rsn: Option<NoReasonCode>,
    #[yaserde(rename = "CtrPties")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrPties"))]
    pub ctr_pties: Option<ClearingExceptionOrExemption2>,
}

impl Validate for ClearingExceptionOrExemption3Choice {}




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

pub enum ClearingExemptionException1Code {
    #[yaserde(rename = "COOP")]
    #[cfg_attr(feature = "serde", serde(rename = "COOP"))]
    Coop,
    #[yaserde(rename = "ENDU")]
    #[cfg_attr(feature = "serde", serde(rename = "ENDU"))]
    Endu,
    #[yaserde(rename = "AFFL")]
    #[cfg_attr(feature = "serde", serde(rename = "AFFL"))]
    Affl,
    #[yaserde(rename = "NOAL")]
    #[cfg_attr(feature = "serde", serde(rename = "NOAL"))]
    Noal,
    #[yaserde(rename = "NORE")]
    #[cfg_attr(feature = "serde", serde(rename = "NORE"))]
    Nore,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "SMBK")]
    #[cfg_attr(feature = "serde", serde(rename = "SMBK"))]
    Smbk,
    __Unknown__(String),
}

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

impl Validate for ClearingExemptionException1Code {}



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

pub enum ClearingObligationType1Code {
    #[yaserde(rename = "FLSE")]
    #[cfg_attr(feature = "serde", serde(rename = "FLSE"))]
    Flse,
    #[yaserde(rename = "UKWN")]
    #[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
    Ukwn,
    #[yaserde(rename = "TRUE")]
    #[cfg_attr(feature = "serde", serde(rename = "TRUE"))]
    True,
    __Unknown__(String),
}

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

impl Validate for ClearingObligationType1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct ClearingPartyAndTime21Choice {
    #[yaserde(rename = "Rsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
    pub rsn: Option<NoReasonCode>,
    #[yaserde(rename = "Dtls")]
    #[cfg_attr(feature = "serde", serde(rename = "Dtls"))]
    pub dtls: Option<ClearingPartyAndTime22>,
}

impl Validate for ClearingPartyAndTime21Choice {}




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

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

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

    #[yaserde(rename = "ClrIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "ClrIdr"))]
    pub clr_idr: UniqueTransactionIdentifier2Choice,

    #[yaserde(rename = "OrgnlIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlIdr"))]
    pub orgnl_idr: UniqueTransactionIdentifier2Choice,

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

    #[yaserde(rename = "ClrAcctOrgn")]
    #[cfg_attr(feature = "serde", serde(rename = "ClrAcctOrgn"))]
    pub clr_acct_orgn: ClearingAccountType4Code,
}

impl Validate for ClearingPartyAndTime22 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct ClearingPartyAndTime22Choice {
    #[yaserde(rename = "Rsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
    pub rsn: Option<NoReasonCode>,
    #[yaserde(rename = "Dtls")]
    #[cfg_attr(feature = "serde", serde(rename = "Dtls"))]
    pub dtls: Option<ClearingPartyAndTime23>,
}

impl Validate for ClearingPartyAndTime22Choice {}




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

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

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

    #[yaserde(rename = "ClrIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "ClrIdr"))]
    pub clr_idr: UniqueTransactionIdentifier1Choice,

    #[yaserde(rename = "OrgnlIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlIdr"))]
    pub orgnl_idr: UniqueTransactionIdentifier1Choice,

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

impl Validate for ClearingPartyAndTime23 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct CollateralPortfolioCode6Choice {
    #[yaserde(rename = "Prtfl")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtfl"))]
    pub prtfl: Option<PortfolioCode3Choice>,
    #[yaserde(rename = "MrgnPrtflCd")]
    #[cfg_attr(feature = "serde", serde(rename = "MrgnPrtflCd"))]
    pub mrgn_prtfl_cd: Option<MarginPortfolio4>,
}

impl Validate for CollateralPortfolioCode6Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct CommonTradeDataReport71 {
    #[yaserde(rename = "CtrctData")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrctData"))]
    pub ctrct_data: ContractType15,

    #[yaserde(rename = "TxData")]
    #[cfg_attr(feature = "serde", serde(rename = "TxData"))]
    pub tx_data: TradeTransaction50,
}

impl Validate for CommonTradeDataReport71 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct ContractType15 {
    #[yaserde(rename = "CtrctTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrctTp"))]
    pub ctrct_tp: FinancialInstrumentContractType2Code,

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

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

    #[yaserde(rename = "PdctId")]
    #[cfg_attr(feature = "serde", serde(rename = "PdctId"))]
    pub pdct_id: SecurityIdentification46,

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

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

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

    #[yaserde(rename = "SttlmCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmCcy"))]
    pub sttlm_ccy: CurrencyExchange23,

    #[yaserde(rename = "SttlmCcyScndLeg")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmCcyScndLeg"))]
    pub sttlm_ccy_scnd_leg: CurrencyExchange23,

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

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

impl Validate for ContractType15 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct ContractValuationData8 {
    #[yaserde(rename = "CtrctVal")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrctVal"))]
    pub ctrct_val: AmountAndDirection109,

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

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

    #[yaserde(rename = "Dlta")]
    #[cfg_attr(feature = "serde", serde(rename = "Dlta"))]
    pub dlta: LongFraction19DecimalNumber,
}

impl Validate for ContractValuationData8 {}


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

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

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

    #[yaserde(rename = "DrctnOrSd")]
    #[cfg_attr(feature = "serde", serde(rename = "DrctnOrSd"))]
    pub drctn_or_sd: Direction4Choice,

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

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

    #[yaserde(rename = "RptgXmptn")]
    #[cfg_attr(feature = "serde", serde(rename = "RptgXmptn"))]
    pub rptg_xmptn: ReportingExemption1,
}

impl Validate for Counterparty45 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct Counterparty46 {
    #[yaserde(rename = "IdTp")]
    #[cfg_attr(feature = "serde", serde(rename = "IdTp"))]
    pub id_tp: PartyIdentification248Choice,

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

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

impl Validate for Counterparty46 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct CounterpartySpecificData36 {
    #[yaserde(rename = "CtrPty")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrPty"))]
    pub ctr_pty: TradeCounterpartyReport20,

    #[yaserde(rename = "Valtn")]
    #[cfg_attr(feature = "serde", serde(rename = "Valtn"))]
    pub valtn: ContractValuationData8,

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

impl Validate for CounterpartySpecificData36 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct CounterpartyTradeNature15Choice {
    #[yaserde(rename = "FI")]
    #[cfg_attr(feature = "serde", serde(rename = "FI"))]
    pub fi: Option<FinancialInstitutionSector1>,
    #[yaserde(rename = "NFI")]
    #[cfg_attr(feature = "serde", serde(rename = "NFI"))]
    pub nfi: Option<NonFinancialInstitutionSector10>,
    #[yaserde(rename = "CntrlCntrPty")]
    #[cfg_attr(feature = "serde", serde(rename = "CntrlCntrPty"))]
    pub cntrl_cntr_pty: Option<NoReasonCode>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<NoReasonCode>,
}

impl Validate for CounterpartyTradeNature15Choice {}




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

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

impl Validate for CountrySubDivisionCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct CreditDerivative4 {
    #[yaserde(rename = "Snrty")]
    #[cfg_attr(feature = "serde", serde(rename = "Snrty"))]
    pub snrty: DebtInstrumentSeniorityType2Code,

    #[yaserde(rename = "RefPty")]
    #[cfg_attr(feature = "serde", serde(rename = "RefPty"))]
    pub ref_pty: DerivativePartyIdentification1Choice,

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

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

    #[yaserde(rename = "Srs")]
    #[cfg_attr(feature = "serde", serde(rename = "Srs"))]
    pub srs: Number,

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

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

    #[yaserde(rename = "Trch")]
    #[cfg_attr(feature = "serde", serde(rename = "Trch"))]
    pub trch: TrancheIndicator3Choice,
}

impl Validate for CreditDerivative4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct CurrencyExchange22 {
    #[yaserde(rename = "DlvrblCrossCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "DlvrblCrossCcy"))]
    pub dlvrbl_cross_ccy: ActiveOrHistoricCurrencyCode,

    #[yaserde(rename = "XchgRate")]
    #[cfg_attr(feature = "serde", serde(rename = "XchgRate"))]
    pub xchg_rate: BaseOne18Rate,

    #[yaserde(rename = "FwdXchgRate")]
    #[cfg_attr(feature = "serde", serde(rename = "FwdXchgRate"))]
    pub fwd_xchg_rate: BaseOne18Rate,

    #[yaserde(rename = "XchgRateBsis")]
    #[cfg_attr(feature = "serde", serde(rename = "XchgRateBsis"))]
    pub xchg_rate_bsis: ExchangeRateBasis1Choice,

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

impl Validate for CurrencyExchange22 {}


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

    #[yaserde(rename = "XchgRate")]
    #[cfg_attr(feature = "serde", serde(rename = "XchgRate"))]
    pub xchg_rate: BaseOne18Rate,

    #[yaserde(rename = "FwdXchgRate")]
    #[cfg_attr(feature = "serde", serde(rename = "FwdXchgRate"))]
    pub fwd_xchg_rate: BaseOne18Rate,

    #[yaserde(rename = "XchgRateBsis")]
    #[cfg_attr(feature = "serde", serde(rename = "XchgRateBsis"))]
    pub xchg_rate_bsis: ExchangeRateBasis1Choice,

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

impl Validate for CurrencyExchange23 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct CustomBasket4 {
    #[yaserde(rename = "Strr")]
    #[cfg_attr(feature = "serde", serde(rename = "Strr"))]
    pub strr: Leiidentifier,

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

    #[yaserde(rename = "Cnsttnts")]
    #[cfg_attr(feature = "serde", serde(rename = "Cnsttnts"))]
    pub cnsttnts: Vec<BasketConstituents3>,
}

impl Validate for CustomBasket4 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct DateAndDateTime2Choice {
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Option<Isodate>,
    #[yaserde(rename = "DtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "DtTm"))]
    pub dt_tm: Option<IsodateTime>,
}

impl Validate for DateAndDateTime2Choice {}




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

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

impl Validate for DatePeriod1 {}


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

pub enum DebtInstrumentSeniorityType2Code {
    #[yaserde(rename = "SBOD")]
    #[cfg_attr(feature = "serde", serde(rename = "SBOD"))]
    Sbod,
    #[yaserde(rename = "SNDB")]
    #[cfg_attr(feature = "serde", serde(rename = "SNDB"))]
    Sndb,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    __Unknown__(String),
}

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

impl Validate for DebtInstrumentSeniorityType2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct DeliveryInterconnectionPoint1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<Eicidentifier>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max52Text>,
}

impl Validate for DeliveryInterconnectionPoint1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct DerivativeEvent6 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: DerivativeEventType3Code,

    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: EventIdentifier1Choice,

    #[yaserde(rename = "TmStmp")]
    #[cfg_attr(feature = "serde", serde(rename = "TmStmp"))]
    pub tm_stmp: DateAndDateTime2Choice,

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

impl Validate for DerivativeEvent6 {}


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

pub enum DerivativeEventType3Code {
    #[yaserde(rename = "ALOC")]
    #[cfg_attr(feature = "serde", serde(rename = "ALOC"))]
    Aloc,
    #[yaserde(rename = "CLRG")]
    #[cfg_attr(feature = "serde", serde(rename = "CLRG"))]
    Clrg,
    #[yaserde(rename = "CLAL")]
    #[cfg_attr(feature = "serde", serde(rename = "CLAL"))]
    Clal,
    #[yaserde(rename = "COMP")]
    #[cfg_attr(feature = "serde", serde(rename = "COMP"))]
    Comp,
    #[yaserde(rename = "CORP")]
    #[cfg_attr(feature = "serde", serde(rename = "CORP"))]
    Corp,
    #[yaserde(rename = "CREV")]
    #[cfg_attr(feature = "serde", serde(rename = "CREV"))]
    Crev,
    #[yaserde(rename = "ETRM")]
    #[cfg_attr(feature = "serde", serde(rename = "ETRM"))]
    Etrm,
    #[yaserde(rename = "EXER")]
    #[cfg_attr(feature = "serde", serde(rename = "EXER"))]
    Exer,
    #[yaserde(rename = "INCP")]
    #[cfg_attr(feature = "serde", serde(rename = "INCP"))]
    Incp,
    #[yaserde(rename = "NOVA")]
    #[cfg_attr(feature = "serde", serde(rename = "NOVA"))]
    Nova,
    #[yaserde(rename = "PTNG")]
    #[cfg_attr(feature = "serde", serde(rename = "PTNG"))]
    Ptng,
    #[yaserde(rename = "TRAD")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAD"))]
    Trad,
    #[yaserde(rename = "UPDT")]
    #[cfg_attr(feature = "serde", serde(rename = "UPDT"))]
    Updt,
    __Unknown__(String),
}

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

impl Validate for DerivativeEventType3Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct DerivativePartyIdentification1Choice {
    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: Option<CountryCode>,
    #[yaserde(rename = "CtrySubDvsn")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrySubDvsn"))]
    pub ctry_sub_dvsn: Option<CountrySubDivisionCode>,
    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Option<Leiidentifier>,
}

impl Validate for DerivativePartyIdentification1Choice {}




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

    #[yaserde(rename = "TradData")]
    #[cfg_attr(feature = "serde", serde(rename = "TradData"))]
    pub trad_data: TradeData59Choice,

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

impl Validate for DerivativesTradeReportV04 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct Direction2 {
    #[yaserde(rename = "DrctnOfTheFrstLeg")]
    #[cfg_attr(feature = "serde", serde(rename = "DrctnOfTheFrstLeg"))]
    pub drctn_of_the_frst_leg: OptionParty3Code,

    #[yaserde(rename = "DrctnOfTheScndLeg")]
    #[cfg_attr(feature = "serde", serde(rename = "DrctnOfTheScndLeg"))]
    pub drctn_of_the_scnd_leg: OptionParty3Code,
}

impl Validate for Direction2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct Direction4Choice {
    #[yaserde(rename = "Drctn")]
    #[cfg_attr(feature = "serde", serde(rename = "Drctn"))]
    pub drctn: Option<Direction2>,
    #[yaserde(rename = "CtrPtySd")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrPtySd"))]
    pub ctr_pty_sd: Option<OptionParty1Code>,
}

impl Validate for Direction4Choice {}




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

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

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

impl Validate for DisseminationData1 {}


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

impl Validate for Document {}


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

pub enum DurationType1Code {
    #[yaserde(rename = "YEAR")]
    #[cfg_attr(feature = "serde", serde(rename = "YEAR"))]
    Year,
    #[yaserde(rename = "WEEK")]
    #[cfg_attr(feature = "serde", serde(rename = "WEEK"))]
    Week,
    #[yaserde(rename = "SEAS")]
    #[cfg_attr(feature = "serde", serde(rename = "SEAS"))]
    Seas,
    #[yaserde(rename = "QURT")]
    #[cfg_attr(feature = "serde", serde(rename = "QURT"))]
    Qurt,
    #[yaserde(rename = "MNTH")]
    #[cfg_attr(feature = "serde", serde(rename = "MNTH"))]
    Mnth,
    #[yaserde(rename = "MNUT")]
    #[cfg_attr(feature = "serde", serde(rename = "MNUT"))]
    Mnut,
    #[yaserde(rename = "HOUR")]
    #[cfg_attr(feature = "serde", serde(rename = "HOUR"))]
    Hour,
    #[yaserde(rename = "DASD")]
    #[cfg_attr(feature = "serde", serde(rename = "DASD"))]
    Dasd,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    __Unknown__(String),
}

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

impl Validate for DurationType1Code {}



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

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

pub enum EmbeddedType1Code {
    #[yaserde(rename = "CANC")]
    #[cfg_attr(feature = "serde", serde(rename = "CANC"))]
    Canc,
    #[yaserde(rename = "EXTD")]
    #[cfg_attr(feature = "serde", serde(rename = "EXTD"))]
    Extd,
    #[yaserde(rename = "OPET")]
    #[cfg_attr(feature = "serde", serde(rename = "OPET"))]
    Opet,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "MDET")]
    #[cfg_attr(feature = "serde", serde(rename = "MDET"))]
    Mdet,
    __Unknown__(String),
}

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

impl Validate for EmbeddedType1Code {}



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


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


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


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


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


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

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

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

impl Validate for EnergyCommodityNaturalGas3 {}


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

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

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

impl Validate for EnergyCommodityOil3 {}


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

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

impl Validate for EnergyCommodityOther2 {}


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


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

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

    #[yaserde(rename = "Drtn")]
    #[cfg_attr(feature = "serde", serde(rename = "Drtn"))]
    pub drtn: DurationType1Code,

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

    #[yaserde(rename = "DlvryCpcty")]
    #[cfg_attr(feature = "serde", serde(rename = "DlvryCpcty"))]
    pub dlvry_cpcty: Quantity47Choice,

    #[yaserde(rename = "QtyUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "QtyUnit"))]
    pub qty_unit: EnergyQuantityUnit2Choice,

    #[yaserde(rename = "PricTmIntrvlQty")]
    #[cfg_attr(feature = "serde", serde(rename = "PricTmIntrvlQty"))]
    pub pric_tm_intrvl_qty: AmountAndDirection106,
}

impl Validate for EnergyDeliveryAttribute10 {}


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

pub enum EnergyLoadType1Code {
    #[yaserde(rename = "BSLD")]
    #[cfg_attr(feature = "serde", serde(rename = "BSLD"))]
    Bsld,
    #[yaserde(rename = "GASD")]
    #[cfg_attr(feature = "serde", serde(rename = "GASD"))]
    Gasd,
    #[yaserde(rename = "HABH")]
    #[cfg_attr(feature = "serde", serde(rename = "HABH"))]
    Habh,
    #[yaserde(rename = "OFFP")]
    #[cfg_attr(feature = "serde", serde(rename = "OFFP"))]
    Offp,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "PKLD")]
    #[cfg_attr(feature = "serde", serde(rename = "PKLD"))]
    Pkld,
    #[yaserde(rename = "SHPD")]
    #[cfg_attr(feature = "serde", serde(rename = "SHPD"))]
    Shpd,
    __Unknown__(String),
}

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

impl Validate for EnergyLoadType1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct EnergyQuantityUnit2Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<EnergyQuantityUnit2Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max52Text>,
}

impl Validate for EnergyQuantityUnit2Choice {}




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

pub enum EnergyQuantityUnit2Code {
    #[yaserde(rename = "BTUD")]
    #[cfg_attr(feature = "serde", serde(rename = "BTUD"))]
    Btud,
    #[yaserde(rename = "CMPD")]
    #[cfg_attr(feature = "serde", serde(rename = "CMPD"))]
    Cmpd,
    #[yaserde(rename = "GJDD")]
    #[cfg_attr(feature = "serde", serde(rename = "GJDD"))]
    Gjdd,
    #[yaserde(rename = "GWAT")]
    #[cfg_attr(feature = "serde", serde(rename = "GWAT"))]
    Gwat,
    #[yaserde(rename = "GWHD")]
    #[cfg_attr(feature = "serde", serde(rename = "GWHD"))]
    Gwhd,
    #[yaserde(rename = "GWHH")]
    #[cfg_attr(feature = "serde", serde(rename = "GWHH"))]
    Gwhh,
    #[yaserde(rename = "HMJD")]
    #[cfg_attr(feature = "serde", serde(rename = "HMJD"))]
    Hmjd,
    #[yaserde(rename = "KTMD")]
    #[cfg_attr(feature = "serde", serde(rename = "KTMD"))]
    Ktmd,
    #[yaserde(rename = "KWAT")]
    #[cfg_attr(feature = "serde", serde(rename = "KWAT"))]
    Kwat,
    #[yaserde(rename = "KWHD")]
    #[cfg_attr(feature = "serde", serde(rename = "KWHD"))]
    Kwhd,
    #[yaserde(rename = "KWHH")]
    #[cfg_attr(feature = "serde", serde(rename = "KWHH"))]
    Kwhh,
    #[yaserde(rename = "MCMD")]
    #[cfg_attr(feature = "serde", serde(rename = "MCMD"))]
    Mcmd,
    #[yaserde(rename = "MJDD")]
    #[cfg_attr(feature = "serde", serde(rename = "MJDD"))]
    Mjdd,
    #[yaserde(rename = "MBTD")]
    #[cfg_attr(feature = "serde", serde(rename = "MBTD"))]
    Mbtd,
    #[yaserde(rename = "MMJD")]
    #[cfg_attr(feature = "serde", serde(rename = "MMJD"))]
    Mmjd,
    #[yaserde(rename = "MTMD")]
    #[cfg_attr(feature = "serde", serde(rename = "MTMD"))]
    Mtmd,
    #[yaserde(rename = "MWAT")]
    #[cfg_attr(feature = "serde", serde(rename = "MWAT"))]
    Mwat,
    #[yaserde(rename = "MWHD")]
    #[cfg_attr(feature = "serde", serde(rename = "MWHD"))]
    Mwhd,
    #[yaserde(rename = "MWHH")]
    #[cfg_attr(feature = "serde", serde(rename = "MWHH"))]
    Mwhh,
    #[yaserde(rename = "THMD")]
    #[cfg_attr(feature = "serde", serde(rename = "THMD"))]
    Thmd,
    __Unknown__(String),
}

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

impl Validate for EnergyQuantityUnit2Code {}



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

    #[yaserde(rename = "IntrCnnctnPt")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrCnnctnPt"))]
    pub intr_cnnctn_pt: DeliveryInterconnectionPoint1Choice,

    #[yaserde(rename = "LdTp")]
    #[cfg_attr(feature = "serde", serde(rename = "LdTp"))]
    pub ld_tp: EnergyLoadType1Code,

    #[yaserde(rename = "DlvryAttr")]
    #[cfg_attr(feature = "serde", serde(rename = "DlvryAttr"))]
    pub dlvry_attr: Vec<EnergyDeliveryAttribute10>,
}

impl Validate for EnergySpecificAttribute9 {}


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

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

impl Validate for EnvironmentCommodityOther2 {}


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


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


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct EnvironmentalCommodityWeather2 {
    #[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 EnvironmentalCommodityWeather2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct EventIdentifier1Choice {
    #[yaserde(rename = "EvtIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "EvtIdr"))]
    pub evt_idr: Option<Utiidentifier>,
    #[yaserde(rename = "PstTradRskRdctnIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "PstTradRskRdctnIdr"))]
    pub pst_trad_rsk_rdctn_idr: Option<PostTradeRiskReductionIdentifier1>,
}

impl Validate for EventIdentifier1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct ExchangeRateBasis1 {
    #[yaserde(rename = "BaseCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "BaseCcy"))]
    pub base_ccy: ActiveCurrencyCode,

    #[yaserde(rename = "QtdCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "QtdCcy"))]
    pub qtd_ccy: ActiveCurrencyCode,
}

impl Validate for ExchangeRateBasis1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct ExchangeRateBasis1Choice {
    #[yaserde(rename = "CcyPair")]
    #[cfg_attr(feature = "serde", serde(rename = "CcyPair"))]
    pub ccy_pair: Option<ExchangeRateBasis1>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max52Text>,
}

impl Validate for ExchangeRateBasis1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct ExerciseDate1Choice {
    #[yaserde(rename = "FrstExrcDt")]
    #[cfg_attr(feature = "serde", serde(rename = "FrstExrcDt"))]
    pub frst_exrc_dt: Option<Isodate>,
    #[yaserde(rename = "PdgDtAplbl")]
    #[cfg_attr(feature = "serde", serde(rename = "PdgDtAplbl"))]
    pub pdg_dt_aplbl: Option<PriceStatus2Code>,
}

impl Validate for ExerciseDate1Choice {}




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

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

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

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

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

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

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

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

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


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


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

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

impl Validate for FertilizerCommodityOther2 {}


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


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


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


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


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

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

impl Validate for FinancialInstitutionSector1 {}


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

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

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

impl Validate for FinancialInstrumentContractType2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct FinancialInstrumentQuantity32Choice {
    #[yaserde(rename = "Unit")]
    #[cfg_attr(feature = "serde", serde(rename = "Unit"))]
    pub unit: Option<LongFraction19DecimalNumber>,
    #[yaserde(rename = "NmnlVal")]
    #[cfg_attr(feature = "serde", serde(rename = "NmnlVal"))]
    pub nmnl_val: Option<ActiveOrHistoricCurrencyAnd19DecimalAmount>,
    #[yaserde(rename = "MntryVal")]
    #[cfg_attr(feature = "serde", serde(rename = "MntryVal"))]
    pub mntry_val: Option<ActiveOrHistoricCurrencyAnd19DecimalAmount>,
}

impl Validate for FinancialInstrumentQuantity32Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct FinancialPartyClassification2Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<FinancialPartySectorType3Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification175>,
}

impl Validate for FinancialPartyClassification2Choice {}




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

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

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

impl Validate for FinancialPartySectorType3Code {}



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

    #[yaserde(rename = "DayCnt")]
    #[cfg_attr(feature = "serde", serde(rename = "DayCnt"))]
    pub day_cnt: InterestComputationMethodFormat7,

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

impl Validate for FixedRate10 {}


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

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

    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: FloatingRateIdentification8Choice,

    #[yaserde(rename = "RefPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "RefPrd"))]
    pub ref_prd: InterestRateContractTerm4,

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

    #[yaserde(rename = "DayCnt")]
    #[cfg_attr(feature = "serde", serde(rename = "DayCnt"))]
    pub day_cnt: InterestComputationMethodFormat7,

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

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

    #[yaserde(rename = "NxtFltgRst")]
    #[cfg_attr(feature = "serde", serde(rename = "NxtFltgRst"))]
    pub nxt_fltg_rst: ResetDateAndValue1,

    #[yaserde(rename = "LastFltgRst")]
    #[cfg_attr(feature = "serde", serde(rename = "LastFltgRst"))]
    pub last_fltg_rst: ResetDateAndValue1,
}

impl Validate for FloatingRate13 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct FloatingRateIdentification8Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ExternalBenchmarkCurveName1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max350Text>,
}

impl Validate for FloatingRateIdentification8Choice {}




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


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

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

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

impl Validate for FreightCommodityDry3 {}


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

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

impl Validate for FreightCommodityOther2 {}


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

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

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

impl Validate for FreightCommodityWet3 {}


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

pub enum Frequency13Code {
    #[yaserde(rename = "DAIL")]
    #[cfg_attr(feature = "serde", serde(rename = "DAIL"))]
    Dail,
    #[yaserde(rename = "WEEK")]
    #[cfg_attr(feature = "serde", serde(rename = "WEEK"))]
    Week,
    #[yaserde(rename = "MNTH")]
    #[cfg_attr(feature = "serde", serde(rename = "MNTH"))]
    Mnth,
    #[yaserde(rename = "YEAR")]
    #[cfg_attr(feature = "serde", serde(rename = "YEAR"))]
    Year,
    #[yaserde(rename = "ADHO")]
    #[cfg_attr(feature = "serde", serde(rename = "ADHO"))]
    Adho,
    #[yaserde(rename = "EXPI")]
    #[cfg_attr(feature = "serde", serde(rename = "EXPI"))]
    Expi,
    #[yaserde(rename = "MIAN")]
    #[cfg_attr(feature = "serde", serde(rename = "MIAN"))]
    Mian,
    #[yaserde(rename = "QURT")]
    #[cfg_attr(feature = "serde", serde(rename = "QURT"))]
    Qurt,
    __Unknown__(String),
}

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

impl Validate for Frequency13Code {}



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

pub enum Frequency19Code {
    #[yaserde(rename = "DAIL")]
    #[cfg_attr(feature = "serde", serde(rename = "DAIL"))]
    Dail,
    #[yaserde(rename = "WEEK")]
    #[cfg_attr(feature = "serde", serde(rename = "WEEK"))]
    Week,
    #[yaserde(rename = "MNTH")]
    #[cfg_attr(feature = "serde", serde(rename = "MNTH"))]
    Mnth,
    #[yaserde(rename = "YEAR")]
    #[cfg_attr(feature = "serde", serde(rename = "YEAR"))]
    Year,
    #[yaserde(rename = "ADHO")]
    #[cfg_attr(feature = "serde", serde(rename = "ADHO"))]
    Adho,
    #[yaserde(rename = "EXPI")]
    #[cfg_attr(feature = "serde", serde(rename = "EXPI"))]
    Expi,
    #[yaserde(rename = "MIAN")]
    #[cfg_attr(feature = "serde", serde(rename = "MIAN"))]
    Mian,
    #[yaserde(rename = "QURT")]
    #[cfg_attr(feature = "serde", serde(rename = "QURT"))]
    Qurt,
    #[yaserde(rename = "HOUL")]
    #[cfg_attr(feature = "serde", serde(rename = "HOUL"))]
    Houl,
    #[yaserde(rename = "ODMD")]
    #[cfg_attr(feature = "serde", serde(rename = "ODMD"))]
    Odmd,
    __Unknown__(String),
}

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

impl Validate for Frequency19Code {}



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

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

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

impl Validate for GenericIdentification175 {}


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

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

impl Validate for GenericIdentification179 {}


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

    #[yaserde(rename = "Src")]
    #[cfg_attr(feature = "serde", serde(rename = "Src"))]
    pub src: Max100Text,
}

impl Validate for GenericIdentification184 {}


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

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

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

impl Validate for GenericIdentification185 {}


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

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

    #[yaserde(rename = "Indx")]
    #[cfg_attr(feature = "serde", serde(rename = "Indx"))]
    pub indx: ExternalBenchmarkCurveName1Code,
}

impl Validate for IndexIdentification1 {}


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


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct IndustrialProductCommodityManufacturing2 {
    #[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 IndustrialProductCommodityManufacturing2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct InstrumentIdentification6Choice {
    #[yaserde(rename = "ISIN")]
    #[cfg_attr(feature = "serde", serde(rename = "ISIN"))]
    pub isin: Option<Isinoct2015Identifier>,
    #[yaserde(rename = "AltrntvInstrmId")]
    #[cfg_attr(feature = "serde", serde(rename = "AltrntvInstrmId"))]
    pub altrntv_instrm_id: Option<Max52Text>,
    #[yaserde(rename = "UnqPdctIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "UnqPdctIdr"))]
    pub unq_pdct_idr: Option<UniqueProductIdentifier1Choice>,
    #[yaserde(rename = "OthrId")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrId"))]
    pub othr_id: Option<GenericIdentification184>,
}

impl Validate for InstrumentIdentification6Choice {}




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

pub enum InterestComputationMethod4Code {
    A004,
    A019,
    A017,
    A005,
    A009,
    A014,
    A010,
    A006,
    A008,
    A015,
    A018,
    A011,
    A001,
    A002,
    A003,
    A012,
    A013,
    A007,
    A016,
    #[yaserde(rename = "NARR")]
    #[cfg_attr(feature = "serde", serde(rename = "NARR"))]
    Narr,
    A020,
    __Unknown__(String),
}

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

impl Validate for InterestComputationMethod4Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct InterestComputationMethodFormat7 {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: InterestComputationMethod4Code,

    #[yaserde(rename = "Nrrtv")]
    #[cfg_attr(feature = "serde", serde(rename = "Nrrtv"))]
    pub nrrtv: Max1000Text,
}

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

impl Validate for InterestRate33Choice {}




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

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

impl Validate for InterestRateContractTerm4 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct InterestRateFrequency3Choice {
    #[yaserde(rename = "Term")]
    #[cfg_attr(feature = "serde", serde(rename = "Term"))]
    pub term: Option<InterestRateContractTerm4>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max52Text>,
}

impl Validate for InterestRateFrequency3Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct InterestRateLegs14 {
    #[yaserde(rename = "FrstLeg")]
    #[cfg_attr(feature = "serde", serde(rename = "FrstLeg"))]
    pub frst_leg: InterestRate33Choice,

    #[yaserde(rename = "ScndLeg")]
    #[cfg_attr(feature = "serde", serde(rename = "ScndLeg"))]
    pub scnd_leg: InterestRate33Choice,
}

impl Validate for InterestRateLegs14 {}


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

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

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

impl Validate for LegalPersonIdentification1 {}


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

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

impl Validate for Micidentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct MarginPortfolio4 {
    #[yaserde(rename = "InitlMrgnPrtflCd")]
    #[cfg_attr(feature = "serde", serde(rename = "InitlMrgnPrtflCd"))]
    pub initl_mrgn_prtfl_cd: PortfolioCode5Choice,

    #[yaserde(rename = "VartnMrgnPrtflCd")]
    #[cfg_attr(feature = "serde", serde(rename = "VartnMrgnPrtflCd"))]
    pub vartn_mrgn_prtfl_cd: PortfolioCode5Choice,
}

impl Validate for MarginPortfolio4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct MasterAgreement8 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: AgreementType2Choice,

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

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

impl Validate for MasterAgreement8 {}


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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


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

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

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

impl Validate for ModificationLevel1Code {}



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

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

    #[yaserde(rename = "Dmcl")]
    #[cfg_attr(feature = "serde", serde(rename = "Dmcl"))]
    pub dmcl: Max500Text,
}

impl Validate for NaturalPersonIdentification2 {}


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

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

impl Validate for NaturalPersonIdentification3 {}


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

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

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

impl Validate for NoReasonCode {}



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

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

impl Validate for NonClearingReason2 {}


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

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

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

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

impl Validate for NonFinancialInstitutionSector10 {}


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

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

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

impl Validate for NotApplicable1Code {}



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

    #[yaserde(rename = "SchdlPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "SchdlPrd"))]
    pub schdl_prd: Vec<Schedule11>,
}

impl Validate for NotionalAmount5 {}


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

    #[yaserde(rename = "SchdlPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "SchdlPrd"))]
    pub schdl_prd: Vec<Schedule11>,

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

impl Validate for NotionalAmount6 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct NotionalAmountLegs5 {
    #[yaserde(rename = "FrstLeg")]
    #[cfg_attr(feature = "serde", serde(rename = "FrstLeg"))]
    pub frst_leg: NotionalAmount5,

    #[yaserde(rename = "ScndLeg")]
    #[cfg_attr(feature = "serde", serde(rename = "ScndLeg"))]
    pub scnd_leg: NotionalAmount6,
}

impl Validate for NotionalAmountLegs5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct NotionalQuantity9 {
    #[yaserde(rename = "TtlQty")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlQty"))]
    pub ttl_qty: LongFraction19DecimalNumber,

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

    #[yaserde(rename = "Dtls")]
    #[cfg_attr(feature = "serde", serde(rename = "Dtls"))]
    pub dtls: QuantityOrTerm1Choice,
}

impl Validate for NotionalQuantity9 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct NotionalQuantityLegs5 {
    #[yaserde(rename = "FrstLeg")]
    #[cfg_attr(feature = "serde", serde(rename = "FrstLeg"))]
    pub frst_leg: NotionalQuantity9,

    #[yaserde(rename = "ScndLeg")]
    #[cfg_attr(feature = "serde", serde(rename = "ScndLeg"))]
    pub scnd_leg: NotionalQuantity9,
}

impl Validate for NotionalQuantityLegs5 {}


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

impl Validate for Number {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct OptionBarrierLevel1Choice {
    #[yaserde(rename = "Sngl")]
    #[cfg_attr(feature = "serde", serde(rename = "Sngl"))]
    pub sngl: Option<SecuritiesTransactionPrice23Choice>,
    #[yaserde(rename = "Mltpl")]
    #[cfg_attr(feature = "serde", serde(rename = "Mltpl"))]
    pub mltpl: Option<OptionMultipleBarrierLevels1>,
}

impl Validate for OptionBarrierLevel1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct OptionMultipleBarrierLevels1 {
    #[yaserde(rename = "LwrLvl")]
    #[cfg_attr(feature = "serde", serde(rename = "LwrLvl"))]
    pub lwr_lvl: SecuritiesTransactionPrice23Choice,

    #[yaserde(rename = "UpperLvl")]
    #[cfg_attr(feature = "serde", serde(rename = "UpperLvl"))]
    pub upper_lvl: SecuritiesTransactionPrice23Choice,
}

impl Validate for OptionMultipleBarrierLevels1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct OptionOrSwaption11 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: OptionType2Code,

    #[yaserde(rename = "MbddTp")]
    #[cfg_attr(feature = "serde", serde(rename = "MbddTp"))]
    pub mbdd_tp: EmbeddedType1Code,

    #[yaserde(rename = "ExrcStyle")]
    #[cfg_attr(feature = "serde", serde(rename = "ExrcStyle"))]
    pub exrc_style: Vec<OptionStyle6Code>,

    #[yaserde(rename = "ExrcDt")]
    #[cfg_attr(feature = "serde", serde(rename = "ExrcDt"))]
    pub exrc_dt: ExerciseDate1Choice,

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

    #[yaserde(rename = "StrkPricSchdl")]
    #[cfg_attr(feature = "serde", serde(rename = "StrkPricSchdl"))]
    pub strk_pric_schdl: Vec<Schedule4>,

    #[yaserde(rename = "CallAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "CallAmt"))]
    pub call_amt: ActiveOrHistoricCurrencyAnd19DecimalAmount,

    #[yaserde(rename = "PutAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "PutAmt"))]
    pub put_amt: ActiveOrHistoricCurrencyAnd19DecimalAmount,

    #[yaserde(rename = "PrmAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "PrmAmt"))]
    pub prm_amt: ActiveOrHistoricCurrencyAnd19DecimalAmount,

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

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

    #[yaserde(rename = "BrrrLvls")]
    #[cfg_attr(feature = "serde", serde(rename = "BrrrLvls"))]
    pub brrr_lvls: OptionBarrierLevel1Choice,
}

impl Validate for OptionOrSwaption11 {}


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

pub enum OptionParty1Code {
    #[yaserde(rename = "SLLR")]
    #[cfg_attr(feature = "serde", serde(rename = "SLLR"))]
    Sllr,
    #[yaserde(rename = "BYER")]
    #[cfg_attr(feature = "serde", serde(rename = "BYER"))]
    Byer,
    __Unknown__(String),
}

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

impl Validate for OptionParty1Code {}



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

pub enum OptionParty3Code {
    #[yaserde(rename = "MAKE")]
    #[cfg_attr(feature = "serde", serde(rename = "MAKE"))]
    Make,
    #[yaserde(rename = "TAKE")]
    #[cfg_attr(feature = "serde", serde(rename = "TAKE"))]
    Take,
    __Unknown__(String),
}

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

impl Validate for OptionParty3Code {}



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

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

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

impl Validate for OptionStyle6Code {}



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

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.030.001.04")]
pub struct OrganisationIdentification15Choice {
    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Option<Leiidentifier>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<OrganisationIdentification38>,
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_b_i_c: Option<AnyBICDec2014Identifier>,
}

impl Validate for OrganisationIdentification15Choice {}




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

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

    #[yaserde(rename = "Dmcl")]
    #[cfg_attr(feature = "serde", serde(rename = "Dmcl"))]
    pub dmcl: Max500Text,
}

impl Validate for OrganisationIdentification38 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct OtherPayment5 {
    #[yaserde(rename = "PmtAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtAmt"))]
    pub pmt_amt: AmountAndDirection106,

    #[yaserde(rename = "PmtTp")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtTp"))]
    pub pmt_tp: PaymentType5Choice,

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

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

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

impl Validate for OtherPayment5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct Ptrrevent2 {
    #[yaserde(rename = "Tchnq")]
    #[cfg_attr(feature = "serde", serde(rename = "Tchnq"))]
    pub tchnq: RiskReductionService1Code,

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

impl Validate for Ptrrevent2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct Package4 {
    #[yaserde(rename = "CmplxTradId")]
    #[cfg_attr(feature = "serde", serde(rename = "CmplxTradId"))]
    pub cmplx_trad_id: Max100Text,

    #[yaserde(rename = "FxSwpLkId")]
    #[cfg_attr(feature = "serde", serde(rename = "FxSwpLkId"))]
    pub fx_swp_lk_id: Max100Text,

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

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

impl Validate for Package4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct Pagination1 {
    #[yaserde(rename = "PgNb")]
    #[cfg_attr(feature = "serde", serde(rename = "PgNb"))]
    pub pg_nb: Max5NumericText,

    #[yaserde(rename = "LastPgInd")]
    #[cfg_attr(feature = "serde", serde(rename = "LastPgInd"))]
    pub last_pg_ind: YesNoIndicator,
}

impl Validate for Pagination1 {}


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


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


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

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

impl Validate for PaperCommodityOther1 {}


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


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

impl Validate for PaperCommodityRecoveredPaper3 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct PartyIdentification236Choice {
    #[yaserde(rename = "Lgl")]
    #[cfg_attr(feature = "serde", serde(rename = "Lgl"))]
    pub lgl: Option<OrganisationIdentification15Choice>,
    #[yaserde(rename = "Ntrl")]
    #[cfg_attr(feature = "serde", serde(rename = "Ntrl"))]
    pub ntrl: Option<NaturalPersonIdentification2>,
}

impl Validate for PartyIdentification236Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct PartyIdentification248Choice {
    #[yaserde(rename = "Lgl")]
    #[cfg_attr(feature = "serde", serde(rename = "Lgl"))]
    pub lgl: Option<LegalPersonIdentification1>,
    #[yaserde(rename = "Ntrl")]
    #[cfg_attr(feature = "serde", serde(rename = "Ntrl"))]
    pub ntrl: Option<NaturalPersonIdentification3>,
}

impl Validate for PartyIdentification248Choice {}




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

pub enum PaymentType4Code {
    #[yaserde(rename = "UFRO")]
    #[cfg_attr(feature = "serde", serde(rename = "UFRO"))]
    Ufro,
    #[yaserde(rename = "UWIN")]
    #[cfg_attr(feature = "serde", serde(rename = "UWIN"))]
    Uwin,
    #[yaserde(rename = "PEXH")]
    #[cfg_attr(feature = "serde", serde(rename = "PEXH"))]
    Pexh,
    __Unknown__(String),
}

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

impl Validate for PaymentType4Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct PaymentType5Choice {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: Option<PaymentType4Code>,
    #[yaserde(rename = "PrtryTp")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryTp"))]
    pub prtry_tp: Option<Max4AlphaNumericText>,
}

impl Validate for PaymentType5Choice {}




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

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

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

impl Validate for PolypropyleneCommodityOther2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct PolypropyleneCommodityPlastic2 {
    #[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 PolypropyleneCommodityPlastic2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct PortfolioCode3Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<Max52Text>,
    #[yaserde(rename = "NoPrtfl")]
    #[cfg_attr(feature = "serde", serde(rename = "NoPrtfl"))]
    pub no_prtfl: Option<NotApplicable1Code>,
}

impl Validate for PortfolioCode3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct PortfolioCode5Choice {
    #[yaserde(rename = "Prtfl")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtfl"))]
    pub prtfl: Option<PortfolioIdentification3>,
    #[yaserde(rename = "NoPrtfl")]
    #[cfg_attr(feature = "serde", serde(rename = "NoPrtfl"))]
    pub no_prtfl: Option<NotApplicable1Code>,
}

impl Validate for PortfolioCode5Choice {}




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

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

impl Validate for PortfolioIdentification3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct PostTradeRiskReductionIdentifier1 {
    #[yaserde(rename = "Strr")]
    #[cfg_attr(feature = "serde", serde(rename = "Strr"))]
    pub strr: Leiidentifier,

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

impl Validate for PostTradeRiskReductionIdentifier1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct PriceData2 {
    #[yaserde(rename = "Pric")]
    #[cfg_attr(feature = "serde", serde(rename = "Pric"))]
    pub pric: SecuritiesTransactionPrice17Choice,

    #[yaserde(rename = "SchdlPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "SchdlPrd"))]
    pub schdl_prd: Vec<Schedule1>,

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

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

impl Validate for PriceData2 {}


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

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.030.001.04")]

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

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

impl Validate for PriceStatus2Code {}



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

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

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

impl Validate for ProductType4Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct Quantity47Choice {
    #[yaserde(rename = "Qty")]
    #[cfg_attr(feature = "serde", serde(rename = "Qty"))]
    pub qty: Option<LongFraction19DecimalNumber>,
    #[yaserde(rename = "Desc")]
    #[cfg_attr(feature = "serde", serde(rename = "Desc"))]
    pub desc: Option<Max52Text>,
}

impl Validate for Quantity47Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct QuantityOrTerm1Choice {
    #[yaserde(rename = "SchdlPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "SchdlPrd"))]
    pub schdl_prd: Vec<Schedule10>,
    #[yaserde(rename = "Term")]
    #[cfg_attr(feature = "serde", serde(rename = "Term"))]
    pub term: Option<QuantityTerm1>,
}

impl Validate for QuantityOrTerm1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct QuantityTerm1 {
    #[yaserde(rename = "Qty")]
    #[cfg_attr(feature = "serde", serde(rename = "Qty"))]
    pub qty: LongFraction19DecimalNumber,

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

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

    #[yaserde(rename = "TmUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "TmUnit"))]
    pub tm_unit: Frequency19Code,
}

impl Validate for QuantityTerm1 {}


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

pub enum Reconciliation3Code {
    #[yaserde(rename = "DPRW")]
    #[cfg_attr(feature = "serde", serde(rename = "DPRW"))]
    Dprw,
    #[yaserde(rename = "DPRV")]
    #[cfg_attr(feature = "serde", serde(rename = "DPRV"))]
    Dprv,
    #[yaserde(rename = "DSMA")]
    #[cfg_attr(feature = "serde", serde(rename = "DSMA"))]
    Dsma,
    #[yaserde(rename = "DSNM")]
    #[cfg_attr(feature = "serde", serde(rename = "DSNM"))]
    Dsnm,
    #[yaserde(rename = "NORE")]
    #[cfg_attr(feature = "serde", serde(rename = "NORE"))]
    Nore,
    #[yaserde(rename = "SSMA")]
    #[cfg_attr(feature = "serde", serde(rename = "SSMA"))]
    Ssma,
    #[yaserde(rename = "SSPA")]
    #[cfg_attr(feature = "serde", serde(rename = "SSPA"))]
    Sspa,
    #[yaserde(rename = "SPRW")]
    #[cfg_attr(feature = "serde", serde(rename = "SPRW"))]
    Sprw,
    #[yaserde(rename = "SPRV")]
    #[cfg_attr(feature = "serde", serde(rename = "SPRV"))]
    Sprv,
    #[yaserde(rename = "SSUN")]
    #[cfg_attr(feature = "serde", serde(rename = "SSUN"))]
    Ssun,
    #[yaserde(rename = "SSNE")]
    #[cfg_attr(feature = "serde", serde(rename = "SSNE"))]
    Ssne,
    __Unknown__(String),
}

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

impl Validate for Reconciliation3Code {}



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

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

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

impl Validate for ReportPeriodActivity1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct ReportingExemption1 {
    #[yaserde(rename = "Rsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
    pub rsn: Max4Text,

    #[yaserde(rename = "Desc")]
    #[cfg_attr(feature = "serde", serde(rename = "Desc"))]
    pub desc: Max1000Text,
}

impl Validate for ReportingExemption1 {}


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

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

impl Validate for ResetDateAndValue1 {}


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

pub enum RiskReductionService1Code {
    #[yaserde(rename = "NORR")]
    #[cfg_attr(feature = "serde", serde(rename = "NORR"))]
    Norr,
    #[yaserde(rename = "PWOS")]
    #[cfg_attr(feature = "serde", serde(rename = "PWOS"))]
    Pwos,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "PRBM")]
    #[cfg_attr(feature = "serde", serde(rename = "PRBM"))]
    Prbm,
    #[yaserde(rename = "PWAS")]
    #[cfg_attr(feature = "serde", serde(rename = "PWAS"))]
    Pwas,
    __Unknown__(String),
}

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

impl Validate for RiskReductionService1Code {}



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

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

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

impl Validate for Schedule1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct Schedule10 {
    #[yaserde(rename = "Qty")]
    #[cfg_attr(feature = "serde", serde(rename = "Qty"))]
    pub qty: LongFraction19DecimalNumber,

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

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

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

impl Validate for Schedule10 {}


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

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

    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: AmountAndDirection106,
}

impl Validate for Schedule11 {}


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

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

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

impl Validate for Schedule4 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct SecuritiesTransactionPrice14Choice {
    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: Option<PercentageRate>,
    #[yaserde(rename = "Dcml")]
    #[cfg_attr(feature = "serde", serde(rename = "Dcml"))]
    pub dcml: Option<BaseOneRate>,
}

impl Validate for SecuritiesTransactionPrice14Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct SecuritiesTransactionPrice17Choice {
    #[yaserde(rename = "MntryVal")]
    #[cfg_attr(feature = "serde", serde(rename = "MntryVal"))]
    pub mntry_val: Option<AmountAndDirection106>,
    #[yaserde(rename = "Unit")]
    #[cfg_attr(feature = "serde", serde(rename = "Unit"))]
    pub unit: Option<LongFraction19DecimalNumber>,
    #[yaserde(rename = "Pctg")]
    #[cfg_attr(feature = "serde", serde(rename = "Pctg"))]
    pub pctg: Option<PercentageRate>,
    #[yaserde(rename = "Yld")]
    #[cfg_attr(feature = "serde", serde(rename = "Yld"))]
    pub yld: Option<PercentageRate>,
    #[yaserde(rename = "Dcml")]
    #[cfg_attr(feature = "serde", serde(rename = "Dcml"))]
    pub dcml: Option<BaseOneRate>,
    #[yaserde(rename = "PdgPric")]
    #[cfg_attr(feature = "serde", serde(rename = "PdgPric"))]
    pub pdg_pric: Option<PriceStatus1Code>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<SecuritiesTransactionPrice5>,
}

impl Validate for SecuritiesTransactionPrice17Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct SecuritiesTransactionPrice20Choice {
    #[yaserde(rename = "MntryVal")]
    #[cfg_attr(feature = "serde", serde(rename = "MntryVal"))]
    pub mntry_val: Option<AmountAndDirection106>,
    #[yaserde(rename = "Pctg")]
    #[cfg_attr(feature = "serde", serde(rename = "Pctg"))]
    pub pctg: Option<PercentageRate>,
    #[yaserde(rename = "Dcml")]
    #[cfg_attr(feature = "serde", serde(rename = "Dcml"))]
    pub dcml: Option<BaseOneRate>,
    #[yaserde(rename = "BsisPtSprd")]
    #[cfg_attr(feature = "serde", serde(rename = "BsisPtSprd"))]
    pub bsis_pt_sprd: Option<Number>,
}

impl Validate for SecuritiesTransactionPrice20Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct SecuritiesTransactionPrice23Choice {
    #[yaserde(rename = "MntryVal")]
    #[cfg_attr(feature = "serde", serde(rename = "MntryVal"))]
    pub mntry_val: Option<AmountAndDirection106>,
    #[yaserde(rename = "Unit")]
    #[cfg_attr(feature = "serde", serde(rename = "Unit"))]
    pub unit: Option<LongFraction19DecimalNumber>,
    #[yaserde(rename = "Pctg")]
    #[cfg_attr(feature = "serde", serde(rename = "Pctg"))]
    pub pctg: Option<PercentageRate>,
    #[yaserde(rename = "Yld")]
    #[cfg_attr(feature = "serde", serde(rename = "Yld"))]
    pub yld: Option<PercentageRate>,
    #[yaserde(rename = "Dcml")]
    #[cfg_attr(feature = "serde", serde(rename = "Dcml"))]
    pub dcml: Option<BaseOneRate>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<SecuritiesTransactionPrice5>,
}

impl Validate for SecuritiesTransactionPrice23Choice {}




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

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

impl Validate for SecuritiesTransactionPrice5 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct SecurityIdentification41Choice {
    #[yaserde(rename = "ISIN")]
    #[cfg_attr(feature = "serde", serde(rename = "ISIN"))]
    pub isin: Option<Isinoct2015Identifier>,
    #[yaserde(rename = "AltrntvInstrmId")]
    #[cfg_attr(feature = "serde", serde(rename = "AltrntvInstrmId"))]
    pub altrntv_instrm_id: Option<Max52Text>,
    #[yaserde(rename = "UnqPdctIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "UnqPdctIdr"))]
    pub unq_pdct_idr: Option<UniqueProductIdentifier2Choice>,
    #[yaserde(rename = "Bskt")]
    #[cfg_attr(feature = "serde", serde(rename = "Bskt"))]
    pub bskt: Option<CustomBasket4>,
    #[yaserde(rename = "Indx")]
    #[cfg_attr(feature = "serde", serde(rename = "Indx"))]
    pub indx: Option<IndexIdentification1>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<GenericIdentification184>,
    #[yaserde(rename = "IdNotAvlbl")]
    #[cfg_attr(feature = "serde", serde(rename = "IdNotAvlbl"))]
    pub id_not_avlbl: Option<UnderlyingIdentification1Code>,
}

impl Validate for SecurityIdentification41Choice {}




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

    #[yaserde(rename = "UnqPdctIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "UnqPdctIdr"))]
    pub unq_pdct_idr: UniqueProductIdentifier2Choice,

    #[yaserde(rename = "AltrntvInstrmId")]
    #[cfg_attr(feature = "serde", serde(rename = "AltrntvInstrmId"))]
    pub altrntv_instrm_id: Max105Text,

    #[yaserde(rename = "PdctDesc")]
    #[cfg_attr(feature = "serde", serde(rename = "PdctDesc"))]
    pub pdct_desc: Max1000Text,
}

impl Validate for SecurityIdentification46 {}


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

impl Validate for SupplementaryDataEnvelope1 {}


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

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

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

impl Validate for TechnicalAttributes5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct TimePeriodDetails1 {
    #[yaserde(rename = "FrTm")]
    #[cfg_attr(feature = "serde", serde(rename = "FrTm"))]
    pub fr_tm: Isotime,

    #[yaserde(rename = "ToTm")]
    #[cfg_attr(feature = "serde", serde(rename = "ToTm"))]
    pub to_tm: Isotime,
}

impl Validate for TimePeriodDetails1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct TradeClearing11 {
    #[yaserde(rename = "ClrOblgtn")]
    #[cfg_attr(feature = "serde", serde(rename = "ClrOblgtn"))]
    pub clr_oblgtn: ClearingObligationType1Code,

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

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

impl Validate for TradeClearing11 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct TradeConfirmation4Choice {
    #[yaserde(rename = "Confd")]
    #[cfg_attr(feature = "serde", serde(rename = "Confd"))]
    pub confd: Option<TradeConfirmation5>,
    #[yaserde(rename = "NonConfd")]
    #[cfg_attr(feature = "serde", serde(rename = "NonConfd"))]
    pub non_confd: Option<TradeNonConfirmation1>,
}

impl Validate for TradeConfirmation4Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct TradeConfirmation5 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: TradeConfirmationType1Code,

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

impl Validate for TradeConfirmation5 {}


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

pub enum TradeConfirmationType1Code {
    #[yaserde(rename = "ECNF")]
    #[cfg_attr(feature = "serde", serde(rename = "ECNF"))]
    Ecnf,
    #[yaserde(rename = "YCNF")]
    #[cfg_attr(feature = "serde", serde(rename = "YCNF"))]
    Ycnf,
    __Unknown__(String),
}

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

impl Validate for TradeConfirmationType1Code {}



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

pub enum TradeConfirmationType2Code {
    #[yaserde(rename = "NCNF")]
    #[cfg_attr(feature = "serde", serde(rename = "NCNF"))]
    Ncnf,
    __Unknown__(String),
}

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

impl Validate for TradeConfirmationType2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct TradeCounterpartyRelationship1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ExternalPartyRelationshipType1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max100Text>,
}

impl Validate for TradeCounterpartyRelationship1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct TradeCounterpartyRelationshipRecord1 {
    #[yaserde(rename = "StartRltshPty")]
    #[cfg_attr(feature = "serde", serde(rename = "StartRltshPty"))]
    pub start_rltsh_pty: TradeCounterpartyType1Code,

    #[yaserde(rename = "EndRltshPty")]
    #[cfg_attr(feature = "serde", serde(rename = "EndRltshPty"))]
    pub end_rltsh_pty: TradeCounterpartyType1Code,

    #[yaserde(rename = "RltshTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RltshTp"))]
    pub rltsh_tp: TradeCounterpartyRelationship1Choice,

    #[yaserde(rename = "Desc")]
    #[cfg_attr(feature = "serde", serde(rename = "Desc"))]
    pub desc: Max1000Text,
}

impl Validate for TradeCounterpartyRelationshipRecord1 {}


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

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

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

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

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

    #[yaserde(rename = "Bnfcry")]
    #[cfg_attr(feature = "serde", serde(rename = "Bnfcry"))]
    pub bnfcry: Vec<PartyIdentification248Choice>,

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

    #[yaserde(rename = "ExctnAgt")]
    #[cfg_attr(feature = "serde", serde(rename = "ExctnAgt"))]
    pub exctn_agt: Vec<OrganisationIdentification15Choice>,

    #[yaserde(rename = "RltshRcrd")]
    #[cfg_attr(feature = "serde", serde(rename = "RltshRcrd"))]
    pub rltsh_rcrd: Vec<TradeCounterpartyRelationshipRecord1>,
}

impl Validate for TradeCounterpartyReport20 {}


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

pub enum TradeCounterpartyType1Code {
    #[yaserde(rename = "BENE")]
    #[cfg_attr(feature = "serde", serde(rename = "BENE"))]
    Bene,
    #[yaserde(rename = "BROK")]
    #[cfg_attr(feature = "serde", serde(rename = "BROK"))]
    Brok,
    #[yaserde(rename = "CLEM")]
    #[cfg_attr(feature = "serde", serde(rename = "CLEM"))]
    Clem,
    #[yaserde(rename = "EXEA")]
    #[cfg_attr(feature = "serde", serde(rename = "EXEA"))]
    Exea,
    #[yaserde(rename = "OTHC")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHC"))]
    Othc,
    #[yaserde(rename = "REPC")]
    #[cfg_attr(feature = "serde", serde(rename = "REPC"))]
    Repc,
    #[yaserde(rename = "SBMA")]
    #[cfg_attr(feature = "serde", serde(rename = "SBMA"))]
    Sbma,
    #[yaserde(rename = "ERFR")]
    #[cfg_attr(feature = "serde", serde(rename = "ERFR"))]
    Erfr,
    __Unknown__(String),
}

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

impl Validate for TradeCounterpartyType1Code {}



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

    #[yaserde(rename = "CmonTradData")]
    #[cfg_attr(feature = "serde", serde(rename = "CmonTradData"))]
    pub cmon_trad_data: CommonTradeDataReport71,

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

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

    #[yaserde(rename = "PblcDssmntnData")]
    #[cfg_attr(feature = "serde", serde(rename = "PblcDssmntnData"))]
    pub pblc_dssmntn_data: DisseminationData1,

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

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

impl Validate for TradeData59Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct TradeNonConfirmation1 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: TradeConfirmationType2Code,
}

impl Validate for TradeNonConfirmation1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct TradeReport33Choice {
    #[yaserde(rename = "New")]
    #[cfg_attr(feature = "serde", serde(rename = "New"))]
    pub new: Option<TradeData43>,
    #[yaserde(rename = "Mod")]
    #[cfg_attr(feature = "serde", serde(rename = "Mod"))]
    pub r#mod: Option<TradeData43>,
    #[yaserde(rename = "Crrctn")]
    #[cfg_attr(feature = "serde", serde(rename = "Crrctn"))]
    pub crrctn: Option<TradeData43>,
    #[yaserde(rename = "Termntn")]
    #[cfg_attr(feature = "serde", serde(rename = "Termntn"))]
    pub termntn: Option<TradeData43>,
    #[yaserde(rename = "PosCmpnt")]
    #[cfg_attr(feature = "serde", serde(rename = "PosCmpnt"))]
    pub pos_cmpnt: Option<TradeData43>,
    #[yaserde(rename = "ValtnUpd")]
    #[cfg_attr(feature = "serde", serde(rename = "ValtnUpd"))]
    pub valtn_upd: Option<TradeData43>,
    #[yaserde(rename = "Cmprssn")]
    #[cfg_attr(feature = "serde", serde(rename = "Cmprssn"))]
    pub cmprssn: Option<TradeData43>,
    #[yaserde(rename = "Err")]
    #[cfg_attr(feature = "serde", serde(rename = "Err"))]
    pub err: Option<TradeData43>,
    #[yaserde(rename = "PortOut")]
    #[cfg_attr(feature = "serde", serde(rename = "PortOut"))]
    pub port_out: Option<TradeData43>,
    #[yaserde(rename = "Rvv")]
    #[cfg_attr(feature = "serde", serde(rename = "Rvv"))]
    pub rvv: Option<TradeData43>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<TradeData43>,
}

impl Validate for TradeReport33Choice {}




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

    #[yaserde(rename = "MsgPgntn")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgPgntn"))]
    pub msg_pgntn: Pagination1,

    #[yaserde(rename = "NbRcrds")]
    #[cfg_attr(feature = "serde", serde(rename = "NbRcrds"))]
    pub nb_rcrds: Number,

    #[yaserde(rename = "CmptntAuthrty")]
    #[cfg_attr(feature = "serde", serde(rename = "CmptntAuthrty"))]
    pub cmptnt_authrty: Vec<Max100Text>,

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

    #[yaserde(rename = "RptgPurp")]
    #[cfg_attr(feature = "serde", serde(rename = "RptgPurp"))]
    pub rptg_purp: Vec<Max100Text>,
}

impl Validate for TradeReportHeader4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct TradeTransaction50 {
    #[yaserde(rename = "TxId")]
    #[cfg_attr(feature = "serde", serde(rename = "TxId"))]
    pub tx_id: UniqueTransactionIdentifier2Choice,

    #[yaserde(rename = "ScndryTxId")]
    #[cfg_attr(feature = "serde", serde(rename = "ScndryTxId"))]
    pub scndry_tx_id: Max72Text,

    #[yaserde(rename = "PrrTxId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrrTxId"))]
    pub prr_tx_id: UniqueTransactionIdentifier3Choice,

    #[yaserde(rename = "SbsqntTxId")]
    #[cfg_attr(feature = "serde", serde(rename = "SbsqntTxId"))]
    pub sbsqnt_tx_id: UniqueTransactionIdentifier3Choice,

    #[yaserde(rename = "CollPrtflCd")]
    #[cfg_attr(feature = "serde", serde(rename = "CollPrtflCd"))]
    pub coll_prtfl_cd: CollateralPortfolioCode6Choice,

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

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

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

    #[yaserde(rename = "TxPric")]
    #[cfg_attr(feature = "serde", serde(rename = "TxPric"))]
    pub tx_pric: PriceData2,

    #[yaserde(rename = "NtnlAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "NtnlAmt"))]
    pub ntnl_amt: NotionalAmountLegs5,

    #[yaserde(rename = "NtnlQty")]
    #[cfg_attr(feature = "serde", serde(rename = "NtnlQty"))]
    pub ntnl_qty: NotionalQuantityLegs5,

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

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

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

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

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

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

    #[yaserde(rename = "SttlmDt")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmDt"))]
    pub sttlm_dt: Vec<Isodate>,

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

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

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

    #[yaserde(rename = "PstTradRskRdctnEvt")]
    #[cfg_attr(feature = "serde", serde(rename = "PstTradRskRdctnEvt"))]
    pub pst_trad_rsk_rdctn_evt: Ptrrevent2,

    #[yaserde(rename = "DerivEvt")]
    #[cfg_attr(feature = "serde", serde(rename = "DerivEvt"))]
    pub deriv_evt: DerivativeEvent6,

    #[yaserde(rename = "TradConf")]
    #[cfg_attr(feature = "serde", serde(rename = "TradConf"))]
    pub trad_conf: TradeConfirmation4Choice,

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

    #[yaserde(rename = "TradClr")]
    #[cfg_attr(feature = "serde", serde(rename = "TradClr"))]
    pub trad_clr: TradeClearing11,

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

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

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

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

    #[yaserde(rename = "Cmmdty")]
    #[cfg_attr(feature = "serde", serde(rename = "Cmmdty"))]
    pub cmmdty: AssetClassCommodity7Choice,

    #[yaserde(rename = "Optn")]
    #[cfg_attr(feature = "serde", serde(rename = "Optn"))]
    pub optn: OptionOrSwaption11,

    #[yaserde(rename = "NrgySpcfcAttrbts")]
    #[cfg_attr(feature = "serde", serde(rename = "NrgySpcfcAttrbts"))]
    pub nrgy_spcfc_attrbts: EnergySpecificAttribute9,

    #[yaserde(rename = "Cdt")]
    #[cfg_attr(feature = "serde", serde(rename = "Cdt"))]
    pub cdt: CreditDerivative4,

    #[yaserde(rename = "OthrPmt")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrPmt"))]
    pub othr_pmt: Vec<OtherPayment5>,

    #[yaserde(rename = "Packg")]
    #[cfg_attr(feature = "serde", serde(rename = "Packg"))]
    pub packg: Package4,

    #[yaserde(rename = "TradAllcnSts")]
    #[cfg_attr(feature = "serde", serde(rename = "TradAllcnSts"))]
    pub trad_allcn_sts: AllocationIndicator1Code,
}

impl Validate for TradeTransaction50 {}


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

pub enum TradingCapacity7Code {
    #[yaserde(rename = "AGEN")]
    #[cfg_attr(feature = "serde", serde(rename = "AGEN"))]
    Agen,
    #[yaserde(rename = "PRIN")]
    #[cfg_attr(feature = "serde", serde(rename = "PRIN"))]
    Prin,
    __Unknown__(String),
}

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

impl Validate for TradingCapacity7Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct Tranche3 {
    #[yaserde(rename = "AttchmntPt")]
    #[cfg_attr(feature = "serde", serde(rename = "AttchmntPt"))]
    pub attchmnt_pt: BaseOneRate,

    #[yaserde(rename = "DtchmntPt")]
    #[cfg_attr(feature = "serde", serde(rename = "DtchmntPt"))]
    pub dtchmnt_pt: BaseOneRate,
}

impl Validate for Tranche3 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct TrancheIndicator3Choice {
    #[yaserde(rename = "Trnchd")]
    #[cfg_attr(feature = "serde", serde(rename = "Trnchd"))]
    pub trnchd: Option<Tranche3>,
    #[yaserde(rename = "Utrnchd")]
    #[cfg_attr(feature = "serde", serde(rename = "Utrnchd"))]
    pub utrnchd: Option<NoReasonCode>,
}

impl Validate for TrancheIndicator3Choice {}




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

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

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

pub enum UnderlyingIdentification1Code {
    #[yaserde(rename = "UKWN")]
    #[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
    Ukwn,
    #[yaserde(rename = "BSKT")]
    #[cfg_attr(feature = "serde", serde(rename = "BSKT"))]
    Bskt,
    #[yaserde(rename = "INDX")]
    #[cfg_attr(feature = "serde", serde(rename = "INDX"))]
    Indx,
    __Unknown__(String),
}

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

impl Validate for UnderlyingIdentification1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct UniqueProductIdentifier1Choice {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Option<Max52Text>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification175>,
}

impl Validate for UniqueProductIdentifier1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct UniqueProductIdentifier2Choice {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Option<Max52Text>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification185>,
}

impl Validate for UniqueProductIdentifier2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct UniqueTransactionIdentifier1Choice {
    #[yaserde(rename = "UnqTxIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "UnqTxIdr"))]
    pub unq_tx_idr: Option<Utiidentifier>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification179>,
}

impl Validate for UniqueTransactionIdentifier1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct UniqueTransactionIdentifier2Choice {
    #[yaserde(rename = "UnqTxIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "UnqTxIdr"))]
    pub unq_tx_idr: Option<Utiidentifier>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification175>,
}

impl Validate for UniqueTransactionIdentifier2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct UniqueTransactionIdentifier3Choice {
    #[yaserde(rename = "UnqTxIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "UnqTxIdr"))]
    pub unq_tx_idr: Option<Utiidentifier>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification175>,
    #[yaserde(rename = "NotAvlbl")]
    #[cfg_attr(feature = "serde", serde(rename = "NotAvlbl"))]
    pub not_avlbl: Option<NoReasonCode>,
}

impl Validate for UniqueTransactionIdentifier3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.030.001.04")]
pub struct UnitOfMeasure8Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ExternalUnitOfMeasure1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification175>,
}

impl Validate for UnitOfMeasure8Choice {}




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

pub enum ValuationType1Code {
    #[yaserde(rename = "CCPV")]
    #[cfg_attr(feature = "serde", serde(rename = "CCPV"))]
    Ccpv,
    #[yaserde(rename = "MTMA")]
    #[cfg_attr(feature = "serde", serde(rename = "MTMA"))]
    Mtma,
    #[yaserde(rename = "MTMO")]
    #[cfg_attr(feature = "serde", serde(rename = "MTMO"))]
    Mtmo,
    __Unknown__(String),
}

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

impl Validate for ValuationType1Code {}



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

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

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

impl Validate for WeekDay3Code {}



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

impl Validate for YesNoIndicator {}

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