#![allow(clippy::all)]
#![allow(non_snake_case, non_camel_case_types, dead_code, unused_imports)]
#![allow(non_local_definitions)]
use std::str::FromStr;
use crate::validate::Validate;
use yaserde_derive::{YaDeserialize, YaSerialize};
#[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.090.001.02")]
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 ActiveOrHistoricCurrencyAnd20DecimalAmountSimpleType (pub String);
crate::simple_type!(ActiveOrHistoricCurrencyAnd20DecimalAmountSimpleType);
impl Validate for ActiveOrHistoricCurrencyAnd20DecimalAmountSimpleType {
fn validate(&self) -> Result<(), String> {
if self.0 < "0".parse::<String>().unwrap() {
return Err(format!("MinInclusive validation error: invalid value of 0! \nExpected: 0 >= 0.\nActual: 0 == {}", self.0));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct ActiveOrHistoricCurrencyAnd20DecimalAmount {
#[yaserde(text)]
pub value: String,
#[yaserde(attribute, rename = "Ccy")]
#[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
pub ccy: ActiveOrHistoricCurrencyCode,
}
impl Validate for ActiveOrHistoricCurrencyAnd20DecimalAmount {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct 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.090.001.02")]
pub struct AgreementType2Choice {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: Option<ExternalAgreementType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<Max50Text>,
}
impl Validate for AgreementType2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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)]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
pub struct AssetClassCommodityInflation1 {
#[yaserde(rename = "BasePdct")]
#[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
pub base_pdct: AssetClassProductType12Code,
}
impl Validate for AssetClassCommodityInflation1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
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.090.001.02")]
pub struct AssetClassCommodityMultiCommodityExotic1 {
#[yaserde(rename = "BasePdct")]
#[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
pub base_pdct: AssetClassProductType13Code,
}
impl Validate for AssetClassCommodityMultiCommodityExotic1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct AssetClassCommodityOfficialEconomicStatistics1 {
#[yaserde(rename = "BasePdct")]
#[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
pub base_pdct: AssetClassProductType14Code,
}
impl Validate for AssetClassCommodityOfficialEconomicStatistics1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct AssetClassCommodityOther1 {
#[yaserde(rename = "BasePdct")]
#[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
pub base_pdct: AssetClassProductType15Code,
}
impl Validate for AssetClassCommodityOther1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
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.090.001.02")]
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.090.001.02")]
pub enum AssetClassDetailedSubProductType10Code {
#[yaserde(rename = "ALUM")]
#[cfg_attr(feature = "serde", serde(rename = "ALUM"))]
Alum,
#[yaserde(rename = "ALUA")]
#[cfg_attr(feature = "serde", serde(rename = "ALUA"))]
Alua,
#[yaserde(rename = "CBLT")]
#[cfg_attr(feature = "serde", serde(rename = "CBLT"))]
Cblt,
#[yaserde(rename = "COPR")]
#[cfg_attr(feature = "serde", serde(rename = "COPR"))]
Copr,
#[yaserde(rename = "IRON")]
#[cfg_attr(feature = "serde", serde(rename = "IRON"))]
Iron,
#[yaserde(rename = "MOLY")]
#[cfg_attr(feature = "serde", serde(rename = "MOLY"))]
Moly,
#[yaserde(rename = "NASC")]
#[cfg_attr(feature = "serde", serde(rename = "NASC"))]
Nasc,
#[yaserde(rename = "NICK")]
#[cfg_attr(feature = "serde", serde(rename = "NICK"))]
Nick,
#[yaserde(rename = "STEL")]
#[cfg_attr(feature = "serde", serde(rename = "STEL"))]
Stel,
#[yaserde(rename = "TINN")]
#[cfg_attr(feature = "serde", serde(rename = "TINN"))]
Tinn,
#[yaserde(rename = "ZINC")]
#[cfg_attr(feature = "serde", serde(rename = "ZINC"))]
Zinc,
#[yaserde(rename = "OTHR")]
#[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
Othr,
#[yaserde(rename = "LEAD")]
#[cfg_attr(feature = "serde", serde(rename = "LEAD"))]
Lead,
__Unknown__(String),
}
impl Default for AssetClassDetailedSubProductType10Code {
fn default() -> AssetClassDetailedSubProductType10Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassDetailedSubProductType10Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassDetailedSubProductType11Code {
#[yaserde(rename = "GOLD")]
#[cfg_attr(feature = "serde", serde(rename = "GOLD"))]
Gold,
#[yaserde(rename = "OTHR")]
#[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
Othr,
#[yaserde(rename = "PLDM")]
#[cfg_attr(feature = "serde", serde(rename = "PLDM"))]
Pldm,
#[yaserde(rename = "PTNM")]
#[cfg_attr(feature = "serde", serde(rename = "PTNM"))]
Ptnm,
#[yaserde(rename = "SLVR")]
#[cfg_attr(feature = "serde", serde(rename = "SLVR"))]
Slvr,
__Unknown__(String),
}
impl Default for AssetClassDetailedSubProductType11Code {
fn default() -> AssetClassDetailedSubProductType11Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassDetailedSubProductType11Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassDetailedSubProductType1Code {
#[yaserde(rename = "FWHT")]
#[cfg_attr(feature = "serde", serde(rename = "FWHT"))]
Fwht,
#[yaserde(rename = "SOYB")]
#[cfg_attr(feature = "serde", serde(rename = "SOYB"))]
Soyb,
#[yaserde(rename = "RPSD")]
#[cfg_attr(feature = "serde", serde(rename = "RPSD"))]
Rpsd,
#[yaserde(rename = "OTHR")]
#[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
Othr,
#[yaserde(rename = "CORN")]
#[cfg_attr(feature = "serde", serde(rename = "CORN"))]
Corn,
#[yaserde(rename = "RICE")]
#[cfg_attr(feature = "serde", serde(rename = "RICE"))]
Rice,
__Unknown__(String),
}
impl Default for AssetClassDetailedSubProductType1Code {
fn default() -> AssetClassDetailedSubProductType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassDetailedSubProductType1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassDetailedSubProductType29Code {
#[yaserde(rename = "LAMP")]
#[cfg_attr(feature = "serde", serde(rename = "LAMP"))]
Lamp,
#[yaserde(rename = "OTHR")]
#[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
Othr,
__Unknown__(String),
}
impl Default for AssetClassDetailedSubProductType29Code {
fn default() -> AssetClassDetailedSubProductType29Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassDetailedSubProductType29Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassDetailedSubProductType2Code {
#[yaserde(rename = "ROBU")]
#[cfg_attr(feature = "serde", serde(rename = "ROBU"))]
Robu,
#[yaserde(rename = "CCOA")]
#[cfg_attr(feature = "serde", serde(rename = "CCOA"))]
Ccoa,
#[yaserde(rename = "BRWN")]
#[cfg_attr(feature = "serde", serde(rename = "BRWN"))]
Brwn,
#[yaserde(rename = "WHSG")]
#[cfg_attr(feature = "serde", serde(rename = "WHSG"))]
Whsg,
#[yaserde(rename = "OTHR")]
#[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
Othr,
__Unknown__(String),
}
impl Default for AssetClassDetailedSubProductType2Code {
fn default() -> AssetClassDetailedSubProductType2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassDetailedSubProductType2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassDetailedSubProductType30Code {
#[yaserde(rename = "MWHT")]
#[cfg_attr(feature = "serde", serde(rename = "MWHT"))]
Mwht,
#[yaserde(rename = "OTHR")]
#[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
Othr,
__Unknown__(String),
}
impl Default for AssetClassDetailedSubProductType30Code {
fn default() -> AssetClassDetailedSubProductType30Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassDetailedSubProductType30Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassDetailedSubProductType31Code {
#[yaserde(rename = "GASP")]
#[cfg_attr(feature = "serde", serde(rename = "GASP"))]
Gasp,
#[yaserde(rename = "LNGG")]
#[cfg_attr(feature = "serde", serde(rename = "LNGG"))]
Lngg,
#[yaserde(rename = "NCGG")]
#[cfg_attr(feature = "serde", serde(rename = "NCGG"))]
Ncgg,
#[yaserde(rename = "TTFG")]
#[cfg_attr(feature = "serde", serde(rename = "TTFG"))]
Ttfg,
#[yaserde(rename = "NBPG")]
#[cfg_attr(feature = "serde", serde(rename = "NBPG"))]
Nbpg,
#[yaserde(rename = "OTHR")]
#[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
Othr,
__Unknown__(String),
}
impl Default for AssetClassDetailedSubProductType31Code {
fn default() -> AssetClassDetailedSubProductType31Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassDetailedSubProductType31Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassDetailedSubProductType32Code {
#[yaserde(rename = "BAKK")]
#[cfg_attr(feature = "serde", serde(rename = "BAKK"))]
Bakk,
#[yaserde(rename = "BDSL")]
#[cfg_attr(feature = "serde", serde(rename = "BDSL"))]
Bdsl,
#[yaserde(rename = "BRNT")]
#[cfg_attr(feature = "serde", serde(rename = "BRNT"))]
Brnt,
#[yaserde(rename = "BRNX")]
#[cfg_attr(feature = "serde", serde(rename = "BRNX"))]
Brnx,
#[yaserde(rename = "CNDA")]
#[cfg_attr(feature = "serde", serde(rename = "CNDA"))]
Cnda,
#[yaserde(rename = "COND")]
#[cfg_attr(feature = "serde", serde(rename = "COND"))]
Cond,
#[yaserde(rename = "DSEL")]
#[cfg_attr(feature = "serde", serde(rename = "DSEL"))]
Dsel,
#[yaserde(rename = "DUBA")]
#[cfg_attr(feature = "serde", serde(rename = "DUBA"))]
Duba,
#[yaserde(rename = "ESPO")]
#[cfg_attr(feature = "serde", serde(rename = "ESPO"))]
Espo,
#[yaserde(rename = "ETHA")]
#[cfg_attr(feature = "serde", serde(rename = "ETHA"))]
Etha,
#[yaserde(rename = "FUEL")]
#[cfg_attr(feature = "serde", serde(rename = "FUEL"))]
Fuel,
#[yaserde(rename = "FOIL")]
#[cfg_attr(feature = "serde", serde(rename = "FOIL"))]
Foil,
#[yaserde(rename = "GOIL")]
#[cfg_attr(feature = "serde", serde(rename = "GOIL"))]
Goil,
#[yaserde(rename = "GSLN")]
#[cfg_attr(feature = "serde", serde(rename = "GSLN"))]
Gsln,
#[yaserde(rename = "HEAT")]
#[cfg_attr(feature = "serde", serde(rename = "HEAT"))]
Heat,
#[yaserde(rename = "JTFL")]
#[cfg_attr(feature = "serde", serde(rename = "JTFL"))]
Jtfl,
#[yaserde(rename = "KERO")]
#[cfg_attr(feature = "serde", serde(rename = "KERO"))]
Kero,
#[yaserde(rename = "LLSO")]
#[cfg_attr(feature = "serde", serde(rename = "LLSO"))]
Llso,
#[yaserde(rename = "MARS")]
#[cfg_attr(feature = "serde", serde(rename = "MARS"))]
Mars,
#[yaserde(rename = "NAPH")]
#[cfg_attr(feature = "serde", serde(rename = "NAPH"))]
Naph,
#[yaserde(rename = "NGLO")]
#[cfg_attr(feature = "serde", serde(rename = "NGLO"))]
Nglo,
#[yaserde(rename = "TAPI")]
#[cfg_attr(feature = "serde", serde(rename = "TAPI"))]
Tapi,
#[yaserde(rename = "WTIO")]
#[cfg_attr(feature = "serde", serde(rename = "WTIO"))]
Wtio,
#[yaserde(rename = "URAL")]
#[cfg_attr(feature = "serde", serde(rename = "URAL"))]
Ural,
#[yaserde(rename = "OTHR")]
#[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
Othr,
__Unknown__(String),
}
impl Default for AssetClassDetailedSubProductType32Code {
fn default() -> AssetClassDetailedSubProductType32Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassDetailedSubProductType32Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassDetailedSubProductType33Code {
#[yaserde(rename = "DBCR")]
#[cfg_attr(feature = "serde", serde(rename = "DBCR"))]
Dbcr,
#[yaserde(rename = "OTHR")]
#[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
Othr,
__Unknown__(String),
}
impl Default for AssetClassDetailedSubProductType33Code {
fn default() -> AssetClassDetailedSubProductType33Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassDetailedSubProductType33Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassDetailedSubProductType34Code {
#[yaserde(rename = "TNKR")]
#[cfg_attr(feature = "serde", serde(rename = "TNKR"))]
Tnkr,
#[yaserde(rename = "OTHR")]
#[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
Othr,
__Unknown__(String),
}
impl Default for AssetClassDetailedSubProductType34Code {
fn default() -> AssetClassDetailedSubProductType34Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassDetailedSubProductType34Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassDetailedSubProductType5Code {
#[yaserde(rename = "BSLD")]
#[cfg_attr(feature = "serde", serde(rename = "BSLD"))]
Bsld,
#[yaserde(rename = "FITR")]
#[cfg_attr(feature = "serde", serde(rename = "FITR"))]
Fitr,
#[yaserde(rename = "PKLD")]
#[cfg_attr(feature = "serde", serde(rename = "PKLD"))]
Pkld,
#[yaserde(rename = "OFFP")]
#[cfg_attr(feature = "serde", serde(rename = "OFFP"))]
Offp,
#[yaserde(rename = "OTHR")]
#[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
Othr,
__Unknown__(String),
}
impl Default for AssetClassDetailedSubProductType5Code {
fn default() -> AssetClassDetailedSubProductType5Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassDetailedSubProductType5Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassDetailedSubProductType8Code {
#[yaserde(rename = "CERE")]
#[cfg_attr(feature = "serde", serde(rename = "CERE"))]
Cere,
#[yaserde(rename = "ERUE")]
#[cfg_attr(feature = "serde", serde(rename = "ERUE"))]
Erue,
#[yaserde(rename = "EUAE")]
#[cfg_attr(feature = "serde", serde(rename = "EUAE"))]
Euae,
#[yaserde(rename = "EUAA")]
#[cfg_attr(feature = "serde", serde(rename = "EUAA"))]
Euaa,
#[yaserde(rename = "OTHR")]
#[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
Othr,
__Unknown__(String),
}
impl Default for AssetClassDetailedSubProductType8Code {
fn default() -> AssetClassDetailedSubProductType8Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassDetailedSubProductType8Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassProductType11Code {
#[yaserde(rename = "OTHC")]
#[cfg_attr(feature = "serde", serde(rename = "OTHC"))]
Othc,
__Unknown__(String),
}
impl Default for AssetClassProductType11Code {
fn default() -> AssetClassProductType11Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassProductType11Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassProductType12Code {
#[yaserde(rename = "INFL")]
#[cfg_attr(feature = "serde", serde(rename = "INFL"))]
Infl,
__Unknown__(String),
}
impl Default for AssetClassProductType12Code {
fn default() -> AssetClassProductType12Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassProductType12Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassProductType13Code {
#[yaserde(rename = "MCEX")]
#[cfg_attr(feature = "serde", serde(rename = "MCEX"))]
Mcex,
__Unknown__(String),
}
impl Default for AssetClassProductType13Code {
fn default() -> AssetClassProductType13Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassProductType13Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassProductType14Code {
#[yaserde(rename = "OEST")]
#[cfg_attr(feature = "serde", serde(rename = "OEST"))]
Oest,
__Unknown__(String),
}
impl Default for AssetClassProductType14Code {
fn default() -> AssetClassProductType14Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassProductType14Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassProductType15Code {
#[yaserde(rename = "OTHR")]
#[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
Othr,
__Unknown__(String),
}
impl Default for AssetClassProductType15Code {
fn default() -> AssetClassProductType15Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassProductType15Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
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.090.001.02")]
pub enum AssetClassProductType1Code {
#[yaserde(rename = "AGRI")]
#[cfg_attr(feature = "serde", serde(rename = "AGRI"))]
Agri,
__Unknown__(String),
}
impl Default for AssetClassProductType1Code {
fn default() -> AssetClassProductType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassProductType1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassProductType2Code {
#[yaserde(rename = "NRGY")]
#[cfg_attr(feature = "serde", serde(rename = "NRGY"))]
Nrgy,
__Unknown__(String),
}
impl Default for AssetClassProductType2Code {
fn default() -> AssetClassProductType2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassProductType2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassProductType3Code {
#[yaserde(rename = "ENVR")]
#[cfg_attr(feature = "serde", serde(rename = "ENVR"))]
Envr,
__Unknown__(String),
}
impl Default for AssetClassProductType3Code {
fn default() -> AssetClassProductType3Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassProductType3Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassProductType4Code {
#[yaserde(rename = "FRGT")]
#[cfg_attr(feature = "serde", serde(rename = "FRGT"))]
Frgt,
__Unknown__(String),
}
impl Default for AssetClassProductType4Code {
fn default() -> AssetClassProductType4Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassProductType4Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassProductType5Code {
#[yaserde(rename = "FRTL")]
#[cfg_attr(feature = "serde", serde(rename = "FRTL"))]
Frtl,
__Unknown__(String),
}
impl Default for AssetClassProductType5Code {
fn default() -> AssetClassProductType5Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassProductType5Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassProductType6Code {
#[yaserde(rename = "INDP")]
#[cfg_attr(feature = "serde", serde(rename = "INDP"))]
Indp,
__Unknown__(String),
}
impl Default for AssetClassProductType6Code {
fn default() -> AssetClassProductType6Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassProductType6Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassProductType7Code {
#[yaserde(rename = "METL")]
#[cfg_attr(feature = "serde", serde(rename = "METL"))]
Metl,
__Unknown__(String),
}
impl Default for AssetClassProductType7Code {
fn default() -> AssetClassProductType7Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassProductType7Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassProductType8Code {
#[yaserde(rename = "PAPR")]
#[cfg_attr(feature = "serde", serde(rename = "PAPR"))]
Papr,
__Unknown__(String),
}
impl Default for AssetClassProductType8Code {
fn default() -> AssetClassProductType8Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassProductType8Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassProductType9Code {
#[yaserde(rename = "POLY")]
#[cfg_attr(feature = "serde", serde(rename = "POLY"))]
Poly,
__Unknown__(String),
}
impl Default for AssetClassProductType9Code {
fn default() -> AssetClassProductType9Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassProductType9Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType10Code {
#[yaserde(rename = "EMIS")]
#[cfg_attr(feature = "serde", serde(rename = "EMIS"))]
Emis,
__Unknown__(String),
}
impl Default for AssetClassSubProductType10Code {
fn default() -> AssetClassSubProductType10Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType10Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType15Code {
#[yaserde(rename = "NPRM")]
#[cfg_attr(feature = "serde", serde(rename = "NPRM"))]
Nprm,
__Unknown__(String),
}
impl Default for AssetClassSubProductType15Code {
fn default() -> AssetClassSubProductType15Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType15Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType16Code {
#[yaserde(rename = "PRME")]
#[cfg_attr(feature = "serde", serde(rename = "PRME"))]
Prme,
__Unknown__(String),
}
impl Default for AssetClassSubProductType16Code {
fn default() -> AssetClassSubProductType16Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType16Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType18Code {
#[yaserde(rename = "PLST")]
#[cfg_attr(feature = "serde", serde(rename = "PLST"))]
Plst,
__Unknown__(String),
}
impl Default for AssetClassSubProductType18Code {
fn default() -> AssetClassSubProductType18Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType18Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType1Code {
#[yaserde(rename = "GROS")]
#[cfg_attr(feature = "serde", serde(rename = "GROS"))]
Gros,
__Unknown__(String),
}
impl Default for AssetClassSubProductType1Code {
fn default() -> AssetClassSubProductType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType20Code {
#[yaserde(rename = "DIRY")]
#[cfg_attr(feature = "serde", serde(rename = "DIRY"))]
Diry,
__Unknown__(String),
}
impl Default for AssetClassSubProductType20Code {
fn default() -> AssetClassSubProductType20Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType20Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType21Code {
#[yaserde(rename = "FRST")]
#[cfg_attr(feature = "serde", serde(rename = "FRST"))]
Frst,
__Unknown__(String),
}
impl Default for AssetClassSubProductType21Code {
fn default() -> AssetClassSubProductType21Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType21Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType22Code {
#[yaserde(rename = "LSTK")]
#[cfg_attr(feature = "serde", serde(rename = "LSTK"))]
Lstk,
__Unknown__(String),
}
impl Default for AssetClassSubProductType22Code {
fn default() -> AssetClassSubProductType22Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType22Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType23Code {
#[yaserde(rename = "SEAF")]
#[cfg_attr(feature = "serde", serde(rename = "SEAF"))]
Seaf,
__Unknown__(String),
}
impl Default for AssetClassSubProductType23Code {
fn default() -> AssetClassSubProductType23Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType23Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType24Code {
#[yaserde(rename = "COAL")]
#[cfg_attr(feature = "serde", serde(rename = "COAL"))]
Coal,
__Unknown__(String),
}
impl Default for AssetClassSubProductType24Code {
fn default() -> AssetClassSubProductType24Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType24Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType25Code {
#[yaserde(rename = "DIST")]
#[cfg_attr(feature = "serde", serde(rename = "DIST"))]
Dist,
__Unknown__(String),
}
impl Default for AssetClassSubProductType25Code {
fn default() -> AssetClassSubProductType25Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType25Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType26Code {
#[yaserde(rename = "INRG")]
#[cfg_attr(feature = "serde", serde(rename = "INRG"))]
Inrg,
__Unknown__(String),
}
impl Default for AssetClassSubProductType26Code {
fn default() -> AssetClassSubProductType26Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType26Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType27Code {
#[yaserde(rename = "LGHT")]
#[cfg_attr(feature = "serde", serde(rename = "LGHT"))]
Lght,
__Unknown__(String),
}
impl Default for AssetClassSubProductType27Code {
fn default() -> AssetClassSubProductType27Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType27Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType28Code {
#[yaserde(rename = "RNNG")]
#[cfg_attr(feature = "serde", serde(rename = "RNNG"))]
Rnng,
__Unknown__(String),
}
impl Default for AssetClassSubProductType28Code {
fn default() -> AssetClassSubProductType28Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType28Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType29Code {
#[yaserde(rename = "CRBR")]
#[cfg_attr(feature = "serde", serde(rename = "CRBR"))]
Crbr,
__Unknown__(String),
}
impl Default for AssetClassSubProductType29Code {
fn default() -> AssetClassSubProductType29Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType29Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType2Code {
#[yaserde(rename = "SOFT")]
#[cfg_attr(feature = "serde", serde(rename = "SOFT"))]
Soft,
__Unknown__(String),
}
impl Default for AssetClassSubProductType2Code {
fn default() -> AssetClassSubProductType2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType30Code {
#[yaserde(rename = "WTHR")]
#[cfg_attr(feature = "serde", serde(rename = "WTHR"))]
Wthr,
__Unknown__(String),
}
impl Default for AssetClassSubProductType30Code {
fn default() -> AssetClassSubProductType30Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType30Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType31Code {
#[yaserde(rename = "DRYF")]
#[cfg_attr(feature = "serde", serde(rename = "DRYF"))]
Dryf,
__Unknown__(String),
}
impl Default for AssetClassSubProductType31Code {
fn default() -> AssetClassSubProductType31Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType31Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType32Code {
#[yaserde(rename = "WETF")]
#[cfg_attr(feature = "serde", serde(rename = "WETF"))]
Wetf,
__Unknown__(String),
}
impl Default for AssetClassSubProductType32Code {
fn default() -> AssetClassSubProductType32Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType32Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType33Code {
#[yaserde(rename = "CSTR")]
#[cfg_attr(feature = "serde", serde(rename = "CSTR"))]
Cstr,
__Unknown__(String),
}
impl Default for AssetClassSubProductType33Code {
fn default() -> AssetClassSubProductType33Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType33Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType34Code {
#[yaserde(rename = "MFTG")]
#[cfg_attr(feature = "serde", serde(rename = "MFTG"))]
Mftg,
__Unknown__(String),
}
impl Default for AssetClassSubProductType34Code {
fn default() -> AssetClassSubProductType34Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType34Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType35Code {
#[yaserde(rename = "CBRD")]
#[cfg_attr(feature = "serde", serde(rename = "CBRD"))]
Cbrd,
__Unknown__(String),
}
impl Default for AssetClassSubProductType35Code {
fn default() -> AssetClassSubProductType35Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType35Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType36Code {
#[yaserde(rename = "NSPT")]
#[cfg_attr(feature = "serde", serde(rename = "NSPT"))]
Nspt,
__Unknown__(String),
}
impl Default for AssetClassSubProductType36Code {
fn default() -> AssetClassSubProductType36Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType36Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType37Code {
#[yaserde(rename = "PULP")]
#[cfg_attr(feature = "serde", serde(rename = "PULP"))]
Pulp,
__Unknown__(String),
}
impl Default for AssetClassSubProductType37Code {
fn default() -> AssetClassSubProductType37Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType37Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType39Code {
#[yaserde(rename = "AMMO")]
#[cfg_attr(feature = "serde", serde(rename = "AMMO"))]
Ammo,
__Unknown__(String),
}
impl Default for AssetClassSubProductType39Code {
fn default() -> AssetClassSubProductType39Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType39Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType3Code {
#[yaserde(rename = "OOLI")]
#[cfg_attr(feature = "serde", serde(rename = "OOLI"))]
Ooli,
__Unknown__(String),
}
impl Default for AssetClassSubProductType3Code {
fn default() -> AssetClassSubProductType3Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType3Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType40Code {
#[yaserde(rename = "DAPH")]
#[cfg_attr(feature = "serde", serde(rename = "DAPH"))]
Daph,
__Unknown__(String),
}
impl Default for AssetClassSubProductType40Code {
fn default() -> AssetClassSubProductType40Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType40Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType41Code {
#[yaserde(rename = "PTSH")]
#[cfg_attr(feature = "serde", serde(rename = "PTSH"))]
Ptsh,
__Unknown__(String),
}
impl Default for AssetClassSubProductType41Code {
fn default() -> AssetClassSubProductType41Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType41Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType42Code {
#[yaserde(rename = "SLPH")]
#[cfg_attr(feature = "serde", serde(rename = "SLPH"))]
Slph,
__Unknown__(String),
}
impl Default for AssetClassSubProductType42Code {
fn default() -> AssetClassSubProductType42Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType42Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType43Code {
#[yaserde(rename = "UREA")]
#[cfg_attr(feature = "serde", serde(rename = "UREA"))]
Urea,
__Unknown__(String),
}
impl Default for AssetClassSubProductType43Code {
fn default() -> AssetClassSubProductType43Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType43Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType44Code {
#[yaserde(rename = "UAAN")]
#[cfg_attr(feature = "serde", serde(rename = "UAAN"))]
Uaan,
__Unknown__(String),
}
impl Default for AssetClassSubProductType44Code {
fn default() -> AssetClassSubProductType44Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType44Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType45Code {
#[yaserde(rename = "POTA")]
#[cfg_attr(feature = "serde", serde(rename = "POTA"))]
Pota,
__Unknown__(String),
}
impl Default for AssetClassSubProductType45Code {
fn default() -> AssetClassSubProductType45Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType45Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType46Code {
#[yaserde(rename = "CSHP")]
#[cfg_attr(feature = "serde", serde(rename = "CSHP"))]
Cshp,
__Unknown__(String),
}
impl Default for AssetClassSubProductType46Code {
fn default() -> AssetClassSubProductType46Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType46Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType49Code {
#[yaserde(rename = "OTHR")]
#[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
Othr,
__Unknown__(String),
}
impl Default for AssetClassSubProductType49Code {
fn default() -> AssetClassSubProductType49Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType49Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType5Code {
#[yaserde(rename = "GRIN")]
#[cfg_attr(feature = "serde", serde(rename = "GRIN"))]
Grin,
__Unknown__(String),
}
impl Default for AssetClassSubProductType5Code {
fn default() -> AssetClassSubProductType5Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType5Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType6Code {
#[yaserde(rename = "ELEC")]
#[cfg_attr(feature = "serde", serde(rename = "ELEC"))]
Elec,
__Unknown__(String),
}
impl Default for AssetClassSubProductType6Code {
fn default() -> AssetClassSubProductType6Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType6Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType7Code {
#[yaserde(rename = "NGAS")]
#[cfg_attr(feature = "serde", serde(rename = "NGAS"))]
Ngas,
__Unknown__(String),
}
impl Default for AssetClassSubProductType7Code {
fn default() -> AssetClassSubProductType7Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType7Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum AssetClassSubProductType8Code {
#[yaserde(rename = "OILP")]
#[cfg_attr(feature = "serde", serde(rename = "OILP"))]
Oilp,
__Unknown__(String),
}
impl Default for AssetClassSubProductType8Code {
fn default() -> AssetClassSubProductType8Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssetClassSubProductType8Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum CollateralisationType3Code {
#[yaserde(rename = "FLCL")]
#[cfg_attr(feature = "serde", serde(rename = "FLCL"))]
Flcl,
#[yaserde(rename = "OWCL")]
#[cfg_attr(feature = "serde", serde(rename = "OWCL"))]
Owcl,
#[yaserde(rename = "OWC1")]
#[cfg_attr(feature = "serde", serde(rename = "OWC1"))]
Owc1,
#[yaserde(rename = "OWC2")]
#[cfg_attr(feature = "serde", serde(rename = "OWC2"))]
Owc2,
#[yaserde(rename = "OWP1")]
#[cfg_attr(feature = "serde", serde(rename = "OWP1"))]
Owp1,
#[yaserde(rename = "OWP2")]
#[cfg_attr(feature = "serde", serde(rename = "OWP2"))]
Owp2,
#[yaserde(rename = "PRCL")]
#[cfg_attr(feature = "serde", serde(rename = "PRCL"))]
Prcl,
#[yaserde(rename = "PRC1")]
#[cfg_attr(feature = "serde", serde(rename = "PRC1"))]
Prc1,
#[yaserde(rename = "PRC2")]
#[cfg_attr(feature = "serde", serde(rename = "PRC2"))]
Prc2,
#[yaserde(rename = "UNCL")]
#[cfg_attr(feature = "serde", serde(rename = "UNCL"))]
Uncl,
__Unknown__(String),
}
impl Default for CollateralisationType3Code {
fn default() -> CollateralisationType3Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for CollateralisationType3Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct Counterparty45 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: PartyIdentification248Choice,
#[yaserde(rename = "Ntr")]
#[cfg_attr(feature = "serde", serde(rename = "Ntr"))]
pub ntr: CounterpartyTradeNature15Choice,
#[yaserde(rename = "TradgCpcty")]
#[cfg_attr(feature = "serde", serde(rename = "TradgCpcty"))]
pub tradg_cpcty: TradingCapacity7Code,
#[yaserde(rename = "DrctnOrSd")]
#[cfg_attr(feature = "serde", serde(rename = "DrctnOrSd"))]
pub drctn_or_sd: Direction4Choice,
#[yaserde(rename = "TradrLctn")]
#[cfg_attr(feature = "serde", serde(rename = "TradrLctn"))]
pub tradr_lctn: CountryCode,
#[yaserde(rename = "BookgLctn")]
#[cfg_attr(feature = "serde", serde(rename = "BookgLctn"))]
pub bookg_lctn: CountryCode,
#[yaserde(rename = "RptgXmptn")]
#[cfg_attr(feature = "serde", serde(rename = "RptgXmptn"))]
pub rptg_xmptn: ReportingExemption1,
}
impl Validate for Counterparty45 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct Counterparty46 {
#[yaserde(rename = "IdTp")]
#[cfg_attr(feature = "serde", serde(rename = "IdTp"))]
pub id_tp: PartyIdentification248Choice,
#[yaserde(rename = "Ntr")]
#[cfg_attr(feature = "serde", serde(rename = "Ntr"))]
pub ntr: CounterpartyTradeNature15Choice,
#[yaserde(rename = "RptgOblgtn")]
#[cfg_attr(feature = "serde", serde(rename = "RptgOblgtn"))]
pub rptg_oblgtn: TrueFalseIndicator,
}
impl Validate for Counterparty46 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct CounterpartyTradeNature15Choice {
#[yaserde(rename = "FI")]
#[cfg_attr(feature = "serde", serde(rename = "FI"))]
pub fi: Option<FinancialInstitutionSector1>,
#[yaserde(rename = "NFI")]
#[cfg_attr(feature = "serde", serde(rename = "NFI"))]
pub nfi: Option<NonFinancialInstitutionSector10>,
#[yaserde(rename = "CntrlCntrPty")]
#[cfg_attr(feature = "serde", serde(rename = "CntrlCntrPty"))]
pub cntrl_cntr_pty: Option<NoReasonCode>,
#[yaserde(rename = "Othr")]
#[cfg_attr(feature = "serde", serde(rename = "Othr"))]
pub othr: Option<NoReasonCode>,
}
impl Validate for CounterpartyTradeNature15Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct CountryCode (pub String);
crate::simple_type!(CountryCode);
impl Validate for CountryCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct CountrySubDivisionCode (pub String);
crate::simple_type!(CountrySubDivisionCode);
impl Validate for CountrySubDivisionCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct CreditDerivative7 {
#[yaserde(rename = "Snrty")]
#[cfg_attr(feature = "serde", serde(rename = "Snrty"))]
pub snrty: DebtInstrumentSeniorityType2Code,
#[yaserde(rename = "RefPty")]
#[cfg_attr(feature = "serde", serde(rename = "RefPty"))]
pub ref_pty: DerivativePartyIdentification1Choice,
#[yaserde(rename = "PmtFrqcy")]
#[cfg_attr(feature = "serde", serde(rename = "PmtFrqcy"))]
pub pmt_frqcy: Frequency13Code,
#[yaserde(rename = "ClctnBsis")]
#[cfg_attr(feature = "serde", serde(rename = "ClctnBsis"))]
pub clctn_bsis: Max35Text,
#[yaserde(rename = "Srs")]
#[cfg_attr(feature = "serde", serde(rename = "Srs"))]
pub srs: Number,
#[yaserde(rename = "Vrsn")]
#[cfg_attr(feature = "serde", serde(rename = "Vrsn"))]
pub vrsn: Number,
#[yaserde(rename = "IndxFctr")]
#[cfg_attr(feature = "serde", serde(rename = "IndxFctr"))]
pub indx_fctr: PercentageRate,
#[yaserde(rename = "TrchInd")]
#[cfg_attr(feature = "serde", serde(rename = "TrchInd"))]
pub trch_ind: TrueFalseIndicator,
}
impl Validate for CreditDerivative7 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
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.090.001.02")]
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.090.001.02")]
pub struct DerivativesTradePositionSetReportV02 {
#[yaserde(rename = "AggtdPos")]
#[cfg_attr(feature = "serde", serde(rename = "AggtdPos"))]
pub aggtd_pos: PositionSetAggregated2Choice,
#[yaserde(rename = "SplmtryData")]
#[cfg_attr(feature = "serde", serde(rename = "SplmtryData"))]
pub splmtry_data: Vec<SupplementaryData1>,
}
impl Validate for DerivativesTradePositionSetReportV02 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
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.090.001.02")]
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.090.001.02")]
pub struct Document {
#[yaserde(rename = "DerivsTradPosSetRpt")]
#[cfg_attr(feature = "serde", serde(rename = "DerivsTradPosSetRpt"))]
pub derivs_trad_pos_set_rpt: DerivativesTradePositionSetReportV02,
}
impl Validate for Document {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
pub struct EnergyCommodityRenewableEnergy2 {
#[yaserde(rename = "BasePdct")]
#[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
pub base_pdct: AssetClassProductType2Code,
#[yaserde(rename = "SubPdct")]
#[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
pub sub_pdct: AssetClassSubProductType28Code,
}
impl Validate for EnergyCommodityRenewableEnergy2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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 ExternalPartyRelationshipType1Code (pub String);
crate::simple_type!(ExternalPartyRelationshipType1Code);
impl Validate for ExternalPartyRelationshipType1Code {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 4 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 4 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ExternalUnitOfMeasure1Code (pub String);
crate::simple_type!(ExternalUnitOfMeasure1Code);
impl Validate for ExternalUnitOfMeasure1Code {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 4 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 4 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
pub struct FertilizerCommodityUreaAndAmmoniumNitrate2 {
#[yaserde(rename = "BasePdct")]
#[cfg_attr(feature = "serde", serde(rename = "BasePdct"))]
pub base_pdct: AssetClassProductType5Code,
#[yaserde(rename = "SubPdct")]
#[cfg_attr(feature = "serde", serde(rename = "SubPdct"))]
pub sub_pdct: AssetClassSubProductType44Code,
}
impl Validate for FertilizerCommodityUreaAndAmmoniumNitrate2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct FinancialInstitutionSector1 {
#[yaserde(rename = "Sctr")]
#[cfg_attr(feature = "serde", serde(rename = "Sctr"))]
pub sctr: Vec<FinancialPartyClassification2Choice>,
#[yaserde(rename = "ClrThrshld")]
#[cfg_attr(feature = "serde", serde(rename = "ClrThrshld"))]
pub clr_thrshld: TrueFalseIndicator,
}
impl Validate for FinancialInstitutionSector1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
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.090.001.02")]
pub struct FinancialPartyClassification2Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<FinancialPartySectorType3Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification175>,
}
impl Validate for FinancialPartyClassification2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum FinancialPartySectorType3Code {
#[yaserde(rename = "AIFD")]
#[cfg_attr(feature = "serde", serde(rename = "AIFD"))]
Aifd,
#[yaserde(rename = "CSDS")]
#[cfg_attr(feature = "serde", serde(rename = "CSDS"))]
Csds,
#[yaserde(rename = "CCPS")]
#[cfg_attr(feature = "serde", serde(rename = "CCPS"))]
Ccps,
#[yaserde(rename = "CDTI")]
#[cfg_attr(feature = "serde", serde(rename = "CDTI"))]
Cdti,
#[yaserde(rename = "INUN")]
#[cfg_attr(feature = "serde", serde(rename = "INUN"))]
Inun,
#[yaserde(rename = "ORPI")]
#[cfg_attr(feature = "serde", serde(rename = "ORPI"))]
Orpi,
#[yaserde(rename = "INVF")]
#[cfg_attr(feature = "serde", serde(rename = "INVF"))]
Invf,
#[yaserde(rename = "REIN")]
#[cfg_attr(feature = "serde", serde(rename = "REIN"))]
Rein,
#[yaserde(rename = "UCIT")]
#[cfg_attr(feature = "serde", serde(rename = "UCIT"))]
Ucit,
#[yaserde(rename = "ASSU")]
#[cfg_attr(feature = "serde", serde(rename = "ASSU"))]
Assu,
#[yaserde(rename = "OTHR")]
#[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
Othr,
__Unknown__(String),
}
impl Default for FinancialPartySectorType3Code {
fn default() -> FinancialPartySectorType3Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for FinancialPartySectorType3Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
pub struct GenericIdentification175 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max72Text,
#[yaserde(rename = "SchmeNm")]
#[cfg_attr(feature = "serde", serde(rename = "SchmeNm"))]
pub schme_nm: Max35Text,
#[yaserde(rename = "Issr")]
#[cfg_attr(feature = "serde", serde(rename = "Issr"))]
pub issr: Max35Text,
}
impl Validate for GenericIdentification175 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
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.090.001.02")]
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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(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.090.001.02")]
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct MarginCollateralReport4 {
#[yaserde(rename = "CollPrtflCd")]
#[cfg_attr(feature = "serde", serde(rename = "CollPrtflCd"))]
pub coll_prtfl_cd: CollateralPortfolioCode5Choice,
#[yaserde(rename = "CollstnCtgy")]
#[cfg_attr(feature = "serde", serde(rename = "CollstnCtgy"))]
pub collstn_ctgy: CollateralisationType3Code,
#[yaserde(rename = "TmStmp")]
#[cfg_attr(feature = "serde", serde(rename = "TmStmp"))]
pub tm_stmp: IsodateTime,
}
impl Validate for MarginCollateralReport4 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
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.090.001.02")]
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.090.001.02")]
pub struct MaturityTerm2 {
#[yaserde(rename = "Unit")]
#[cfg_attr(feature = "serde", serde(rename = "Unit"))]
pub unit: RateBasis1Code,
#[yaserde(rename = "Val")]
#[cfg_attr(feature = "serde", serde(rename = "Val"))]
pub val: Max3Number,
}
impl Validate for MaturityTerm2 {}
#[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 Max20PositiveNumber (pub String);
crate::simple_type!(Max20PositiveNumber);
impl Validate for Max20PositiveNumber {
fn validate(&self) -> Result<(), String> {
if self.0 < "0".parse::<String>().unwrap() {
return Err(format!("MinInclusive validation error: invalid value of 0! \nExpected: 0 >= 0.\nActual: 0 == {}", self.0));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max210Text (pub String);
crate::simple_type!(Max210Text);
impl Validate for Max210Text {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 210 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 210 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max350Text (pub String);
crate::simple_type!(Max350Text);
impl Validate for Max350Text {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 350 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 350 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max35Text (pub String);
crate::simple_type!(Max35Text);
impl Validate for Max35Text {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 35 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 35 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max3Number (pub String);
crate::simple_type!(Max3Number);
impl Validate for Max3Number {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max4AlphaNumericText (pub String);
crate::simple_type!(Max4AlphaNumericText);
impl Validate for Max4AlphaNumericText {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 4 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 4 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max4Text (pub String);
crate::simple_type!(Max4Text);
impl Validate for Max4Text {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 4 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 4 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max500Text (pub String);
crate::simple_type!(Max500Text);
impl Validate for Max500Text {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 500 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 500 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max50Text (pub String);
crate::simple_type!(Max50Text);
impl Validate for Max50Text {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 50 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 50 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max52Text (pub String);
crate::simple_type!(Max52Text);
impl Validate for Max52Text {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 52 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 52 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct 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.090.001.02")]
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.090.001.02")]
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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct NaturalPersonIdentification2 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: GenericIdentification175,
#[yaserde(rename = "Nm")]
#[cfg_attr(feature = "serde", serde(rename = "Nm"))]
pub nm: Max105Text,
#[yaserde(rename = "Dmcl")]
#[cfg_attr(feature = "serde", serde(rename = "Dmcl"))]
pub dmcl: Max500Text,
}
impl Validate for NaturalPersonIdentification2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
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.090.001.02")]
pub enum NoReasonCode {
#[yaserde(rename = "NORE")]
#[cfg_attr(feature = "serde", serde(rename = "NORE"))]
Nore,
__Unknown__(String),
}
impl Default for NoReasonCode {
fn default() -> NoReasonCode {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for NoReasonCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct NonFinancialInstitutionSector10 {
#[yaserde(rename = "Sctr")]
#[cfg_attr(feature = "serde", serde(rename = "Sctr"))]
pub sctr: Vec<GenericIdentification175>,
#[yaserde(rename = "ClrThrshld")]
#[cfg_attr(feature = "serde", serde(rename = "ClrThrshld"))]
pub clr_thrshld: TrueFalseIndicator,
#[yaserde(rename = "DrctlyLkdActvty")]
#[cfg_attr(feature = "serde", serde(rename = "DrctlyLkdActvty"))]
pub drctly_lkd_actvty: TrueFalseIndicator,
#[yaserde(rename = "FdrlInstn")]
#[cfg_attr(feature = "serde", serde(rename = "FdrlInstn"))]
pub fdrl_instn: TrueFalseIndicator,
}
impl Validate for NonFinancialInstitutionSector10 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum NotApplicable1Code {
#[yaserde(rename = "NOAP")]
#[cfg_attr(feature = "serde", serde(rename = "NOAP"))]
Noap,
__Unknown__(String),
}
impl Default for NotApplicable1Code {
fn default() -> NotApplicable1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for NotApplicable1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct NotionalAmount7 {
#[yaserde(rename = "Amt")]
#[cfg_attr(feature = "serde", serde(rename = "Amt"))]
pub amt: ActiveOrHistoricCurrencyAnd19DecimalAmount,
#[yaserde(rename = "AmtInFct")]
#[cfg_attr(feature = "serde", serde(rename = "AmtInFct"))]
pub amt_in_fct: Vec<ActiveOrHistoricCurrencyAnd19DecimalAmount>,
#[yaserde(rename = "WghtdAvrgDlta")]
#[cfg_attr(feature = "serde", serde(rename = "WghtdAvrgDlta"))]
pub wghtd_avrg_dlta: LongFraction19DecimalNumber,
}
impl Validate for NotionalAmount7 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct NotionalAmountLegs6 {
#[yaserde(rename = "FrstLeg")]
#[cfg_attr(feature = "serde", serde(rename = "FrstLeg"))]
pub frst_leg: NotionalAmount7,
#[yaserde(rename = "ScndLeg")]
#[cfg_attr(feature = "serde", serde(rename = "ScndLeg"))]
pub scnd_leg: NotionalAmount7,
}
impl Validate for NotionalAmountLegs6 {}
#[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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
pub enum OptionType2Code {
#[yaserde(rename = "CALL")]
#[cfg_attr(feature = "serde", serde(rename = "CALL"))]
Call,
#[yaserde(rename = "PUTO")]
#[cfg_attr(feature = "serde", serde(rename = "PUTO"))]
Puto,
#[yaserde(rename = "OTHR")]
#[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
Othr,
__Unknown__(String),
}
impl Default for OptionType2Code {
fn default() -> OptionType2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for OptionType2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct OrganisationIdentification15Choice {
#[yaserde(rename = "LEI")]
#[cfg_attr(feature = "serde", serde(rename = "LEI"))]
pub lei: Option<Leiidentifier>,
#[yaserde(rename = "Othr")]
#[cfg_attr(feature = "serde", serde(rename = "Othr"))]
pub othr: Option<OrganisationIdentification38>,
#[yaserde(rename = "AnyBIC")]
#[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
pub any_b_i_c: Option<AnyBICDec2014Identifier>,
}
impl Validate for OrganisationIdentification15Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct OrganisationIdentification38 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: GenericIdentification175,
#[yaserde(rename = "Nm")]
#[cfg_attr(feature = "serde", serde(rename = "Nm"))]
pub nm: Max105Text,
#[yaserde(rename = "Dmcl")]
#[cfg_attr(feature = "serde", serde(rename = "Dmcl"))]
pub dmcl: Max500Text,
}
impl Validate for OrganisationIdentification38 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct OtherPayment6 {
#[yaserde(rename = "PmtCcy")]
#[cfg_attr(feature = "serde", serde(rename = "PmtCcy"))]
pub pmt_ccy: ActiveOrHistoricCurrencyCode,
#[yaserde(rename = "PmtTp")]
#[cfg_attr(feature = "serde", serde(rename = "PmtTp"))]
pub pmt_tp: PaymentType5Choice,
#[yaserde(rename = "PmtDt")]
#[cfg_attr(feature = "serde", serde(rename = "PmtDt"))]
pub pmt_dt: Isodate,
#[yaserde(rename = "PmtPyer")]
#[cfg_attr(feature = "serde", serde(rename = "PmtPyer"))]
pub pmt_pyer: PartyIdentification236Choice,
#[yaserde(rename = "PmtRcvr")]
#[cfg_attr(feature = "serde", serde(rename = "PmtRcvr"))]
pub pmt_rcvr: PartyIdentification236Choice,
}
impl Validate for OtherPayment6 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
pub struct PartyIdentification236Choice {
#[yaserde(rename = "Lgl")]
#[cfg_attr(feature = "serde", serde(rename = "Lgl"))]
pub lgl: Option<OrganisationIdentification15Choice>,
#[yaserde(rename = "Ntrl")]
#[cfg_attr(feature = "serde", serde(rename = "Ntrl"))]
pub ntrl: Option<NaturalPersonIdentification2>,
}
impl Validate for PartyIdentification236Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
pub struct PositionSet21 {
#[yaserde(rename = "Dmnsns")]
#[cfg_attr(feature = "serde", serde(rename = "Dmnsns"))]
pub dmnsns: PositionSetDimensions16,
#[yaserde(rename = "Mtrcs")]
#[cfg_attr(feature = "serde", serde(rename = "Mtrcs"))]
pub mtrcs: PositionSetMetrics14,
}
impl Validate for PositionSet21 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct PositionSet22 {
#[yaserde(rename = "Dmnsns")]
#[cfg_attr(feature = "serde", serde(rename = "Dmnsns"))]
pub dmnsns: PositionSetCollateralDimensions3,
#[yaserde(rename = "Mtrcs")]
#[cfg_attr(feature = "serde", serde(rename = "Mtrcs"))]
pub mtrcs: PositionSetCollateralMetrics2,
}
impl Validate for PositionSet22 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct PositionSetAggregated2Choice {
#[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: Option<PositionSetAggregated4>,
}
impl Validate for PositionSetAggregated2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct PositionSetAggregated4 {
#[yaserde(rename = "RefDt")]
#[cfg_attr(feature = "serde", serde(rename = "RefDt"))]
pub ref_dt: Isodate,
#[yaserde(rename = "PosSet")]
#[cfg_attr(feature = "serde", serde(rename = "PosSet"))]
pub pos_set: Vec<PositionSet21>,
#[yaserde(rename = "CcyPosSet")]
#[cfg_attr(feature = "serde", serde(rename = "CcyPosSet"))]
pub ccy_pos_set: Vec<PositionSet21>,
#[yaserde(rename = "CollPosSet")]
#[cfg_attr(feature = "serde", serde(rename = "CollPosSet"))]
pub coll_pos_set: Vec<PositionSet22>,
#[yaserde(rename = "CcyCollPosSet")]
#[cfg_attr(feature = "serde", serde(rename = "CcyCollPosSet"))]
pub ccy_coll_pos_set: Vec<PositionSet22>,
}
impl Validate for PositionSetAggregated4 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct PositionSetBuyerAndSeller2 {
#[yaserde(rename = "Buyr")]
#[cfg_attr(feature = "serde", serde(rename = "Buyr"))]
pub buyr: PositionSetTotal2,
#[yaserde(rename = "Sellr")]
#[cfg_attr(feature = "serde", serde(rename = "Sellr"))]
pub sellr: PositionSetTotal2,
}
impl Validate for PositionSetBuyerAndSeller2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct PositionSetCollateralDimensions3 {
#[yaserde(rename = "CtrPtyId")]
#[cfg_attr(feature = "serde", serde(rename = "CtrPtyId"))]
pub ctr_pty_id: TradeCounterpartyReport20,
#[yaserde(rename = "Coll")]
#[cfg_attr(feature = "serde", serde(rename = "Coll"))]
pub coll: MarginCollateralReport4,
#[yaserde(rename = "InitlMrgnPstdCcy")]
#[cfg_attr(feature = "serde", serde(rename = "InitlMrgnPstdCcy"))]
pub initl_mrgn_pstd_ccy: ActiveOrHistoricCurrencyCode,
#[yaserde(rename = "VartnMrgnPstdCcy")]
#[cfg_attr(feature = "serde", serde(rename = "VartnMrgnPstdCcy"))]
pub vartn_mrgn_pstd_ccy: ActiveOrHistoricCurrencyCode,
#[yaserde(rename = "InitlMrgnRcvdCcy")]
#[cfg_attr(feature = "serde", serde(rename = "InitlMrgnRcvdCcy"))]
pub initl_mrgn_rcvd_ccy: ActiveOrHistoricCurrencyCode,
#[yaserde(rename = "VartnMrgnRcvdCcy")]
#[cfg_attr(feature = "serde", serde(rename = "VartnMrgnRcvdCcy"))]
pub vartn_mrgn_rcvd_ccy: ActiveOrHistoricCurrencyCode,
#[yaserde(rename = "XcssCollPstdCcy")]
#[cfg_attr(feature = "serde", serde(rename = "XcssCollPstdCcy"))]
pub xcss_coll_pstd_ccy: ActiveOrHistoricCurrencyCode,
#[yaserde(rename = "XcssCollRcvdCcy")]
#[cfg_attr(feature = "serde", serde(rename = "XcssCollRcvdCcy"))]
pub xcss_coll_rcvd_ccy: ActiveOrHistoricCurrencyCode,
}
impl Validate for PositionSetCollateralDimensions3 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct PositionSetCollateralMetrics2 {
#[yaserde(rename = "Ttl")]
#[cfg_attr(feature = "serde", serde(rename = "Ttl"))]
pub ttl: PositionSetCollateralTotal2,
#[yaserde(rename = "Clean")]
#[cfg_attr(feature = "serde", serde(rename = "Clean"))]
pub clean: PositionSetCollateralTotal2,
}
impl Validate for PositionSetCollateralMetrics2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct PositionSetCollateralTotal2 {
#[yaserde(rename = "NbOfRpts")]
#[cfg_attr(feature = "serde", serde(rename = "NbOfRpts"))]
pub nb_of_rpts: Max20PositiveNumber,
#[yaserde(rename = "PstdMrgnOrColl")]
#[cfg_attr(feature = "serde", serde(rename = "PstdMrgnOrColl"))]
pub pstd_mrgn_or_coll: PostedMarginOrCollateral6,
#[yaserde(rename = "RcvdMrgnOrColl")]
#[cfg_attr(feature = "serde", serde(rename = "RcvdMrgnOrColl"))]
pub rcvd_mrgn_or_coll: ReceivedMarginOrCollateral6,
}
impl Validate for PositionSetCollateralTotal2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct PositionSetDimensions16 {
#[yaserde(rename = "CtrPtyId")]
#[cfg_attr(feature = "serde", serde(rename = "CtrPtyId"))]
pub ctr_pty_id: TradeCounterpartyReport20,
#[yaserde(rename = "ValCcy")]
#[cfg_attr(feature = "serde", serde(rename = "ValCcy"))]
pub val_ccy: ActiveOrHistoricCurrencyCode,
#[yaserde(rename = "Coll")]
#[cfg_attr(feature = "serde", serde(rename = "Coll"))]
pub coll: MarginCollateralReport4,
#[yaserde(rename = "CtrctTp")]
#[cfg_attr(feature = "serde", serde(rename = "CtrctTp"))]
pub ctrct_tp: FinancialInstrumentContractType2Code,
#[yaserde(rename = "AsstClss")]
#[cfg_attr(feature = "serde", serde(rename = "AsstClss"))]
pub asst_clss: ProductType4Code,
#[yaserde(rename = "UndrlygInstrm")]
#[cfg_attr(feature = "serde", serde(rename = "UndrlygInstrm"))]
pub undrlyg_instrm: SecurityIdentification41Choice,
#[yaserde(rename = "NtnlCcy")]
#[cfg_attr(feature = "serde", serde(rename = "NtnlCcy"))]
pub ntnl_ccy: ActiveOrHistoricCurrencyCode,
#[yaserde(rename = "NtnlCcyScndLeg")]
#[cfg_attr(feature = "serde", serde(rename = "NtnlCcyScndLeg"))]
pub ntnl_ccy_scnd_leg: ActiveOrHistoricCurrencyCode,
#[yaserde(rename = "SttlmCcy")]
#[cfg_attr(feature = "serde", serde(rename = "SttlmCcy"))]
pub sttlm_ccy: ActiveOrHistoricCurrencyCode,
#[yaserde(rename = "SttlmCcyScndLeg")]
#[cfg_attr(feature = "serde", serde(rename = "SttlmCcyScndLeg"))]
pub sttlm_ccy_scnd_leg: ActiveOrHistoricCurrencyCode,
#[yaserde(rename = "MstrAgrmt")]
#[cfg_attr(feature = "serde", serde(rename = "MstrAgrmt"))]
pub mstr_agrmt: MasterAgreement8,
#[yaserde(rename = "Clrd")]
#[cfg_attr(feature = "serde", serde(rename = "Clrd"))]
pub clrd: TrueFalseIndicator,
#[yaserde(rename = "IntraGrp")]
#[cfg_attr(feature = "serde", serde(rename = "IntraGrp"))]
pub intra_grp: TrueFalseIndicator,
#[yaserde(rename = "XchgRateBsis")]
#[cfg_attr(feature = "serde", serde(rename = "XchgRateBsis"))]
pub xchg_rate_bsis: ExchangeRateBasis1Choice,
#[yaserde(rename = "OptnTp")]
#[cfg_attr(feature = "serde", serde(rename = "OptnTp"))]
pub optn_tp: OptionType2Code,
#[yaserde(rename = "TmToMtrty")]
#[cfg_attr(feature = "serde", serde(rename = "TmToMtrty"))]
pub tm_to_mtrty: TimeToMaturity1Choice,
#[yaserde(rename = "IRSTp")]
#[cfg_attr(feature = "serde", serde(rename = "IRSTp"))]
pub irs_tp: Max52Text,
#[yaserde(rename = "Cdt")]
#[cfg_attr(feature = "serde", serde(rename = "Cdt"))]
pub cdt: CreditDerivative7,
#[yaserde(rename = "Cmmdty")]
#[cfg_attr(feature = "serde", serde(rename = "Cmmdty"))]
pub cmmdty: AssetClassCommodity6Choice,
#[yaserde(rename = "OthrPmt")]
#[cfg_attr(feature = "serde", serde(rename = "OthrPmt"))]
pub othr_pmt: OtherPayment6,
}
impl Validate for PositionSetDimensions16 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct PositionSetMetrics14 {
#[yaserde(rename = "Ttl")]
#[cfg_attr(feature = "serde", serde(rename = "Ttl"))]
pub ttl: PositionSetBuyerAndSeller2,
#[yaserde(rename = "Clean")]
#[cfg_attr(feature = "serde", serde(rename = "Clean"))]
pub clean: PositionSetBuyerAndSeller2,
}
impl Validate for PositionSetMetrics14 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct PositionSetTotal2 {
#[yaserde(rename = "NbOfTrds")]
#[cfg_attr(feature = "serde", serde(rename = "NbOfTrds"))]
pub nb_of_trds: Max20PositiveNumber,
#[yaserde(rename = "PostvVal")]
#[cfg_attr(feature = "serde", serde(rename = "PostvVal"))]
pub postv_val: ActiveOrHistoricCurrencyAnd19DecimalAmount,
#[yaserde(rename = "NegVal")]
#[cfg_attr(feature = "serde", serde(rename = "NegVal"))]
pub neg_val: ActiveOrHistoricCurrencyAnd19DecimalAmount,
#[yaserde(rename = "Ntnl")]
#[cfg_attr(feature = "serde", serde(rename = "Ntnl"))]
pub ntnl: NotionalAmountLegs6,
#[yaserde(rename = "OthrPmtAmt")]
#[cfg_attr(feature = "serde", serde(rename = "OthrPmtAmt"))]
pub othr_pmt_amt: Vec<ActiveOrHistoricCurrencyAnd19DecimalAmount>,
}
impl Validate for PositionSetTotal2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct PostedMarginOrCollateral6 {
#[yaserde(rename = "InitlMrgnPstdPreHrcut")]
#[cfg_attr(feature = "serde", serde(rename = "InitlMrgnPstdPreHrcut"))]
pub initl_mrgn_pstd_pre_hrcut: ActiveOrHistoricCurrencyAnd20DecimalAmount,
#[yaserde(rename = "InitlMrgnPstdPstHrcut")]
#[cfg_attr(feature = "serde", serde(rename = "InitlMrgnPstdPstHrcut"))]
pub initl_mrgn_pstd_pst_hrcut: ActiveOrHistoricCurrencyAnd20DecimalAmount,
#[yaserde(rename = "VartnMrgnPstdPreHrcut")]
#[cfg_attr(feature = "serde", serde(rename = "VartnMrgnPstdPreHrcut"))]
pub vartn_mrgn_pstd_pre_hrcut: ActiveOrHistoricCurrencyAnd20DecimalAmount,
#[yaserde(rename = "VartnMrgnPstdPstHrcut")]
#[cfg_attr(feature = "serde", serde(rename = "VartnMrgnPstdPstHrcut"))]
pub vartn_mrgn_pstd_pst_hrcut: ActiveOrHistoricCurrencyAnd20DecimalAmount,
#[yaserde(rename = "XcssCollPstd")]
#[cfg_attr(feature = "serde", serde(rename = "XcssCollPstd"))]
pub xcss_coll_pstd: ActiveOrHistoricCurrencyAnd20DecimalAmount,
}
impl Validate for PostedMarginOrCollateral6 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum RateBasis1Code {
#[yaserde(rename = "DAYS")]
#[cfg_attr(feature = "serde", serde(rename = "DAYS"))]
Days,
#[yaserde(rename = "MNTH")]
#[cfg_attr(feature = "serde", serde(rename = "MNTH"))]
Mnth,
#[yaserde(rename = "WEEK")]
#[cfg_attr(feature = "serde", serde(rename = "WEEK"))]
Week,
#[yaserde(rename = "YEAR")]
#[cfg_attr(feature = "serde", serde(rename = "YEAR"))]
Year,
__Unknown__(String),
}
impl Default for RateBasis1Code {
fn default() -> RateBasis1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for RateBasis1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct ReceivedMarginOrCollateral6 {
#[yaserde(rename = "InitlMrgnRcvdPreHrcut")]
#[cfg_attr(feature = "serde", serde(rename = "InitlMrgnRcvdPreHrcut"))]
pub initl_mrgn_rcvd_pre_hrcut: ActiveOrHistoricCurrencyAnd20DecimalAmount,
#[yaserde(rename = "InitlMrgnRcvdPstHrcut")]
#[cfg_attr(feature = "serde", serde(rename = "InitlMrgnRcvdPstHrcut"))]
pub initl_mrgn_rcvd_pst_hrcut: ActiveOrHistoricCurrencyAnd20DecimalAmount,
#[yaserde(rename = "VartnMrgnRcvdPreHrcut")]
#[cfg_attr(feature = "serde", serde(rename = "VartnMrgnRcvdPreHrcut"))]
pub vartn_mrgn_rcvd_pre_hrcut: ActiveOrHistoricCurrencyAnd20DecimalAmount,
#[yaserde(rename = "VartnMrgnRcvdPstHrcut")]
#[cfg_attr(feature = "serde", serde(rename = "VartnMrgnRcvdPstHrcut"))]
pub vartn_mrgn_rcvd_pst_hrcut: ActiveOrHistoricCurrencyAnd20DecimalAmount,
#[yaserde(rename = "XcssCollRcvd")]
#[cfg_attr(feature = "serde", serde(rename = "XcssCollRcvd"))]
pub xcss_coll_rcvd: ActiveOrHistoricCurrencyAnd20DecimalAmount,
}
impl Validate for ReceivedMarginOrCollateral6 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum ReportPeriodActivity1Code {
#[yaserde(rename = "NOTX")]
#[cfg_attr(feature = "serde", serde(rename = "NOTX"))]
Notx,
__Unknown__(String),
}
impl Default for ReportPeriodActivity1Code {
fn default() -> ReportPeriodActivity1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for ReportPeriodActivity1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct ReportingExemption1 {
#[yaserde(rename = "Rsn")]
#[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
pub rsn: Max4Text,
#[yaserde(rename = "Desc")]
#[cfg_attr(feature = "serde", serde(rename = "Desc"))]
pub desc: Max1000Text,
}
impl Validate for ReportingExemption1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum SpecialPurpose2Code {
#[yaserde(rename = "BLNK")]
#[cfg_attr(feature = "serde", serde(rename = "BLNK"))]
Blnk,
#[yaserde(rename = "NTAV")]
#[cfg_attr(feature = "serde", serde(rename = "NTAV"))]
Ntav,
__Unknown__(String),
}
impl Default for SpecialPurpose2Code {
fn default() -> SpecialPurpose2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for SpecialPurpose2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct SupplementaryData1 {
#[yaserde(rename = "PlcAndNm")]
#[cfg_attr(feature = "serde", serde(rename = "PlcAndNm"))]
pub plc_and_nm: Max350Text,
#[yaserde(rename = "Envlp")]
#[cfg_attr(feature = "serde", serde(rename = "Envlp"))]
pub envlp: SupplementaryDataEnvelope1,
}
impl Validate for SupplementaryData1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct SupplementaryDataEnvelope1 {}
impl Validate for SupplementaryDataEnvelope1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct TimeToMaturity1Choice {
#[yaserde(rename = "Prd")]
#[cfg_attr(feature = "serde", serde(rename = "Prd"))]
pub prd: Option<TimeToMaturityPeriod1>,
#[yaserde(rename = "Spcl")]
#[cfg_attr(feature = "serde", serde(rename = "Spcl"))]
pub spcl: Option<SpecialPurpose2Code>,
}
impl Validate for TimeToMaturity1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct TimeToMaturityPeriod1 {
#[yaserde(rename = "Start")]
#[cfg_attr(feature = "serde", serde(rename = "Start"))]
pub start: MaturityTerm2,
#[yaserde(rename = "End")]
#[cfg_attr(feature = "serde", serde(rename = "End"))]
pub end: MaturityTerm2,
}
impl Validate for TimeToMaturityPeriod1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct TradeCounterpartyRelationship1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<ExternalPartyRelationshipType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<Max100Text>,
}
impl Validate for TradeCounterpartyRelationship1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct TradeCounterpartyRelationshipRecord1 {
#[yaserde(rename = "StartRltshPty")]
#[cfg_attr(feature = "serde", serde(rename = "StartRltshPty"))]
pub start_rltsh_pty: TradeCounterpartyType1Code,
#[yaserde(rename = "EndRltshPty")]
#[cfg_attr(feature = "serde", serde(rename = "EndRltshPty"))]
pub end_rltsh_pty: TradeCounterpartyType1Code,
#[yaserde(rename = "RltshTp")]
#[cfg_attr(feature = "serde", serde(rename = "RltshTp"))]
pub rltsh_tp: TradeCounterpartyRelationship1Choice,
#[yaserde(rename = "Desc")]
#[cfg_attr(feature = "serde", serde(rename = "Desc"))]
pub desc: Max1000Text,
}
impl Validate for TradeCounterpartyRelationshipRecord1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub struct TradeCounterpartyReport20 {
#[yaserde(rename = "RptgCtrPty")]
#[cfg_attr(feature = "serde", serde(rename = "RptgCtrPty"))]
pub rptg_ctr_pty: Counterparty45,
#[yaserde(rename = "OthrCtrPty")]
#[cfg_attr(feature = "serde", serde(rename = "OthrCtrPty"))]
pub othr_ctr_pty: Counterparty46,
#[yaserde(rename = "Brkr")]
#[cfg_attr(feature = "serde", serde(rename = "Brkr"))]
pub brkr: OrganisationIdentification15Choice,
#[yaserde(rename = "SubmitgAgt")]
#[cfg_attr(feature = "serde", serde(rename = "SubmitgAgt"))]
pub submitg_agt: OrganisationIdentification15Choice,
#[yaserde(rename = "ClrMmb")]
#[cfg_attr(feature = "serde", serde(rename = "ClrMmb"))]
pub clr_mmb: PartyIdentification248Choice,
#[yaserde(rename = "Bnfcry")]
#[cfg_attr(feature = "serde", serde(rename = "Bnfcry"))]
pub bnfcry: Vec<PartyIdentification248Choice>,
#[yaserde(rename = "NttyRspnsblForRpt")]
#[cfg_attr(feature = "serde", serde(rename = "NttyRspnsblForRpt"))]
pub ntty_rspnsbl_for_rpt: OrganisationIdentification15Choice,
#[yaserde(rename = "ExctnAgt")]
#[cfg_attr(feature = "serde", serde(rename = "ExctnAgt"))]
pub exctn_agt: Vec<OrganisationIdentification15Choice>,
#[yaserde(rename = "RltshRcrd")]
#[cfg_attr(feature = "serde", serde(rename = "RltshRcrd"))]
pub rltsh_rcrd: Vec<TradeCounterpartyRelationshipRecord1>,
}
impl Validate for TradeCounterpartyReport20 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum TradeCounterpartyType1Code {
#[yaserde(rename = "BENE")]
#[cfg_attr(feature = "serde", serde(rename = "BENE"))]
Bene,
#[yaserde(rename = "BROK")]
#[cfg_attr(feature = "serde", serde(rename = "BROK"))]
Brok,
#[yaserde(rename = "CLEM")]
#[cfg_attr(feature = "serde", serde(rename = "CLEM"))]
Clem,
#[yaserde(rename = "EXEA")]
#[cfg_attr(feature = "serde", serde(rename = "EXEA"))]
Exea,
#[yaserde(rename = "OTHC")]
#[cfg_attr(feature = "serde", serde(rename = "OTHC"))]
Othc,
#[yaserde(rename = "REPC")]
#[cfg_attr(feature = "serde", serde(rename = "REPC"))]
Repc,
#[yaserde(rename = "SBMA")]
#[cfg_attr(feature = "serde", serde(rename = "SBMA"))]
Sbma,
#[yaserde(rename = "ERFR")]
#[cfg_attr(feature = "serde", serde(rename = "ERFR"))]
Erfr,
__Unknown__(String),
}
impl Default for TradeCounterpartyType1Code {
fn default() -> TradeCounterpartyType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for TradeCounterpartyType1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
pub enum TradingCapacity7Code {
#[yaserde(rename = "AGEN")]
#[cfg_attr(feature = "serde", serde(rename = "AGEN"))]
Agen,
#[yaserde(rename = "PRIN")]
#[cfg_attr(feature = "serde", serde(rename = "PRIN"))]
Prin,
__Unknown__(String),
}
impl Default for TradingCapacity7Code {
fn default() -> TradingCapacity7Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for TradingCapacity7Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct TrueFalseIndicator (pub bool);
crate::simple_type!(TrueFalseIndicator);
impl Validate for TrueFalseIndicator {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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.090.001.02")]
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 {}
impl crate::MxMessage for Document {
const BUSINESS_AREA: crate::BusinessArea = crate::BusinessArea::auth;
const FUNCTIONALITY: &'static str = "090";
const VARIANT: &'static str = "001";
const VERSION: &'static str = "02";
const MESSAGE_NAME: &'static str = "auth.090.001.02";
const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:auth.090.001.02";
}