rust_iso20022 0.1.1

// @generated by src/bin/codegen.rs from the ISO 20022 XSD schema. Do not edit.
#![allow(clippy::all)]
#![allow(non_snake_case, non_camel_case_types, dead_code, unused_imports)]
// yaserde_derive 0.7 emits trait impls inside nested choice submodules, which
// trips the `non_local_definitions` lint on recent rustc. The generated code is
// correct; silence the lint here.
#![allow(non_local_definitions)]
use std::str::FromStr;
use crate::validate::Validate;
use yaserde_derive::{YaDeserialize, YaSerialize};

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

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

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

pub enum AssetClassSubProductType19Code {
    #[yaserde(rename = "DLVR")]
    #[cfg_attr(feature = "serde", serde(rename = "DLVR"))]
    Dlvr,
    #[yaserde(rename = "NDLV")]
    #[cfg_attr(feature = "serde", serde(rename = "NDLV"))]
    Ndlv,
    __Unknown__(String),
}

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

impl Validate for AssetClassSubProductType19Code {}



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

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

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

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

impl Validate for BenchmarkCurveName5Choice {}




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

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

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

impl Validate for BondDerivative2 {}


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

pub enum BondType1Code {
    #[yaserde(rename = "EUSB")]
    #[cfg_attr(feature = "serde", serde(rename = "EUSB"))]
    Eusb,
    #[yaserde(rename = "OEPB")]
    #[cfg_attr(feature = "serde", serde(rename = "OEPB"))]
    Oepb,
    #[yaserde(rename = "CVTB")]
    #[cfg_attr(feature = "serde", serde(rename = "CVTB"))]
    Cvtb,
    #[yaserde(rename = "CRPB")]
    #[cfg_attr(feature = "serde", serde(rename = "CRPB"))]
    Crpb,
    #[yaserde(rename = "CVDB")]
    #[cfg_attr(feature = "serde", serde(rename = "CVDB"))]
    Cvdb,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    __Unknown__(String),
}

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

impl Validate for BondType1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.033.001.02")]
pub struct CommodityDerivative2Choice {
    #[yaserde(rename = "Frght")]
    #[cfg_attr(feature = "serde", serde(rename = "Frght"))]
    pub frght: Option<CommodityDerivative5>,
    #[yaserde(rename = "Nrgy")]
    #[cfg_attr(feature = "serde", serde(rename = "Nrgy"))]
    pub nrgy: Option<CommodityDerivative6>,
}

impl Validate for CommodityDerivative2Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.033.001.02")]
pub struct CommodityDerivative4 {
    #[yaserde(rename = "ClssSpcfc")]
    #[cfg_attr(feature = "serde", serde(rename = "ClssSpcfc"))]
    pub clss_spcfc: CommodityDerivative2Choice,

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

impl Validate for CommodityDerivative4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.033.001.02")]
pub struct CommodityDerivative5 {
    #[yaserde(rename = "Sz")]
    #[cfg_attr(feature = "serde", serde(rename = "Sz"))]
    pub sz: Max25Text,

    #[yaserde(rename = "AvrgTmChrtr")]
    #[cfg_attr(feature = "serde", serde(rename = "AvrgTmChrtr"))]
    pub avrg_tm_chrtr: Max25Text,
}

impl Validate for CommodityDerivative5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.033.001.02")]
pub struct CommodityDerivative6 {
    #[yaserde(rename = "SttlmLctn")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmLctn"))]
    pub sttlm_lctn: Max25Text,
}

impl Validate for CommodityDerivative6 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.033.001.02")]
pub struct ContractForDifference2 {
    #[yaserde(rename = "UndrlygTp")]
    #[cfg_attr(feature = "serde", serde(rename = "UndrlygTp"))]
    pub undrlyg_tp: UnderlyingContractForDifferenceType3Code,

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

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

impl Validate for ContractForDifference2 {}


#[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.033.001.02")]
pub struct CreditDefaultSwapDerivative5 {
    #[yaserde(rename = "UndrlygCdtDfltSwpId")]
    #[cfg_attr(feature = "serde", serde(rename = "UndrlygCdtDfltSwpId"))]
    pub undrlyg_cdt_dflt_swp_id: Isinoct2015Identifier,

