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.091.001.03")]
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.091.001.03")]
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.091.001.03")]
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.091.001.03")]
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.091.001.03")]
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.091.001.03")]
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.091.001.03")]
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.091.001.03")]
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.091.001.03")]
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.091.001.03")]
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.091.001.03")]
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.091.001.03")]
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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
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)]
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.091.001.03")]
pub struct AssetClassCommodity6Choice {
    #[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<AssetClassCommodityPaper4Choice>,
    #[yaserde(rename = "Plprpln")]
    #[cfg_attr(feature = "serde", serde(rename = "Plprpln"))]
    pub plprpln: Option<AssetClassCommodityPolypropylene4Choice>,
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.091.001.03")]
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.091.001.03")]
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.091.001.03")]
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.091.001.03")]
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.091.001.03")]
pub struct CollateralPortfolioCode5Choice {
    #[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<MarginPortfolio3>,
}

impl Validate for CollateralPortfolioCode5Choice {}




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

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

impl Validate for CompareActiveOrHistoricCurrencyAndAmount4 {}


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

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

impl Validate for CompareActiveOrHistoricCurrencyCode1 {}


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

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

impl Validate for CompareAmountAndDirection3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct CompareAssetClass1 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: ProductType4Code,

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

impl Validate for CompareAssetClass1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct CompareBenchmarkCode1 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: ExternalBenchmarkCurveName1Code,

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

impl Validate for CompareBenchmarkCode1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct CompareCFIIdentifier3 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: Cfioct2015Identifier,

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

impl Validate for CompareCFIIdentifier3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct CompareCommodityAssetClass4 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: AssetClassCommodity6Choice,

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

impl Validate for CompareCommodityAssetClass4 {}


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

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

impl Validate for CompareDate3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct CompareDatePeriod2 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: DatePeriod4,

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

impl Validate for CompareDatePeriod2 {}


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

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

impl Validate for CompareDateTime3 {}


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

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

impl Validate for CompareDayCount1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct CompareDeliveryInterconnectionPoint1 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: DeliveryInterconnectionPoint1Choice,

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

impl Validate for CompareDeliveryInterconnectionPoint1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct CompareDeliveryType1 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: PhysicalTransferType4Code,

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

impl Validate for CompareDeliveryType1 {}


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

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

impl Validate for CompareDerivativeEvent1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct CompareDurationType1 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: DurationType1Code,

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

impl Validate for CompareDurationType1 {}


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

    #[yaserde(rename = "NrgyDt")]
    #[cfg_attr(feature = "serde", serde(rename = "NrgyDt"))]
    pub nrgy_dt: CompareDatePeriod2,

    #[yaserde(rename = "NrgyDrtn")]
    #[cfg_attr(feature = "serde", serde(rename = "NrgyDrtn"))]
    pub nrgy_drtn: CompareDurationType1,

    #[yaserde(rename = "NrgyWkDay")]
    #[cfg_attr(feature = "serde", serde(rename = "NrgyWkDay"))]
    pub nrgy_wk_day: Vec<CompareWeekDay1>,

    #[yaserde(rename = "NrgyDlvryCpcty")]
    #[cfg_attr(feature = "serde", serde(rename = "NrgyDlvryCpcty"))]
    pub nrgy_dlvry_cpcty: CompareLongFraction19DecimalNumber1,

    #[yaserde(rename = "NrgyQtyUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "NrgyQtyUnit"))]
    pub nrgy_qty_unit: CompareEnergyQuantityUnit1,

    #[yaserde(rename = "NrgyPricTmIntrvlQty")]
    #[cfg_attr(feature = "serde", serde(rename = "NrgyPricTmIntrvlQty"))]
    pub nrgy_pric_tm_intrvl_qty: CompareAmountAndDirection3,
}

impl Validate for CompareEnergyDeliveryAttribute1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct CompareEnergyLoadType1 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: EnergyLoadType1Code,

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

impl Validate for CompareEnergyLoadType1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct CompareEnergyQuantityUnit1 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: EnergyQuantityUnit2Choice,

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

impl Validate for CompareEnergyQuantityUnit1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct CompareExchangeRate1 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: BaseOne18Rate,

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

impl Validate for CompareExchangeRate1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct CompareExchangeRateBasis1 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: ExchangeRateBasis1Choice,

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

impl Validate for CompareExchangeRateBasis1 {}


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

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

impl Validate for CompareFinancialInstrumentContractType1 {}


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

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

impl Validate for CompareFrequencyUnit1 {}


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

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

impl Validate for CompareISINIdentifier2 {}


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

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

impl Validate for CompareISINIdentifier4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct CompareLegDirection2 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: Direction4Choice,

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

impl Validate for CompareLegDirection2 {}


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

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

impl Validate for CompareLongFraction19DecimalNumber1 {}


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

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

impl Validate for CompareMICIdentifier3 {}


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

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

impl Validate for CompareMasterAgreementType1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct CompareMax350Text1 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: Max350Text,

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

impl Validate for CompareMax350Text1 {}


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

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

impl Validate for CompareMax50Text1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct CompareNumber5 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: Max3Number,

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

impl Validate for CompareNumber5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct CompareNumber7 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: Number,

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

impl Validate for CompareNumber7 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct CompareOptionStyle1 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: OptionStyle6Code,

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

impl Validate for CompareOptionStyle1 {}


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

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

impl Validate for CompareOptionType1 {}


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

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

impl Validate for CompareOrganisationIdentification6 {}


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

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

impl Validate for CompareOrganisationIdentification7 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct CompareOtherPayment1 {
    #[yaserde(rename = "OthrPmtTp")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrPmtTp"))]
    pub othr_pmt_tp: CompareOtherPaymentType1,

    #[yaserde(rename = "OthrPmtAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrPmtAmt"))]
    pub othr_pmt_amt: CompareAmountAndDirection3,

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

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

    #[yaserde(rename = "OthrPmtRcvr")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrPmtRcvr"))]
    pub othr_pmt_rcvr: CompareOrganisationIdentification7,
}

impl Validate for CompareOtherPayment1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct CompareOtherPaymentType1 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: PaymentType5Choice,

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

impl Validate for CompareOtherPaymentType1 {}


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

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

impl Validate for ComparePercentageRate3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct ComparePostTradeRiskReduction2 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: Ptrrevent3,

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

impl Validate for ComparePostTradeRiskReduction2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct CompareReferenceParty1 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: DerivativePartyIdentification1Choice,

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

impl Validate for CompareReferenceParty1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct CompareReportingLevelType2 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: ModificationLevel1Code,

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

impl Validate for CompareReportingLevelType2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct CompareSeniorityType1 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: DebtInstrumentSeniorityType2Code,

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

impl Validate for CompareSeniorityType1 {}


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

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

impl Validate for CompareText1 {}


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

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

impl Validate for CompareText2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct CompareTimePeriod2 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: TimePeriod3,

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

impl Validate for CompareTimePeriod2 {}


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

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

impl Validate for CompareTradeClearingObligation1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct CompareTradeClearingStatus3 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: Cleared23Choice,

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

impl Validate for CompareTradeClearingStatus3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct CompareTradeConfirmation2 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: TradeConfirmation3Choice,

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

impl Validate for CompareTradeConfirmation2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct CompareTrancheIndicator1 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: TrancheIndicator3Choice,

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

impl Validate for CompareTrancheIndicator1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct CompareTrueFalseIndicator3 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: TrueFalseIndicator,

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

impl Validate for CompareTrueFalseIndicator3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct CompareUnderlyingInstrument3 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: SecurityIdentification41Choice,

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

impl Validate for CompareUnderlyingInstrument3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct CompareUniqueProductIdentifier2 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: UniqueProductIdentifier2Choice,

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

impl Validate for CompareUniqueProductIdentifier2 {}


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

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

impl Validate for CompareUniqueTransactionIdentifier2 {}


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

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

impl Validate for CompareUnitPrice4 {}


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

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

impl Validate for CompareUnitPrice5 {}


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

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

impl Validate for CompareUnitPrice7 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct CompareUnitPrice8 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: SecuritiesTransactionPrice13Choice,

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

impl Validate for CompareUnitPrice8 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct CompareValuationType1 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: ValuationType1Code,

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