    #[yaserde(rename = "UndrlygCdtDfltSwpIndx")]
    #[cfg_attr(feature = "serde", serde(rename = "UndrlygCdtDfltSwpIndx"))]
    pub undrlyg_cdt_dflt_swp_indx: CreditDefaultSwapIndex3,
}

impl Validate for CreditDefaultSwapDerivative5 {}


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

    #[yaserde(rename = "OblgtnId")]
    #[cfg_attr(feature = "serde", serde(rename = "OblgtnId"))]
    pub oblgtn_id: Isinoct2015Identifier,

    #[yaserde(rename = "SnglNm")]
    #[cfg_attr(feature = "serde", serde(rename = "SnglNm"))]
    pub sngl_nm: CreditDefaultSwapSingleName2,
}

impl Validate for CreditDefaultSwapDerivative6 {}


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

    #[yaserde(rename = "UndrlygIndxNm")]
    #[cfg_attr(feature = "serde", serde(rename = "UndrlygIndxNm"))]
    pub undrlyg_indx_nm: Max25Text,

    #[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 = "RollMnth")]
    #[cfg_attr(feature = "serde", serde(rename = "RollMnth"))]
    pub roll_mnth: Vec<RestrictedMonthExact2Number>,

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

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

impl Validate for CreditDefaultSwapIndex3 {}


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

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

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

impl Validate for CreditDefaultSwapSingleName2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.033.001.02")]
pub struct CreditDefaultSwapsDerivative4Choice {
    #[yaserde(rename = "SnglNmCdtDfltSwp")]
    #[cfg_attr(feature = "serde", serde(rename = "SnglNmCdtDfltSwp"))]
    pub sngl_nm_cdt_dflt_swp: Option<CreditDefaultSwapSingleName2>,
    #[yaserde(rename = "CdtDfltSwpIndx")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtDfltSwpIndx"))]
    pub cdt_dflt_swp_indx: Option<CreditDefaultSwapIndex3>,
    #[yaserde(rename = "SnglNmCdtDfltSwpDeriv")]
    #[cfg_attr(feature = "serde", serde(rename = "SnglNmCdtDfltSwpDeriv"))]
    pub sngl_nm_cdt_dflt_swp_deriv: Option<CreditDefaultSwapDerivative6>,
    #[yaserde(rename = "CdtDfltSwpIndxDeriv")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtDfltSwpIndxDeriv"))]
    pub cdt_dflt_swp_indx_deriv: Option<CreditDefaultSwapDerivative5>,
}

impl Validate for CreditDefaultSwapsDerivative4Choice {}




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

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

impl Validate for DebtInstrument5 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.033.001.02")]
pub struct Derivative3Choice {
    #[yaserde(rename = "Cmmdty")]
    #[cfg_attr(feature = "serde", serde(rename = "Cmmdty"))]
    pub cmmdty: Option<CommodityDerivative4>,
    #[yaserde(rename = "IntrstRate")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstRate"))]
    pub intrst_rate: Option<InterestRateDerivative5>,
    #[yaserde(rename = "FX")]
    #[cfg_attr(feature = "serde", serde(rename = "FX"))]
    pub fx: Option<ForeignExchangeDerivative2>,
    #[yaserde(rename = "Eqty")]
    #[cfg_attr(feature = "serde", serde(rename = "Eqty"))]
    pub eqty: Option<EquityDerivative2>,
    #[yaserde(rename = "CtrctForDiff")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrctForDiff"))]
    pub ctrct_for_diff: Option<ContractForDifference2>,
    #[yaserde(rename = "Cdt")]
    #[cfg_attr(feature = "serde", serde(rename = "Cdt"))]
    pub cdt: Option<CreditDefaultSwapsDerivative4Choice>,
    #[yaserde(rename = "EmssnAllwnc")]
    #[cfg_attr(feature = "serde", serde(rename = "EmssnAllwnc"))]
    pub emssn_allwnc: Option<EmissionAllowanceProductType1Code>,
}

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

impl Validate for Document {}


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

pub enum EmissionAllowanceProductType1Code {
    #[yaserde(rename = "EUAA")]
    #[cfg_attr(feature = "serde", serde(rename = "EUAA"))]
    Euaa,
    #[yaserde(rename = "EUAE")]
    #[cfg_attr(feature = "serde", serde(rename = "EUAE"))]
    Euae,
    #[yaserde(rename = "ERUE")]
    #[cfg_attr(feature = "serde", serde(rename = "ERUE"))]
    Erue,
    #[yaserde(rename = "CERE")]
    #[cfg_attr(feature = "serde", serde(rename = "CERE"))]
    Cere,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    __Unknown__(String),
}

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

impl Validate for EmissionAllowanceProductType1Code {}



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

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

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

impl Validate for EmissionAllowanceProductType2Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.033.001.02")]
pub struct EquityDerivative2 {
    #[yaserde(rename = "UndrlygTp")]
    #[cfg_attr(feature = "serde", serde(rename = "UndrlygTp"))]
    pub undrlyg_tp: EquityDerivative3Choice,