impl Validate for CompareValuationType1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct CompareWeekDay1 {
    #[yaserde(rename = "Val1")]
    #[cfg_attr(feature = "serde", serde(rename = "Val1"))]
    pub val_1: WeekDay3Code,

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

impl Validate for CompareWeekDay1 {}


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

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

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

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

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

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

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

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

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

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

impl Validate for ContractMatchingCriteria3 {}


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

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

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

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

impl Validate for CounterpartyData91 {}


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

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

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

impl Validate for CounterpartyMatchingCriteria6 {}


#[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.091.001.03")]
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.091.001.03")]
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.091.001.03")]
pub struct DatePeriod4 {
    #[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 DatePeriod4 {}


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

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

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.091.001.03")]
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.091.001.03")]
pub struct DerivativesTradeReconciliationStatisticalReportV03 {
    #[yaserde(rename = "RcncltnSttstcs")]
    #[cfg_attr(feature = "serde", serde(rename = "RcncltnSttstcs"))]
    pub rcncltn_sttstcs: StatisticsPerCounterparty19Choice,

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

impl Validate for DerivativesTradeReconciliationStatisticalReportV03 {}


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

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

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

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

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

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

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

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.091.001.03")]
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)]
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.091.001.03")]
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.091.001.03")]
pub struct MarginPortfolio3 {
    #[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 MarginPortfolio3 {}


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

    #[yaserde(rename = "ValtnMtchgCrit")]
    #[cfg_attr(feature = "serde", serde(rename = "ValtnMtchgCrit"))]
    pub valtn_mtchg_crit: ValuationMatchingCriteria1,

    #[yaserde(rename = "CtrctMtchgCrit")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrctMtchgCrit"))]
    pub ctrct_mtchg_crit: ContractMatchingCriteria3,

    #[yaserde(rename = "TxMtchgCrit")]
    #[cfg_attr(feature = "serde", serde(rename = "TxMtchgCrit"))]
    pub tx_mtchg_crit: TransactionMatchingCriteria7,
}

impl Validate for MatchingCriteria17 {}


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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.091.001.03")]
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.091.001.03")]
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.091.001.03")]
pub struct Ptrrevent3 {
    #[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 Ptrrevent3 {}


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

pub enum PairingStatus1Code {
    #[yaserde(rename = "PARD")]
    #[cfg_attr(feature = "serde", serde(rename = "PARD"))]
    Pard,
    #[yaserde(rename = "UNPR")]
    #[cfg_attr(feature = "serde", serde(rename = "UNPR"))]
    Unpr,
    __Unknown__(String),
}

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

impl Validate for PairingStatus1Code {}



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

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

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

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

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.091.001.03")]
pub struct ReconciliationCategory4 {
    #[yaserde(rename = "Rvvd")]
    #[cfg_attr(feature = "serde", serde(rename = "Rvvd"))]
    pub rvvd: YesNoIndicator,

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

impl Validate for ReconciliationCategory4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct ReconciliationCategory5 {
    #[yaserde(rename = "RptgTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RptgTp"))]
    pub rptg_tp: TradeRepositoryReportingType1Code,

    #[yaserde(rename = "Pairg")]
    #[cfg_attr(feature = "serde", serde(rename = "Pairg"))]
    pub pairg: PairingStatus1Code,

    #[yaserde(rename = "Rcncltn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rcncltn"))]
    pub rcncltn: ReconciliationStatus1Code,

    #[yaserde(rename = "ValtnRcncltn")]
    #[cfg_attr(feature = "serde", serde(rename = "ValtnRcncltn"))]
    pub valtn_rcncltn: ReconciliationStatus2Code,

    #[yaserde(rename = "Rvvd")]
    #[cfg_attr(feature = "serde", serde(rename = "Rvvd"))]
    pub rvvd: YesNoIndicator,

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

impl Validate for ReconciliationCategory5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct ReconciliationCounterpartyPairStatistics7 {
    #[yaserde(rename = "CtrPtyId")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrPtyId"))]
    pub ctr_pty_id: CounterpartyData91,

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

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

impl Validate for ReconciliationCounterpartyPairStatistics7 {}


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

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

impl Validate for ReconciliationReport15 {}


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

    #[yaserde(rename = "RcncltnCtgrs")]
    #[cfg_attr(feature = "serde", serde(rename = "RcncltnCtgrs"))]
    pub rcncltn_ctgrs: ReportingRequirement3Choice,

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

    #[yaserde(rename = "TxDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "TxDtls"))]
    pub tx_dtls: Vec<ReconciliationCounterpartyPairStatistics7>,
}

impl Validate for ReconciliationStatisticsPerCounterparty4 {}


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

pub enum ReconciliationStatus1Code {
    #[yaserde(rename = "NREC")]
    #[cfg_attr(feature = "serde", serde(rename = "NREC"))]
    Nrec,
    #[yaserde(rename = "RECO")]
    #[cfg_attr(feature = "serde", serde(rename = "RECO"))]
    Reco,
    __Unknown__(String),
}

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

impl Validate for ReconciliationStatus1Code {}



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

pub enum ReconciliationStatus2Code {
    #[yaserde(rename = "NREC")]
    #[cfg_attr(feature = "serde", serde(rename = "NREC"))]
    Nrec,
    #[yaserde(rename = "RECO")]
    #[cfg_attr(feature = "serde", serde(rename = "RECO"))]
    Reco,
    #[yaserde(rename = "NOAP")]
    #[cfg_attr(feature = "serde", serde(rename = "NOAP"))]
    Noap,
    __Unknown__(String),
}

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

impl Validate for ReconciliationStatus2Code {}



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

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.091.001.03")]
pub struct ReportingRequirement3Choice {
    #[yaserde(rename = "RptgRqrmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "RptgRqrmnt"))]
    pub rptg_rqrmnt: Option<ReconciliationCategory5>,
    #[yaserde(rename = "NoRptgRqrmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "NoRptgRqrmnt"))]
    pub no_rptg_rqrmnt: Option<ReconciliationCategory4>,
}

impl Validate for ReportingRequirement3Choice {}




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

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

impl Validate for StatisticsPerCounterparty19Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
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.091.001.03")]
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.091.001.03")]
pub struct TimePeriod3 {
    #[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 TimePeriod3 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.091.001.03")]
pub struct TradeConfirmation3Choice {
    #[yaserde(rename = "Confd")]
    #[cfg_attr(feature = "serde", serde(rename = "Confd"))]
    pub confd: Option<TradeConfirmation4>,
    #[yaserde(rename = "NonConfd")]
    #[cfg_attr(feature = "serde", serde(rename = "NonConfd"))]
    pub non_confd: Option<TradeNonConfirmation1>,
}

impl Validate for TradeConfirmation3Choice {}




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


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

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

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

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

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

impl Validate for TradeRepositoryReportingType1Code {}



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

    #[yaserde(rename = "ActnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ActnTp"))]
    pub actn_tp: TransactionOperationType10Code,

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

    #[yaserde(rename = "DerivEvtTp")]
    #[cfg_attr(feature = "serde", serde(rename = "DerivEvtTp"))]
    pub deriv_evt_tp: DerivativeEventType3Code,

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

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

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

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

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

impl Validate for TradeTransactionIdentification24 {}


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

    #[yaserde(rename = "UnqTxIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "UnqTxIdr"))]
    pub unq_tx_idr: CompareUniqueTransactionIdentifier2,

    #[yaserde(rename = "PrrUnqTxIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "PrrUnqTxIdr"))]
    pub prr_unq_tx_idr: CompareUniqueTransactionIdentifier2,

    #[yaserde(rename = "SbsqntPosUnqTxIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "SbsqntPosUnqTxIdr"))]
    pub sbsqnt_pos_unq_tx_idr: CompareUniqueTransactionIdentifier2,

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

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

    #[yaserde(rename = "TradClrOblgtn")]
    #[cfg_attr(feature = "serde", serde(rename = "TradClrOblgtn"))]
    pub trad_clr_oblgtn: CompareTradeClearingObligation1,

    #[yaserde(rename = "TradClrSts")]
    #[cfg_attr(feature = "serde", serde(rename = "TradClrSts"))]
    pub trad_clr_sts: CompareTradeClearingStatus3,

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

    #[yaserde(rename = "MstrAgrmtVrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "MstrAgrmtVrsn"))]
    pub mstr_agrmt_vrsn: CompareMax50Text1,

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

    #[yaserde(rename = "PstTradRskRdctn")]
    #[cfg_attr(feature = "serde", serde(rename = "PstTradRskRdctn"))]
    pub pst_trad_rsk_rdctn: ComparePostTradeRiskReduction2,

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

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

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

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

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

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

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

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

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

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

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