    #[yaserde(rename = "Param")]
    #[cfg_attr(feature = "serde", serde(rename = "Param"))]
    pub param: EquityReturnParameter1Code,
}

impl Validate for EquityDerivative2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.033.001.02")]
pub struct EquityDerivative3Choice {
    #[yaserde(rename = "Bskt")]
    #[cfg_attr(feature = "serde", serde(rename = "Bskt"))]
    pub bskt: Option<UnderlyingEquityType3Code>,
    #[yaserde(rename = "Indx")]
    #[cfg_attr(feature = "serde", serde(rename = "Indx"))]
    pub indx: Option<UnderlyingEquityType4Code>,
    #[yaserde(rename = "SnglNm")]
    #[cfg_attr(feature = "serde", serde(rename = "SnglNm"))]
    pub sngl_nm: Option<UnderlyingEquityType5Code>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<UnderlyingEquityType6Code>,
}

impl Validate for EquityDerivative3Choice {}




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

pub enum EquityReturnParameter1Code {
    #[yaserde(rename = "PRDV")]
    #[cfg_attr(feature = "serde", serde(rename = "PRDV"))]
    Prdv,
    #[yaserde(rename = "PRVA")]
    #[cfg_attr(feature = "serde", serde(rename = "PRVA"))]
    Prva,
    #[yaserde(rename = "PRVO")]
    #[cfg_attr(feature = "serde", serde(rename = "PRVO"))]
    Prvo,
    #[yaserde(rename = "PRBP")]
    #[cfg_attr(feature = "serde", serde(rename = "PRBP"))]
    Prbp,
    __Unknown__(String),
}

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

impl Validate for EquityReturnParameter1Code {}



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

pub enum FinancialInstrumentContractType1Code {
    #[yaserde(rename = "CFDS")]
    #[cfg_attr(feature = "serde", serde(rename = "CFDS"))]
    Cfds,
    #[yaserde(rename = "FORW")]
    #[cfg_attr(feature = "serde", serde(rename = "FORW"))]
    Forw,
    #[yaserde(rename = "FRAS")]
    #[cfg_attr(feature = "serde", serde(rename = "FRAS"))]
    Fras,
    #[yaserde(rename = "FUTR")]
    #[cfg_attr(feature = "serde", serde(rename = "FUTR"))]
    Futr,
    #[yaserde(rename = "OPTN")]
    #[cfg_attr(feature = "serde", serde(rename = "OPTN"))]
    Optn,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[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 = "FONS")]
    #[cfg_attr(feature = "serde", serde(rename = "FONS"))]
    Fons,
    #[yaserde(rename = "PSWP")]
    #[cfg_attr(feature = "serde", serde(rename = "PSWP"))]
    Pswp,
    #[yaserde(rename = "FFAS")]
    #[cfg_attr(feature = "serde", serde(rename = "FFAS"))]
    Ffas,
    #[yaserde(rename = "FWOS")]
    #[cfg_attr(feature = "serde", serde(rename = "FWOS"))]
    Fwos,
    __Unknown__(String),
}

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