    #[yaserde(rename = "TxSchdlPric")]
    #[cfg_attr(feature = "serde", serde(rename = "TxSchdlPric"))]
    pub tx_schdl_pric: Vec<CompareUnitPrice5>,

    #[yaserde(rename = "PackgPric")]
    #[cfg_attr(feature = "serde", serde(rename = "PackgPric"))]
    pub packg_pric: CompareUnitPrice5,

    #[yaserde(rename = "NtnlAmtFrstLeg")]
    #[cfg_attr(feature = "serde", serde(rename = "NtnlAmtFrstLeg"))]
    pub ntnl_amt_frst_leg: CompareAmountAndDirection3,

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

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

    #[yaserde(rename = "NtnlAmtFrstLegSchdlAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "NtnlAmtFrstLegSchdlAmt"))]
    pub ntnl_amt_frst_leg_schdl_amt: Vec<CompareAmountAndDirection3>,

    #[yaserde(rename = "NtnlQtyFrstLeg")]
    #[cfg_attr(feature = "serde", serde(rename = "NtnlQtyFrstLeg"))]
    pub ntnl_qty_frst_leg: CompareLongFraction19DecimalNumber1,

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

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

    #[yaserde(rename = "NtnlQtyFrstLegSchdlQty")]
    #[cfg_attr(feature = "serde", serde(rename = "NtnlQtyFrstLegSchdlQty"))]
    pub ntnl_qty_frst_leg_schdl_qty: Vec<CompareLongFraction19DecimalNumber1>,

    #[yaserde(rename = "NtnlAmtScndLeg")]
    #[cfg_attr(feature = "serde", serde(rename = "NtnlAmtScndLeg"))]
    pub ntnl_amt_scnd_leg: CompareAmountAndDirection3,

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

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

    #[yaserde(rename = "NtnlAmtScndLegSchdlAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "NtnlAmtScndLegSchdlAmt"))]
    pub ntnl_amt_scnd_leg_schdl_amt: Vec<CompareAmountAndDirection3>,

    #[yaserde(rename = "NtnlQtyScndLeg")]
    #[cfg_attr(feature = "serde", serde(rename = "NtnlQtyScndLeg"))]
    pub ntnl_qty_scnd_leg: CompareLongFraction19DecimalNumber1,

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

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

    #[yaserde(rename = "NtnlQtyScndLegSchdlQty")]
    #[cfg_attr(feature = "serde", serde(rename = "NtnlQtyScndLegSchdlQty"))]
    pub ntnl_qty_scnd_leg_schdl_qty: Vec<CompareLongFraction19DecimalNumber1>,

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

    #[yaserde(rename = "IntrstFxdRateFrstLeg")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstFxdRateFrstLeg"))]
    pub intrst_fxd_rate_frst_leg: CompareUnitPrice7,

    #[yaserde(rename = "IntrstFxdRateFrstLegDayCnt")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstFxdRateFrstLegDayCnt"))]
    pub intrst_fxd_rate_frst_leg_day_cnt: CompareDayCount1,

    #[yaserde(rename = "IntrstFxdRateFrstLegPmtFrqcyUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstFxdRateFrstLegPmtFrqcyUnit"))]
    pub intrst_fxd_rate_frst_leg_pmt_frqcy_unit: CompareFrequencyUnit1,

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

    #[yaserde(rename = "IntrstFltgRateFrstLegId")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstFltgRateFrstLegId"))]
    pub intrst_fltg_rate_frst_leg_id: CompareISINIdentifier4,

    #[yaserde(rename = "IntrstFltgRateFrstLegCd")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstFltgRateFrstLegCd"))]
    pub intrst_fltg_rate_frst_leg_cd: CompareBenchmarkCode1,

    #[yaserde(rename = "IntrstFltgRateFrstLegNm")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstFltgRateFrstLegNm"))]
    pub intrst_fltg_rate_frst_leg_nm: CompareMax350Text1,

    #[yaserde(rename = "IntrstFltgRateFrstLegDayCnt")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstFltgRateFrstLegDayCnt"))]
    pub intrst_fltg_rate_frst_leg_day_cnt: CompareDayCount1,

    #[yaserde(rename = "IntrstFltgRateFrstLegPmtFrqcyUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstFltgRateFrstLegPmtFrqcyUnit"))]
    pub intrst_fltg_rate_frst_leg_pmt_frqcy_unit: CompareFrequencyUnit1,

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

    #[yaserde(rename = "IntrstFltgRateFrstLegRefPrdUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstFltgRateFrstLegRefPrdUnit"))]
    pub intrst_fltg_rate_frst_leg_ref_prd_unit: CompareFrequencyUnit1,

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

    #[yaserde(rename = "IntrstFltgRateFrstLegRstFrqcyUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstFltgRateFrstLegRstFrqcyUnit"))]
    pub intrst_fltg_rate_frst_leg_rst_frqcy_unit: CompareFrequencyUnit1,

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

    #[yaserde(rename = "IntrstFltgRateFrstLegSprd")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstFltgRateFrstLegSprd"))]
    pub intrst_fltg_rate_frst_leg_sprd: CompareUnitPrice8,

    #[yaserde(rename = "IntrstRateFxdScndLeg")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstRateFxdScndLeg"))]
    pub intrst_rate_fxd_scnd_leg: CompareUnitPrice7,

    #[yaserde(rename = "IntrstFxdRateScndLegDayCnt")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstFxdRateScndLegDayCnt"))]
    pub intrst_fxd_rate_scnd_leg_day_cnt: CompareDayCount1,

    #[yaserde(rename = "IntrstFxdRateScndLegPmtFrqcyUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstFxdRateScndLegPmtFrqcyUnit"))]
    pub intrst_fxd_rate_scnd_leg_pmt_frqcy_unit: CompareFrequencyUnit1,

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

    #[yaserde(rename = "IntrstFltgRateScndLegId")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstFltgRateScndLegId"))]
    pub intrst_fltg_rate_scnd_leg_id: CompareISINIdentifier4,

    #[yaserde(rename = "IntrstFltgRateScndLegCd")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstFltgRateScndLegCd"))]
    pub intrst_fltg_rate_scnd_leg_cd: CompareBenchmarkCode1,

    #[yaserde(rename = "IntrstFltgRateScndLegNm")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstFltgRateScndLegNm"))]
    pub intrst_fltg_rate_scnd_leg_nm: CompareMax350Text1,

    #[yaserde(rename = "IntrstFltgRateScndLegDayCnt")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstFltgRateScndLegDayCnt"))]
    pub intrst_fltg_rate_scnd_leg_day_cnt: CompareDayCount1,

    #[yaserde(rename = "IntrstFltgRateScndLegPmtFrqcyUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstFltgRateScndLegPmtFrqcyUnit"))]
    pub intrst_fltg_rate_scnd_leg_pmt_frqcy_unit: CompareFrequencyUnit1,

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

    #[yaserde(rename = "IntrstFltgRateScndLegRefPrdUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstFltgRateScndLegRefPrdUnit"))]
    pub intrst_fltg_rate_scnd_leg_ref_prd_unit: CompareFrequencyUnit1,

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

    #[yaserde(rename = "IntrstFltgRateScndLegRstFrqcyUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstFltgRateScndLegRstFrqcyUnit"))]
    pub intrst_fltg_rate_scnd_leg_rst_frqcy_unit: CompareFrequencyUnit1,

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

    #[yaserde(rename = "IntrstFltgRateScndLegSprd")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstFltgRateScndLegSprd"))]
    pub intrst_fltg_rate_scnd_leg_sprd: CompareUnitPrice8,

    #[yaserde(rename = "PackgSprd")]
    #[cfg_attr(feature = "serde", serde(rename = "PackgSprd"))]
    pub packg_sprd: CompareUnitPrice8,

    #[yaserde(rename = "CcyXchgRate")]
    #[cfg_attr(feature = "serde", serde(rename = "CcyXchgRate"))]
    pub ccy_xchg_rate: CompareExchangeRate1,

    #[yaserde(rename = "CcyFwdXchgRate")]
    #[cfg_attr(feature = "serde", serde(rename = "CcyFwdXchgRate"))]
    pub ccy_fwd_xchg_rate: CompareExchangeRate1,

    #[yaserde(rename = "CcyXchgRateBsis")]
    #[cfg_attr(feature = "serde", serde(rename = "CcyXchgRateBsis"))]
    pub ccy_xchg_rate_bsis: CompareExchangeRateBasis1,

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