impl Validate for FinancialInstrumentContractType1Code {}



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

    #[yaserde(rename = "NonEqtyTrnsprncyData")]
    #[cfg_attr(feature = "serde", serde(rename = "NonEqtyTrnsprncyData"))]
    pub non_eqty_trnsprncy_data: Vec<TransparencyDataReport16>,

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

impl Validate for FinancialInstrumentReportingNonEquityTransparencyDataReportV02 {}


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

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

impl Validate for FloatingInterestRate8 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.033.001.02")]
pub struct ForeignExchangeDerivative2 {
    #[yaserde(rename = "CtrctSubTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrctSubTp"))]
    pub ctrct_sub_tp: AssetClassSubProductType19Code,
}

impl Validate for ForeignExchangeDerivative2 {}


#[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.033.001.02")]
pub struct InflationIndex1Choice {
    #[yaserde(rename = "ISIN")]
    #[cfg_attr(feature = "serde", serde(rename = "ISIN"))]
    pub isin: Option<Isinoct2015Identifier>,
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Option<Max25Text>,
}

impl Validate for InflationIndex1Choice {}




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

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

impl Validate for InterestRateContractTerm2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.033.001.02")]
pub struct InterestRateDerivative2Choice {
    #[yaserde(rename = "SwpRltd")]
    #[cfg_attr(feature = "serde", serde(rename = "SwpRltd"))]
    pub swp_rltd: Option<SwapType1Code>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<UnderlyingInterestRateType3Code>,
}

impl Validate for InterestRateDerivative2Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.033.001.02")]
pub struct InterestRateDerivative5 {
    #[yaserde(rename = "UndrlygTp")]
    #[cfg_attr(feature = "serde", serde(rename = "UndrlygTp"))]
    pub undrlyg_tp: InterestRateDerivative2Choice,

    #[yaserde(rename = "UndrlygBd")]
    #[cfg_attr(feature = "serde", serde(rename = "UndrlygBd"))]
    pub undrlyg_bd: BondDerivative2,

    #[yaserde(rename = "SwptnNtnlCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "SwptnNtnlCcy"))]
    pub swptn_ntnl_ccy: ActiveCurrencyCode,

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