    #[yaserde(rename = "NrgyDlvryPtOrZone")]
    #[cfg_attr(feature = "serde", serde(rename = "NrgyDlvryPtOrZone"))]
    pub nrgy_dlvry_pt_or_zone: Vec<CompareDeliveryInterconnectionPoint1>,

    #[yaserde(rename = "NrgyIntrCnnctnPt")]
    #[cfg_attr(feature = "serde", serde(rename = "NrgyIntrCnnctnPt"))]
    pub nrgy_intr_cnnctn_pt: CompareDeliveryInterconnectionPoint1,

    #[yaserde(rename = "NrgyLdTp")]
    #[cfg_attr(feature = "serde", serde(rename = "NrgyLdTp"))]
    pub nrgy_ld_tp: CompareEnergyLoadType1,

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

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

    #[yaserde(rename = "OptnExrcStyle")]
    #[cfg_attr(feature = "serde", serde(rename = "OptnExrcStyle"))]
    pub optn_exrc_style: Vec<CompareOptionStyle1>,

    #[yaserde(rename = "OptnStrkPric")]
    #[cfg_attr(feature = "serde", serde(rename = "OptnStrkPric"))]
    pub optn_strk_pric: CompareUnitPrice4,

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

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

    #[yaserde(rename = "OptnStrkPricSchdlAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "OptnStrkPricSchdlAmt"))]
    pub optn_strk_pric_schdl_amt: Vec<CompareUnitPrice4>,

    #[yaserde(rename = "OptnPrmAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "OptnPrmAmt"))]
    pub optn_prm_amt: CompareActiveOrHistoricCurrencyAndAmount4,

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

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

    #[yaserde(rename = "CdtSnrty")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtSnrty"))]
    pub cdt_snrty: CompareSeniorityType1,

    #[yaserde(rename = "CdtRefPty")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtRefPty"))]
    pub cdt_ref_pty: CompareReferenceParty1,

    #[yaserde(rename = "CdtSrs")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtSrs"))]
    pub cdt_srs: CompareNumber7,

    #[yaserde(rename = "CdtVrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtVrsn"))]
    pub cdt_vrsn: CompareNumber7,

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

    #[yaserde(rename = "CdtTrch")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtTrch"))]
    pub cdt_trch: CompareTrancheIndicator1,

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

impl Validate for TransactionMatchingCriteria7 {}


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

pub enum TransactionOperationType10Code {
    #[yaserde(rename = "COMP")]
    #[cfg_attr(feature = "serde", serde(rename = "COMP"))]
    Comp,
    #[yaserde(rename = "CORR")]
    #[cfg_attr(feature = "serde", serde(rename = "CORR"))]
    Corr,
    #[yaserde(rename = "EROR")]
    #[cfg_attr(feature = "serde", serde(rename = "EROR"))]
    Eror,
    #[yaserde(rename = "MODI")]
    #[cfg_attr(feature = "serde", serde(rename = "MODI"))]
    Modi,
    #[yaserde(rename = "NEWT")]
    #[cfg_attr(feature = "serde", serde(rename = "NEWT"))]
    Newt,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "POSC")]
    #[cfg_attr(feature = "serde", serde(rename = "POSC"))]
    Posc,
    #[yaserde(rename = "REVI")]
    #[cfg_attr(feature = "serde", serde(rename = "REVI"))]
    Revi,
    #[yaserde(rename = "TERM")]
    #[cfg_attr(feature = "serde", serde(rename = "TERM"))]
    Term,
    #[yaserde(rename = "VALU")]
    #[cfg_attr(feature = "serde", serde(rename = "VALU"))]
    Valu,
    #[yaserde(rename = "MARU")]
    #[cfg_attr(feature = "serde", serde(rename = "MARU"))]
    Maru,
    #[yaserde(rename = "PRTO")]
    #[cfg_attr(feature = "serde", serde(rename = "PRTO"))]
    Prto,
    __Unknown__(String),
}

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

impl Validate for TransactionOperationType10Code {}



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

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

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

impl Validate for ValuationMatchingCriteria1 {}


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

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

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 = "091";
    const VARIANT: &'static str = "001";
    const VERSION: &'static str = "03";
    const MESSAGE_NAME: &'static str = "auth.091.001.03";
    const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:auth.091.001.03";
}