    #[yaserde(rename = "InfltnIndx")]
    #[cfg_attr(feature = "serde", serde(rename = "InfltnIndx"))]
    pub infltn_indx: InflationIndex1Choice,

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

impl Validate for InterestRateDerivative5 {}


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

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

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

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

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

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

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

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

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

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

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

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

pub enum NonEquityInstrumentReportingClassification1Code {
    #[yaserde(rename = "SFPS")]
    #[cfg_attr(feature = "serde", serde(rename = "SFPS"))]
    Sfps,
    #[yaserde(rename = "SDRV")]
    #[cfg_attr(feature = "serde", serde(rename = "SDRV"))]
    Sdrv,
    #[yaserde(rename = "DERV")]
    #[cfg_attr(feature = "serde", serde(rename = "DERV"))]
    Derv,
    #[yaserde(rename = "EMAL")]
    #[cfg_attr(feature = "serde", serde(rename = "EMAL"))]
    Emal,
    #[yaserde(rename = "BOND")]
    #[cfg_attr(feature = "serde", serde(rename = "BOND"))]
    Bond,
    #[yaserde(rename = "ETCS")]
    #[cfg_attr(feature = "serde", serde(rename = "ETCS"))]
    Etcs,
    #[yaserde(rename = "ETNS")]
    #[cfg_attr(feature = "serde", serde(rename = "ETNS"))]
    Etns,
    __Unknown__(String),
}

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

impl Validate for NonEquityInstrumentReportingClassification1Code {}



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

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

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

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

impl Validate for Period4Choice {}




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

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

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

impl Validate for ProductType5Code {}



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

impl Validate for RestrictedMonthExact2Number {
    fn validate(&self) -> Result<(), String> { 
        if self.0 < "1".parse::<String>().unwrap() {
            return Err(format!("MinInclusive validation error: invalid value of 0! \nExpected: 0 >= 1.\nActual: 0 == {}", self.0));
        }
        if self.0 > "12".parse::<String>().unwrap() {
            return Err(format!("MaxInclusive validation error: invalid value of 0! \nExpected: 0 <= 12.\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.033.001.02")]
pub struct SecuritiesMarketReportHeader1 {
    #[yaserde(rename = "RptgNtty")]
    #[cfg_attr(feature = "serde", serde(rename = "RptgNtty"))]
    pub rptg_ntty: TradingVenueIdentification1Choice,

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

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

impl Validate for SecuritiesMarketReportHeader1 {}


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

impl Validate for SupplementaryDataEnvelope1 {}


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

pub enum SwapType1Code {
    #[yaserde(rename = "OSSC")]
    #[cfg_attr(feature = "serde", serde(rename = "OSSC"))]
    Ossc,
    #[yaserde(rename = "XFSC")]
    #[cfg_attr(feature = "serde", serde(rename = "XFSC"))]
    Xfsc,
    #[yaserde(rename = "XFMC")]
    #[cfg_attr(feature = "serde", serde(rename = "XFMC"))]
    Xfmc,
    #[yaserde(rename = "XXSC")]
    #[cfg_attr(feature = "serde", serde(rename = "XXSC"))]
    Xxsc,
    #[yaserde(rename = "XXMC")]
    #[cfg_attr(feature = "serde", serde(rename = "XXMC"))]
    Xxmc,
    #[yaserde(rename = "IFMC")]
    #[cfg_attr(feature = "serde", serde(rename = "IFMC"))]
    Ifmc,
    #[yaserde(rename = "FFSC")]
    #[cfg_attr(feature = "serde", serde(rename = "FFSC"))]
    Ffsc,
    #[yaserde(rename = "FFMC")]
    #[cfg_attr(feature = "serde", serde(rename = "FFMC"))]
    Ffmc,
    #[yaserde(rename = "IFSC")]
    #[cfg_attr(feature = "serde", serde(rename = "IFSC"))]
    Ifsc,
    #[yaserde(rename = "OSMC")]
    #[cfg_attr(feature = "serde", serde(rename = "OSMC"))]
    Osmc,
    __Unknown__(String),
}

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

impl Validate for SwapType1Code {}



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

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

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

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

impl Validate for TradingVenueIdentification1Choice {}




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

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

impl Validate for TradingVenueIdentification2 {}


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

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

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

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

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

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

    #[yaserde(rename = "FinInstrmClssfctn")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrmClssfctn"))]
    pub fin_instrm_clssfctn: NonEquityInstrumentReportingClassification1Code,

    #[yaserde(rename = "UndrlygInstrmAsstClss")]
    #[cfg_attr(feature = "serde", serde(rename = "UndrlygInstrmAsstClss"))]
    pub undrlyg_instrm_asst_clss: ProductType5Code,

    #[yaserde(rename = "DerivCtrctTp")]
    #[cfg_attr(feature = "serde", serde(rename = "DerivCtrctTp"))]
    pub deriv_ctrct_tp: FinancialInstrumentContractType1Code,

    #[yaserde(rename = "Bd")]
    #[cfg_attr(feature = "serde", serde(rename = "Bd"))]
    pub bd: DebtInstrument5,

    #[yaserde(rename = "EmssnAllwncTp")]
    #[cfg_attr(feature = "serde", serde(rename = "EmssnAllwncTp"))]
    pub emssn_allwnc_tp: EmissionAllowanceProductType2Code,

    #[yaserde(rename = "Deriv")]
    #[cfg_attr(feature = "serde", serde(rename = "Deriv"))]
    pub deriv: Derivative3Choice,
}

impl Validate for TransparencyDataReport16 {}


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

pub enum UnderlyingContractForDifferenceType3Code {
    #[yaserde(rename = "BOND")]
    #[cfg_attr(feature = "serde", serde(rename = "BOND"))]
    Bond,
    #[yaserde(rename = "COMM")]
    #[cfg_attr(feature = "serde", serde(rename = "COMM"))]
    Comm,
    #[yaserde(rename = "CURR")]
    #[cfg_attr(feature = "serde", serde(rename = "CURR"))]
    Curr,
    #[yaserde(rename = "EMAL")]
    #[cfg_attr(feature = "serde", serde(rename = "EMAL"))]
    Emal,
    #[yaserde(rename = "EQUI")]
    #[cfg_attr(feature = "serde", serde(rename = "EQUI"))]
    Equi,
    #[yaserde(rename = "FTEQ")]
    #[cfg_attr(feature = "serde", serde(rename = "FTEQ"))]
    Fteq,
    #[yaserde(rename = "OPEQ")]
    #[cfg_attr(feature = "serde", serde(rename = "OPEQ"))]
    Opeq,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    __Unknown__(String),
}

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

impl Validate for UnderlyingContractForDifferenceType3Code {}



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

pub enum UnderlyingEquityType3Code {
    #[yaserde(rename = "BSKT")]
    #[cfg_attr(feature = "serde", serde(rename = "BSKT"))]
    Bskt,
    __Unknown__(String),
}

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

impl Validate for UnderlyingEquityType3Code {}



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

pub enum UnderlyingEquityType4Code {
    #[yaserde(rename = "STIX")]
    #[cfg_attr(feature = "serde", serde(rename = "STIX"))]
    Stix,
    #[yaserde(rename = "DIVI")]
    #[cfg_attr(feature = "serde", serde(rename = "DIVI"))]
    Divi,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "VOLI")]
    #[cfg_attr(feature = "serde", serde(rename = "VOLI"))]
    Voli,
    __Unknown__(String),
}

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

impl Validate for UnderlyingEquityType4Code {}



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

pub enum UnderlyingEquityType5Code {
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "ETFS")]
    #[cfg_attr(feature = "serde", serde(rename = "ETFS"))]
    Etfs,
    #[yaserde(rename = "SHRS")]
    #[cfg_attr(feature = "serde", serde(rename = "SHRS"))]
    Shrs,
    #[yaserde(rename = "DVSE")]
    #[cfg_attr(feature = "serde", serde(rename = "DVSE"))]
    Dvse,
    __Unknown__(String),
}

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

impl Validate for UnderlyingEquityType5Code {}



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

pub enum UnderlyingEquityType6Code {
    #[yaserde(rename = "BSKT")]
    #[cfg_attr(feature = "serde", serde(rename = "BSKT"))]
    Bskt,
    #[yaserde(rename = "DIVI")]
    #[cfg_attr(feature = "serde", serde(rename = "DIVI"))]
    Divi,
    #[yaserde(rename = "ETFS")]
    #[cfg_attr(feature = "serde", serde(rename = "ETFS"))]
    Etfs,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "SHRS")]
    #[cfg_attr(feature = "serde", serde(rename = "SHRS"))]
    Shrs,
    #[yaserde(rename = "DVSE")]
    #[cfg_attr(feature = "serde", serde(rename = "DVSE"))]
    Dvse,
    #[yaserde(rename = "STIX")]
    #[cfg_attr(feature = "serde", serde(rename = "STIX"))]
    Stix,
    #[yaserde(rename = "VOLI")]
    #[cfg_attr(feature = "serde", serde(rename = "VOLI"))]
    Voli,
    __Unknown__(String),
}

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

impl Validate for UnderlyingEquityType6Code {}



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

pub enum UnderlyingInterestRateType3Code {
    #[yaserde(rename = "BOND")]
    #[cfg_attr(feature = "serde", serde(rename = "BOND"))]
    Bond,
    #[yaserde(rename = "BNDF")]
    #[cfg_attr(feature = "serde", serde(rename = "BNDF"))]
    Bndf,
    #[yaserde(rename = "INTR")]
    #[cfg_attr(feature = "serde", serde(rename = "INTR"))]
    Intr,
    #[yaserde(rename = "IFUT")]
    #[cfg_attr(feature = "serde", serde(rename = "IFUT"))]
    Ifut,
    __Unknown__(String),
}

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

impl Validate for UnderlyingInterestRateType3Code {}

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