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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct AccountAndBalance60 {
    #[yaserde(rename = "SfkpgAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgAcct"))]
    pub sfkpg_acct: Max35Text,

    #[yaserde(rename = "BlckChainAdrOrWllt")]
    #[cfg_attr(feature = "serde", serde(rename = "BlckChainAdrOrWllt"))]
    pub blck_chain_adr_or_wllt: Max140Text,

    #[yaserde(rename = "AcctOwnr")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctOwnr"))]
    pub acct_ownr: PartyIdentification127Choice,

    #[yaserde(rename = "SfkpgPlc")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgPlc"))]
    pub sfkpg_plc: SafekeepingPlaceFormat42Choice,

    #[yaserde(rename = "Bal")]
    #[cfg_attr(feature = "serde", serde(rename = "Bal"))]
    pub bal: CorporateActionBalanceDetails43,
}

impl Validate for AccountAndBalance60 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct AccountIdentification10 {
    #[yaserde(rename = "IdCd")]
    #[cfg_attr(feature = "serde", serde(rename = "IdCd"))]
    pub id_cd: SafekeepingAccountIdentification1Code,
}

impl Validate for AccountIdentification10 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct AccountIdentification71Choice {
    #[yaserde(rename = "ForAllAccts")]
    #[cfg_attr(feature = "serde", serde(rename = "ForAllAccts"))]
    pub for_all_accts: Option<AccountIdentification10>,
    #[yaserde(rename = "AcctsListAndBalDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctsListAndBalDtls"))]
    pub accts_list_and_bal_dtls: Vec<AccountAndBalance60>,
}

impl Validate for AccountIdentification71Choice {}




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

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

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

impl Validate for ActiveCurrencyAnd13DecimalAmount {}


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

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

impl Validate for ActiveCurrencyAndAmount {}


#[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:seev.031.001.16")]

pub enum AdditionalBusinessProcess9Code {
    #[yaserde(rename = "ACLA")]
    #[cfg_attr(feature = "serde", serde(rename = "ACLA"))]
    Acla,
    #[yaserde(rename = "ATXF")]
    #[cfg_attr(feature = "serde", serde(rename = "ATXF"))]
    Atxf,
    #[yaserde(rename = "CNTR")]
    #[cfg_attr(feature = "serde", serde(rename = "CNTR"))]
    Cntr,
    #[yaserde(rename = "NAMC")]
    #[cfg_attr(feature = "serde", serde(rename = "NAMC"))]
    Namc,
    #[yaserde(rename = "NPLE")]
    #[cfg_attr(feature = "serde", serde(rename = "NPLE"))]
    Nple,
    #[yaserde(rename = "SCHM")]
    #[cfg_attr(feature = "serde", serde(rename = "SCHM"))]
    Schm,
    #[yaserde(rename = "CONS")]
    #[cfg_attr(feature = "serde", serde(rename = "CONS"))]
    Cons,
    #[yaserde(rename = "PPUT")]
    #[cfg_attr(feature = "serde", serde(rename = "PPUT"))]
    Pput,
    #[yaserde(rename = "FPRE")]
    #[cfg_attr(feature = "serde", serde(rename = "FPRE"))]
    Fpre,
    #[yaserde(rename = "PPRE")]
    #[cfg_attr(feature = "serde", serde(rename = "PPRE"))]
    Ppre,
    #[yaserde(rename = "REAC")]
    #[cfg_attr(feature = "serde", serde(rename = "REAC"))]
    Reac,
    #[yaserde(rename = "INCP")]
    #[cfg_attr(feature = "serde", serde(rename = "INCP"))]
    Incp,
    __Unknown__(String),
}

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

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

impl Validate for AdditionalBusinessProcessFormat17Choice {}




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

pub enum AddressType2Code {
    #[yaserde(rename = "ADDR")]
    #[cfg_attr(feature = "serde", serde(rename = "ADDR"))]
    Addr,
    #[yaserde(rename = "PBOX")]
    #[cfg_attr(feature = "serde", serde(rename = "PBOX"))]
    Pbox,
    #[yaserde(rename = "HOME")]
    #[cfg_attr(feature = "serde", serde(rename = "HOME"))]
    Home,
    #[yaserde(rename = "BIZZ")]
    #[cfg_attr(feature = "serde", serde(rename = "BIZZ"))]
    Bizz,
    #[yaserde(rename = "MLTO")]
    #[cfg_attr(feature = "serde", serde(rename = "MLTO"))]
    Mlto,
    #[yaserde(rename = "DLVY")]
    #[cfg_attr(feature = "serde", serde(rename = "DLVY"))]
    Dlvy,
    __Unknown__(String),
}

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

impl Validate for AddressType2Code {}



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

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

impl Validate for AmountAndQuantityRatio4 {}


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

    #[yaserde(rename = "RateSts")]
    #[cfg_attr(feature = "serde", serde(rename = "RateSts"))]
    pub rate_sts: RateStatus1Code,
}

impl Validate for AmountAndRateStatus1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct AmountPrice2 {
    #[yaserde(rename = "AmtPricTp")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtPricTp"))]
    pub amt_pric_tp: AmountPriceType2Code,

    #[yaserde(rename = "PricVal")]
    #[cfg_attr(feature = "serde", serde(rename = "PricVal"))]
    pub pric_val: ActiveCurrencyAnd13DecimalAmount,
}

impl Validate for AmountPrice2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct AmountPrice3 {
    #[yaserde(rename = "AmtPricTp")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtPricTp"))]
    pub amt_pric_tp: AmountPriceType1Code,

    #[yaserde(rename = "PricVal")]
    #[cfg_attr(feature = "serde", serde(rename = "PricVal"))]
    pub pric_val: ActiveCurrencyAnd13DecimalAmount,
}

impl Validate for AmountPrice3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct AmountPrice6 {
    #[yaserde(rename = "AmtPricTp")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtPricTp"))]
    pub amt_pric_tp: AmountPriceType3Code,

    #[yaserde(rename = "PricVal")]
    #[cfg_attr(feature = "serde", serde(rename = "PricVal"))]
    pub pric_val: ActiveCurrencyAnd13DecimalAmount,
}

impl Validate for AmountPrice6 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct AmountPricePerAmount2 {
    #[yaserde(rename = "AmtPricTp")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtPricTp"))]
    pub amt_pric_tp: AmountPriceType1Code,

    #[yaserde(rename = "PricVal")]
    #[cfg_attr(feature = "serde", serde(rename = "PricVal"))]
    pub pric_val: ActiveCurrencyAnd13DecimalAmount,

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

impl Validate for AmountPricePerAmount2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct AmountPricePerFinancialInstrumentQuantity10 {
    #[yaserde(rename = "AmtPricTp")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtPricTp"))]
    pub amt_pric_tp: AmountPriceType1Code,

    #[yaserde(rename = "PricVal")]
    #[cfg_attr(feature = "serde", serde(rename = "PricVal"))]
    pub pric_val: ActiveCurrencyAnd13DecimalAmount,

    #[yaserde(rename = "FinInstrmQty")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrmQty"))]
    pub fin_instrm_qty: FinancialInstrumentQuantity33Choice,
}

impl Validate for AmountPricePerFinancialInstrumentQuantity10 {}


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

pub enum AmountPriceType1Code {
    #[yaserde(rename = "ACTU")]
    #[cfg_attr(feature = "serde", serde(rename = "ACTU"))]
    Actu,
    #[yaserde(rename = "DISC")]
    #[cfg_attr(feature = "serde", serde(rename = "DISC"))]
    Disc,
    #[yaserde(rename = "PLOT")]
    #[cfg_attr(feature = "serde", serde(rename = "PLOT"))]
    Plot,
    #[yaserde(rename = "PREM")]
    #[cfg_attr(feature = "serde", serde(rename = "PREM"))]
    Prem,
    __Unknown__(String),
}

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

impl Validate for AmountPriceType1Code {}



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

pub enum AmountPriceType2Code {
    #[yaserde(rename = "ACTU")]
    #[cfg_attr(feature = "serde", serde(rename = "ACTU"))]
    Actu,
    __Unknown__(String),
}

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

impl Validate for AmountPriceType2Code {}



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

pub enum AmountPriceType3Code {
    #[yaserde(rename = "ACTU")]
    #[cfg_attr(feature = "serde", serde(rename = "ACTU"))]
    Actu,
    #[yaserde(rename = "PLOT")]
    #[cfg_attr(feature = "serde", serde(rename = "PLOT"))]
    Plot,
    __Unknown__(String),
}

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

impl Validate for AmountPriceType3Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct AmountToAmountRatio2 {
    #[yaserde(rename = "Amt1")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt1"))]
    pub amt_1: ActiveCurrencyAnd13DecimalAmount,

    #[yaserde(rename = "Amt2")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt2"))]
    pub amt_2: ActiveCurrencyAnd13DecimalAmount,
}

impl Validate for AmountToAmountRatio2 {}


#[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:seev.031.001.16")]
pub struct BalanceFormat11Choice {
    #[yaserde(rename = "Bal")]
    #[cfg_attr(feature = "serde", serde(rename = "Bal"))]
    pub bal: Option<SignedQuantityFormat11>,
    #[yaserde(rename = "ElgblBal")]
    #[cfg_attr(feature = "serde", serde(rename = "ElgblBal"))]
    pub elgbl_bal: Option<SignedQuantityFormat10>,
    #[yaserde(rename = "NotElgblBal")]
    #[cfg_attr(feature = "serde", serde(rename = "NotElgblBal"))]
    pub not_elgbl_bal: Option<SignedQuantityFormat10>,
}

impl Validate for BalanceFormat11Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct BalanceFormat12Choice {
    #[yaserde(rename = "Bal")]
    #[cfg_attr(feature = "serde", serde(rename = "Bal"))]
    pub bal: Option<SignedQuantityFormat11>,
    #[yaserde(rename = "ElgblBal")]
    #[cfg_attr(feature = "serde", serde(rename = "ElgblBal"))]
    pub elgbl_bal: Option<SignedQuantityFormat10>,
    #[yaserde(rename = "NotElgblBal")]
    #[cfg_attr(feature = "serde", serde(rename = "NotElgblBal"))]
    pub not_elgbl_bal: Option<SignedQuantityFormat10>,
    #[yaserde(rename = "FullPrdUnits")]
    #[cfg_attr(feature = "serde", serde(rename = "FullPrdUnits"))]
    pub full_prd_units: Option<SignedQuantityFormat10>,
    #[yaserde(rename = "PartWayPrdUnits")]
    #[cfg_attr(feature = "serde", serde(rename = "PartWayPrdUnits"))]
    pub part_way_prd_units: Option<SignedQuantityFormat10>,
}

impl Validate for BalanceFormat12Choice {}




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

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

impl Validate for BeneficiaryCertificationType13Choice {}




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

pub enum BeneficiaryCertificationType6Code {
    #[yaserde(rename = "ACCI")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCI"))]
    Acci,
    #[yaserde(rename = "DOMI")]
    #[cfg_attr(feature = "serde", serde(rename = "DOMI"))]
    Domi,
    #[yaserde(rename = "NDOM")]
    #[cfg_attr(feature = "serde", serde(rename = "NDOM"))]
    Ndom,
    #[yaserde(rename = "FULL")]
    #[cfg_attr(feature = "serde", serde(rename = "FULL"))]
    Full,
    #[yaserde(rename = "NCOM")]
    #[cfg_attr(feature = "serde", serde(rename = "NCOM"))]
    Ncom,
    #[yaserde(rename = "QIBB")]
    #[cfg_attr(feature = "serde", serde(rename = "QIBB"))]
    Qibb,
    #[yaserde(rename = "TRBD")]
    #[cfg_attr(feature = "serde", serde(rename = "TRBD"))]
    Trbd,
    #[yaserde(rename = "PABD")]
    #[cfg_attr(feature = "serde", serde(rename = "PABD"))]
    Pabd,
    #[yaserde(rename = "FRAC")]
    #[cfg_attr(feature = "serde", serde(rename = "FRAC"))]
    Frac,
    #[yaserde(rename = "PAPW")]
    #[cfg_attr(feature = "serde", serde(rename = "PAPW"))]
    Papw,
    #[yaserde(rename = "DIOR")]
    #[cfg_attr(feature = "serde", serde(rename = "DIOR"))]
    Dior,
    __Unknown__(String),
}

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

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

impl Validate for BidRangeType1Choice {}




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

pub enum BidRangeType1Code {
    #[yaserde(rename = "DIVI")]
    #[cfg_attr(feature = "serde", serde(rename = "DIVI"))]
    Divi,
    #[yaserde(rename = "INCR")]
    #[cfg_attr(feature = "serde", serde(rename = "INCR"))]
    Incr,
    #[yaserde(rename = "MULT")]
    #[cfg_attr(feature = "serde", serde(rename = "MULT"))]
    Mult,
    __Unknown__(String),
}

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

impl Validate for BidRangeType1Code {}



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

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

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

impl Validate for BlockChainAddressWallet3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct BorrowerLendingDeadline5 {
    #[yaserde(rename = "StockLndgDdln")]
    #[cfg_attr(feature = "serde", serde(rename = "StockLndgDdln"))]
    pub stock_lndg_ddln: DateFormat43Choice,

    #[yaserde(rename = "Brrwr")]
    #[cfg_attr(feature = "serde", serde(rename = "Brrwr"))]
    pub brrwr: PartyIdentification127Choice,
}

impl Validate for BorrowerLendingDeadline5 {}


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

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

impl Validate for CapitalGainFormat3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct CashAccountIdentification9Choice {
    #[yaserde(rename = "IBAN")]
    #[cfg_attr(feature = "serde", serde(rename = "IBAN"))]
    pub iban: Option<Iban2007Identifier>,
    #[yaserde(rename = "BlckChainCshWllt")]
    #[cfg_attr(feature = "serde", serde(rename = "BlckChainCshWllt"))]
    pub blck_chain_csh_wllt: Option<BlockChainAddressWallet3>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max34Text>,
}

impl Validate for CashAccountIdentification9Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct CashOption116 {
    #[yaserde(rename = "CdtDbtInd")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtDbtInd"))]
    pub cdt_dbt_ind: CreditDebitCode,

    #[yaserde(rename = "CtrctlPmtInd")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrctlPmtInd"))]
    pub ctrctl_pmt_ind: Payment2Code,

    #[yaserde(rename = "NonElgblPrcdsInd")]
    #[cfg_attr(feature = "serde", serde(rename = "NonElgblPrcdsInd"))]
    pub non_elgbl_prcds_ind: NonEligibleProceedsIndicator5Choice,

    #[yaserde(rename = "IssrOfferrTaxbltyInd")]
    #[cfg_attr(feature = "serde", serde(rename = "IssrOfferrTaxbltyInd"))]
    pub issr_offerr_taxblty_ind: IssuerOfferorTaxabilityIndicator2Choice,

    #[yaserde(rename = "IncmTp")]
    #[cfg_attr(feature = "serde", serde(rename = "IncmTp"))]
    pub incm_tp: GenericIdentification30,

    #[yaserde(rename = "OthrIncmTp")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrIncmTp"))]
    pub othr_incm_tp: Vec<GenericIdentification30>,

    #[yaserde(rename = "XmptnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "XmptnTp"))]
    pub xmptn_tp: Vec<GenericIdentification30>,

    #[yaserde(rename = "PricClctnMtd")]
    #[cfg_attr(feature = "serde", serde(rename = "PricClctnMtd"))]
    pub pric_clctn_mtd: PriceCalculationMethod2Choice,

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

    #[yaserde(rename = "CshAcctId")]
    #[cfg_attr(feature = "serde", serde(rename = "CshAcctId"))]
    pub csh_acct_id: CashAccountIdentification9Choice,

    #[yaserde(rename = "AmtDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtDtls"))]
    pub amt_dtls: CorporateActionAmounts77,

    #[yaserde(rename = "DtDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "DtDtls"))]
    pub dt_dtls: CorporateActionDate84,

    #[yaserde(rename = "FXDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "FXDtls"))]
    pub fx_dtls: ForeignExchangeTerms39,

    #[yaserde(rename = "RateAndAmtDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "RateAndAmtDtls"))]
    pub rate_and_amt_dtls: Rate48,

    #[yaserde(rename = "PricDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "PricDtls"))]
    pub pric_dtls: PriceDetails38,
}

impl Validate for CashOption116 {}


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

pub enum CertificationFormatType1Code {
    #[yaserde(rename = "ELEC")]
    #[cfg_attr(feature = "serde", serde(rename = "ELEC"))]
    Elec,
    #[yaserde(rename = "PHYS")]
    #[cfg_attr(feature = "serde", serde(rename = "PHYS"))]
    Phys,
    __Unknown__(String),
}

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

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

impl Validate for CertificationTypeFormat3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct ClassificationType32Choice {
    #[yaserde(rename = "ClssfctnFinInstrm")]
    #[cfg_attr(feature = "serde", serde(rename = "ClssfctnFinInstrm"))]
    pub clssfctn_fin_instrm: Option<Cfioct2015Identifier>,
    #[yaserde(rename = "AltrnClssfctn")]
    #[cfg_attr(feature = "serde", serde(rename = "AltrnClssfctn"))]
    pub altrn_clssfctn: Option<GenericIdentification36>,
}

impl Validate for ClassificationType32Choice {}




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

pub enum ConsentType1Code {
    #[yaserde(rename = "CTRM")]
    #[cfg_attr(feature = "serde", serde(rename = "CTRM"))]
    Ctrm,
    #[yaserde(rename = "DUPY")]
    #[cfg_attr(feature = "serde", serde(rename = "DUPY"))]
    Dupy,
    __Unknown__(String),
}

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

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

impl Validate for ConsentTypeFormat4Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct CorporateAction94 {
    #[yaserde(rename = "DtDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "DtDtls"))]
    pub dt_dtls: CorporateActionDate83,

    #[yaserde(rename = "PrdDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "PrdDtls"))]
    pub prd_dtls: CorporateActionPeriod17,

    #[yaserde(rename = "RateAndAmtDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "RateAndAmtDtls"))]
    pub rate_and_amt_dtls: CorporateActionRate122,

    #[yaserde(rename = "PricDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "PricDtls"))]
    pub pric_dtls: CorporateActionPrice85,

    #[yaserde(rename = "SctiesQty")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesQty"))]
    pub scties_qty: CorporateActionQuantity15,

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

    #[yaserde(rename = "CpnNb")]
    #[cfg_attr(feature = "serde", serde(rename = "CpnNb"))]
    pub cpn_nb: Vec<IdentificationFormat3Choice>,

    #[yaserde(rename = "AccptncPrtyLvl")]
    #[cfg_attr(feature = "serde", serde(rename = "AccptncPrtyLvl"))]
    pub accptnc_prty_lvl: Exact3UpperCaseAlphaNumericText,

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

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

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

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

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

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

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

    #[yaserde(rename = "DvddTp")]
    #[cfg_attr(feature = "serde", serde(rename = "DvddTp"))]
    pub dvdd_tp: DividendTypeFormat9Choice,

    #[yaserde(rename = "EvtSeqTp")]
    #[cfg_attr(feature = "serde", serde(rename = "EvtSeqTp"))]
    pub evt_seq_tp: EventSequenceTypeFormat1Choice,

    #[yaserde(rename = "OcrncTp")]
    #[cfg_attr(feature = "serde", serde(rename = "OcrncTp"))]
    pub ocrnc_tp: DistributionTypeFormat7Choice,

    #[yaserde(rename = "OfferTp")]
    #[cfg_attr(feature = "serde", serde(rename = "OfferTp"))]
    pub offer_tp: Vec<OfferTypeFormat18Choice>,

    #[yaserde(rename = "RnncblEntitlmntStsTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RnncblEntitlmntStsTp"))]
    pub rnncbl_entitlmnt_sts_tp: RenounceableEntitlementStatusTypeFormat3Choice,

    #[yaserde(rename = "EvtStag")]
    #[cfg_attr(feature = "serde", serde(rename = "EvtStag"))]
    pub evt_stag: Vec<CorporateActionEventStageFormat13Choice>,

    #[yaserde(rename = "AddtlBizPrcInd")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlBizPrcInd"))]
    pub addtl_biz_prc_ind: Vec<AdditionalBusinessProcessFormat17Choice>,

    #[yaserde(rename = "ChngTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ChngTp"))]
    pub chng_tp: Vec<CorporateActionChangeTypeFormat5Choice>,

    #[yaserde(rename = "FllwngEvtTpInd")]
    #[cfg_attr(feature = "serde", serde(rename = "FllwngEvtTpInd"))]
    pub fllwng_evt_tp_ind: IntermediateSecuritiesDistributionTypeFormat19Choice,

    #[yaserde(rename = "CptlGnInOutInd")]
    #[cfg_attr(feature = "serde", serde(rename = "CptlGnInOutInd"))]
    pub cptl_gn_in_out_ind: CapitalGainFormat3Choice,

    #[yaserde(rename = "TaxblIncmPerShrClctd")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxblIncmPerShrClctd"))]
    pub taxbl_incm_per_shr_clctd: TaxableIncomePerShareCalculatedFormat3Choice,

    #[yaserde(rename = "ElctnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ElctnTp"))]
    pub elctn_tp: ElectionTypeFormat3Choice,

    #[yaserde(rename = "LtryTp")]
    #[cfg_attr(feature = "serde", serde(rename = "LtryTp"))]
    pub ltry_tp: LotteryTypeFormat4Choice,

    #[yaserde(rename = "CertfctnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CertfctnTp"))]
    pub certfctn_tp: CertificationTypeFormat3Choice,

    #[yaserde(rename = "CnsntTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CnsntTp"))]
    pub cnsnt_tp: ConsentTypeFormat4Choice,

    #[yaserde(rename = "InfTp")]
    #[cfg_attr(feature = "serde", serde(rename = "InfTp"))]
    pub inf_tp: InformationTypeFormat4Choice,

    #[yaserde(rename = "TaxOnNonDstrbtdPrcdsInd")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxOnNonDstrbtdPrcdsInd"))]
    pub tax_on_non_dstrbtd_prcds_ind: Vec<GenericIdentification30>,

    #[yaserde(rename = "DtchAuctnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "DtchAuctnTp"))]
    pub dtch_auctn_tp: DutchAuctionTypeFormat1Choice,

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

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

    #[yaserde(rename = "AddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
    pub addtl_inf: CorporateActionNarrative58,
}

impl Validate for CorporateAction94 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct CorporateActionAmounts60 {
    #[yaserde(rename = "WhldgTaxAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "WhldgTaxAmt"))]
    pub whldg_tax_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "ScndLvlTaxAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "ScndLvlTaxAmt"))]
    pub scnd_lvl_tax_amt: ActiveCurrencyAndAmount,
}

impl Validate for CorporateActionAmounts60 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct CorporateActionAmounts77 {
    #[yaserde(rename = "GrssAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "GrssAmt"))]
    pub grss_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "NetAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "NetAmt"))]
    pub net_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "SlctnFees")]
    #[cfg_attr(feature = "serde", serde(rename = "SlctnFees"))]
    pub slctn_fees: ActiveCurrencyAndAmount,

    #[yaserde(rename = "CshInLieuOfShr")]
    #[cfg_attr(feature = "serde", serde(rename = "CshInLieuOfShr"))]
    pub csh_in_lieu_of_shr: ActiveCurrencyAndAmount,

    #[yaserde(rename = "CptlGn")]
    #[cfg_attr(feature = "serde", serde(rename = "CptlGn"))]
    pub cptl_gn: ActiveCurrencyAndAmount,

    #[yaserde(rename = "IntrstAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstAmt"))]
    pub intrst_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "IndmntyAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "IndmntyAmt"))]
    pub indmnty_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "ManfctrdDvddPmtAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "ManfctrdDvddPmtAmt"))]
    pub manfctrd_dvdd_pmt_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "RinvstmtAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "RinvstmtAmt"))]
    pub rinvstmt_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "FullyFrnkdAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "FullyFrnkdAmt"))]
    pub fully_frnkd_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "UfrnkdAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "UfrnkdAmt"))]
    pub ufrnkd_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "SndryOrOthrAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "SndryOrOthrAmt"))]
    pub sndry_or_othr_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "TaxFreeAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxFreeAmt"))]
    pub tax_free_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "TaxDfrrdAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxDfrrdAmt"))]
    pub tax_dfrrd_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "ValAddedTaxAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "ValAddedTaxAmt"))]
    pub val_added_tax_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "StmpDtyAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "StmpDtyAmt"))]
    pub stmp_dty_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "TaxRclmAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxRclmAmt"))]
    pub tax_rclm_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "TaxCdtAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxCdtAmt"))]
    pub tax_cdt_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "AddtlTaxAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlTaxAmt"))]
    pub addtl_tax_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "WhldgTaxAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "WhldgTaxAmt"))]
    pub whldg_tax_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "ScndLvlTaxAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "ScndLvlTaxAmt"))]
    pub scnd_lvl_tax_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "FsclStmpAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "FsclStmpAmt"))]
    pub fscl_stmp_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "ExctgBrkrAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "ExctgBrkrAmt"))]
    pub exctg_brkr_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "PngAgtComssnAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "PngAgtComssnAmt"))]
    pub png_agt_comssn_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "LclBrkrComssnAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "LclBrkrComssnAmt"))]
    pub lcl_brkr_comssn_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "RgltryFeesAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "RgltryFeesAmt"))]
    pub rgltry_fees_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "ShppgFeesAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "ShppgFeesAmt"))]
    pub shppg_fees_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "ChrgsAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "ChrgsAmt"))]
    pub chrgs_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "EntitldAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "EntitldAmt"))]
    pub entitld_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "OrgnlAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlAmt"))]
    pub orgnl_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "PrncplOrCrps")]
    #[cfg_attr(feature = "serde", serde(rename = "PrncplOrCrps"))]
    pub prncpl_or_crps: ActiveCurrencyAndAmount,

    #[yaserde(rename = "RedPrmAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "RedPrmAmt"))]
    pub red_prm_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "IncmPrtn")]
    #[cfg_attr(feature = "serde", serde(rename = "IncmPrtn"))]
    pub incm_prtn: ActiveCurrencyAndAmount,

    #[yaserde(rename = "StockXchgTax")]
    #[cfg_attr(feature = "serde", serde(rename = "StockXchgTax"))]
    pub stock_xchg_tax: ActiveCurrencyAndAmount,

    #[yaserde(rename = "EUTaxRtntnAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "EUTaxRtntnAmt"))]
    pub eu_tax_rtntn_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "AcrdIntrstAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "AcrdIntrstAmt"))]
    pub acrd_intrst_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "EqulstnAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "EqulstnAmt"))]
    pub equlstn_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "FATCATaxAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "FATCATaxAmt"))]
    pub fatca_tax_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "NRATaxAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "NRATaxAmt"))]
    pub nra_tax_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "BckUpWhldgTaxAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "BckUpWhldgTaxAmt"))]
    pub bck_up_whldg_tax_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "TaxOnIncmAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxOnIncmAmt"))]
    pub tax_on_incm_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "TxTax")]
    #[cfg_attr(feature = "serde", serde(rename = "TxTax"))]
    pub tx_tax: ActiveCurrencyAndAmount,

    #[yaserde(rename = "DmdAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "DmdAmt"))]
    pub dmd_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "FrgnIncmAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "FrgnIncmAmt"))]
    pub frgn_incm_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "DmdDvddAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "DmdDvddAmt"))]
    pub dmd_dvdd_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "DmdFndAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "DmdFndAmt"))]
    pub dmd_fnd_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "DmdIntrstAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "DmdIntrstAmt"))]
    pub dmd_intrst_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "DmdRyltsAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "DmdRyltsAmt"))]
    pub dmd_rylts_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "BuyUpAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "BuyUpAmt"))]
    pub buy_up_amt: ActiveCurrencyAndAmount,
}

impl Validate for CorporateActionAmounts77 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct CorporateActionBalanceDetails43 {
    #[yaserde(rename = "TtlElgblBal")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlElgblBal"))]
    pub ttl_elgbl_bal: TotalEligibleBalanceFormat10,

    #[yaserde(rename = "BlckdBal")]
    #[cfg_attr(feature = "serde", serde(rename = "BlckdBal"))]
    pub blckd_bal: BalanceFormat11Choice,

    #[yaserde(rename = "BrrwdBal")]
    #[cfg_attr(feature = "serde", serde(rename = "BrrwdBal"))]
    pub brrwd_bal: BalanceFormat11Choice,

    #[yaserde(rename = "CollInBal")]
    #[cfg_attr(feature = "serde", serde(rename = "CollInBal"))]
    pub coll_in_bal: BalanceFormat11Choice,

    #[yaserde(rename = "CollOutBal")]
    #[cfg_attr(feature = "serde", serde(rename = "CollOutBal"))]
    pub coll_out_bal: BalanceFormat11Choice,

    #[yaserde(rename = "OnLnBal")]
    #[cfg_attr(feature = "serde", serde(rename = "OnLnBal"))]
    pub on_ln_bal: BalanceFormat11Choice,

    #[yaserde(rename = "PdgDlvryBal")]
    #[cfg_attr(feature = "serde", serde(rename = "PdgDlvryBal"))]
    pub pdg_dlvry_bal: Vec<BalanceFormat12Choice>,

    #[yaserde(rename = "PdgRctBal")]
    #[cfg_attr(feature = "serde", serde(rename = "PdgRctBal"))]
    pub pdg_rct_bal: Vec<BalanceFormat12Choice>,

    #[yaserde(rename = "OutForRegnBal")]
    #[cfg_attr(feature = "serde", serde(rename = "OutForRegnBal"))]
    pub out_for_regn_bal: BalanceFormat11Choice,

    #[yaserde(rename = "SttlmPosBal")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmPosBal"))]
    pub sttlm_pos_bal: Vec<BalanceFormat12Choice>,

    #[yaserde(rename = "StrtPosBal")]
    #[cfg_attr(feature = "serde", serde(rename = "StrtPosBal"))]
    pub strt_pos_bal: BalanceFormat11Choice,

    #[yaserde(rename = "TradDtPosBal")]
    #[cfg_attr(feature = "serde", serde(rename = "TradDtPosBal"))]
    pub trad_dt_pos_bal: BalanceFormat11Choice,

    #[yaserde(rename = "InTrnsShipmntBal")]
    #[cfg_attr(feature = "serde", serde(rename = "InTrnsShipmntBal"))]
    pub in_trns_shipmnt_bal: BalanceFormat11Choice,

    #[yaserde(rename = "RegdBal")]
    #[cfg_attr(feature = "serde", serde(rename = "RegdBal"))]
    pub regd_bal: BalanceFormat11Choice,

    #[yaserde(rename = "OblgtdBal")]
    #[cfg_attr(feature = "serde", serde(rename = "OblgtdBal"))]
    pub oblgtd_bal: BalanceFormat11Choice,

    #[yaserde(rename = "UinstdBal")]
    #[cfg_attr(feature = "serde", serde(rename = "UinstdBal"))]
    pub uinstd_bal: BalanceFormat11Choice,

    #[yaserde(rename = "InstdBal")]
    #[cfg_attr(feature = "serde", serde(rename = "InstdBal"))]
    pub instd_bal: BalanceFormat11Choice,

    #[yaserde(rename = "AfctdBal")]
    #[cfg_attr(feature = "serde", serde(rename = "AfctdBal"))]
    pub afctd_bal: BalanceFormat11Choice,

    #[yaserde(rename = "UafctdBal")]
    #[cfg_attr(feature = "serde", serde(rename = "UafctdBal"))]
    pub uafctd_bal: BalanceFormat11Choice,
}

impl Validate for CorporateActionBalanceDetails43 {}


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

pub enum CorporateActionChangeType1Code {
    #[yaserde(rename = "BERE")]
    #[cfg_attr(feature = "serde", serde(rename = "BERE"))]
    Bere,
    #[yaserde(rename = "CERT")]
    #[cfg_attr(feature = "serde", serde(rename = "CERT"))]
    Cert,
    #[yaserde(rename = "DEPH")]
    #[cfg_attr(feature = "serde", serde(rename = "DEPH"))]
    Deph,
    #[yaserde(rename = "GPPH")]
    #[cfg_attr(feature = "serde", serde(rename = "GPPH"))]
    Gpph,
    #[yaserde(rename = "GTGP")]
    #[cfg_attr(feature = "serde", serde(rename = "GTGP"))]
    Gtgp,
    #[yaserde(rename = "GTPH")]
    #[cfg_attr(feature = "serde", serde(rename = "GTPH"))]
    Gtph,
    #[yaserde(rename = "NAME")]
    #[cfg_attr(feature = "serde", serde(rename = "NAME"))]
    Name,
    #[yaserde(rename = "PHDE")]
    #[cfg_attr(feature = "serde", serde(rename = "PHDE"))]
    Phde,
    #[yaserde(rename = "REBE")]
    #[cfg_attr(feature = "serde", serde(rename = "REBE"))]
    Rebe,
    #[yaserde(rename = "TERM")]
    #[cfg_attr(feature = "serde", serde(rename = "TERM"))]
    Term,
    #[yaserde(rename = "DECI")]
    #[cfg_attr(feature = "serde", serde(rename = "DECI"))]
    Deci,
    __Unknown__(String),
}

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

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

impl Validate for CorporateActionChangeTypeFormat5Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct CorporateActionDate110 {
    #[yaserde(rename = "EarlyRspnDdln")]
    #[cfg_attr(feature = "serde", serde(rename = "EarlyRspnDdln"))]
    pub early_rspn_ddln: DateFormat43Choice,

    #[yaserde(rename = "CoverXprtnDdln")]
    #[cfg_attr(feature = "serde", serde(rename = "CoverXprtnDdln"))]
    pub cover_xprtn_ddln: DateFormat43Choice,

    #[yaserde(rename = "PrtctDdln")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtctDdln"))]
    pub prtct_ddln: DateFormat43Choice,

    #[yaserde(rename = "MktDdln")]
    #[cfg_attr(feature = "serde", serde(rename = "MktDdln"))]
    pub mkt_ddln: DateFormat43Choice,

    #[yaserde(rename = "RspnDdln")]
    #[cfg_attr(feature = "serde", serde(rename = "RspnDdln"))]
    pub rspn_ddln: DateFormat44Choice,

    #[yaserde(rename = "XpryDt")]
    #[cfg_attr(feature = "serde", serde(rename = "XpryDt"))]
    pub xpry_dt: DateFormat43Choice,

    #[yaserde(rename = "SbcptCostDbtDt")]
    #[cfg_attr(feature = "serde", serde(rename = "SbcptCostDbtDt"))]
    pub sbcpt_cost_dbt_dt: DateFormat43Choice,

    #[yaserde(rename = "DpstryCoverXprtnDt")]
    #[cfg_attr(feature = "serde", serde(rename = "DpstryCoverXprtnDt"))]
    pub dpstry_cover_xprtn_dt: DateFormat43Choice,

    #[yaserde(rename = "StockLndgDdln")]
    #[cfg_attr(feature = "serde", serde(rename = "StockLndgDdln"))]
    pub stock_lndg_ddln: DateFormat43Choice,

    #[yaserde(rename = "BrrwrStockLndgDdln")]
    #[cfg_attr(feature = "serde", serde(rename = "BrrwrStockLndgDdln"))]
    pub brrwr_stock_lndg_ddln: Vec<BorrowerLendingDeadline5>,

    #[yaserde(rename = "EndOfSctiesBlckgPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "EndOfSctiesBlckgPrd"))]
    pub end_of_scties_blckg_prd: DateFormat59Choice,

    #[yaserde(rename = "DcmnttnDdln")]
    #[cfg_attr(feature = "serde", serde(rename = "DcmnttnDdln"))]
    pub dcmnttn_ddln: DateFormat46Choice,
}

impl Validate for CorporateActionDate110 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct CorporateActionDate83 {
    #[yaserde(rename = "AnncmntDt")]
    #[cfg_attr(feature = "serde", serde(rename = "AnncmntDt"))]
    pub anncmnt_dt: DateFormat43Choice,

    #[yaserde(rename = "CertfctnDdln")]
    #[cfg_attr(feature = "serde", serde(rename = "CertfctnDdln"))]
    pub certfctn_ddln: DateFormat43Choice,

    #[yaserde(rename = "CrtApprvlDt")]
    #[cfg_attr(feature = "serde", serde(rename = "CrtApprvlDt"))]
    pub crt_apprvl_dt: DateFormat30Choice,

    #[yaserde(rename = "EarlyClsgDt")]
    #[cfg_attr(feature = "serde", serde(rename = "EarlyClsgDt"))]
    pub early_clsg_dt: DateFormat43Choice,

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

    #[yaserde(rename = "EqulstnDt")]
    #[cfg_attr(feature = "serde", serde(rename = "EqulstnDt"))]
    pub equlstn_dt: DateFormat30Choice,

    #[yaserde(rename = "FrthrDtldAnncmntDt")]
    #[cfg_attr(feature = "serde", serde(rename = "FrthrDtldAnncmntDt"))]
    pub frthr_dtld_anncmnt_dt: DateFormat43Choice,

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

    #[yaserde(rename = "LtryDt")]
    #[cfg_attr(feature = "serde", serde(rename = "LtryDt"))]
    pub ltry_dt: DateFormat30Choice,

    #[yaserde(rename = "NewMtrtyDt")]
    #[cfg_attr(feature = "serde", serde(rename = "NewMtrtyDt"))]
    pub new_mtrty_dt: DateFormat30Choice,

    #[yaserde(rename = "MtgDt")]
    #[cfg_attr(feature = "serde", serde(rename = "MtgDt"))]
    pub mtg_dt: DateFormat43Choice,

    #[yaserde(rename = "MrgnFxgDt")]
    #[cfg_attr(feature = "serde", serde(rename = "MrgnFxgDt"))]
    pub mrgn_fxg_dt: DateFormat30Choice,

    #[yaserde(rename = "PrratnDt")]
    #[cfg_attr(feature = "serde", serde(rename = "PrratnDt"))]
    pub prratn_dt: DateFormat30Choice,

    #[yaserde(rename = "RcrdDt")]
    #[cfg_attr(feature = "serde", serde(rename = "RcrdDt"))]
    pub rcrd_dt: DateFormat30Choice,

    #[yaserde(rename = "RegnDdln")]
    #[cfg_attr(feature = "serde", serde(rename = "RegnDdln"))]
    pub regn_ddln: DateFormat43Choice,

    #[yaserde(rename = "RsltsPblctnDt")]
    #[cfg_attr(feature = "serde", serde(rename = "RsltsPblctnDt"))]
    pub rslts_pblctn_dt: DateFormat43Choice,

    #[yaserde(rename = "DdlnToSplt")]
    #[cfg_attr(feature = "serde", serde(rename = "DdlnToSplt"))]
    pub ddln_to_splt: DateFormat43Choice,

    #[yaserde(rename = "DdlnForTaxBrkdwnInstr")]
    #[cfg_attr(feature = "serde", serde(rename = "DdlnForTaxBrkdwnInstr"))]
    pub ddln_for_tax_brkdwn_instr: DateFormat43Choice,

    #[yaserde(rename = "TradgSspdDt")]
    #[cfg_attr(feature = "serde", serde(rename = "TradgSspdDt"))]
    pub tradg_sspd_dt: DateFormat43Choice,

    #[yaserde(rename = "UcondlDt")]
    #[cfg_attr(feature = "serde", serde(rename = "UcondlDt"))]
    pub ucondl_dt: DateFormat30Choice,

    #[yaserde(rename = "WhlyUcondlDt")]
    #[cfg_attr(feature = "serde", serde(rename = "WhlyUcondlDt"))]
    pub whly_ucondl_dt: DateFormat30Choice,

    #[yaserde(rename = "ExDvddDt")]
    #[cfg_attr(feature = "serde", serde(rename = "ExDvddDt"))]
    pub ex_dvdd_dt: DateFormat30Choice,

    #[yaserde(rename = "OffclAnncmntPblctnDt")]
    #[cfg_attr(feature = "serde", serde(rename = "OffclAnncmntPblctnDt"))]
    pub offcl_anncmnt_pblctn_dt: DateFormat43Choice,

    #[yaserde(rename = "SpclExDt")]
    #[cfg_attr(feature = "serde", serde(rename = "SpclExDt"))]
    pub spcl_ex_dt: DateFormat30Choice,

    #[yaserde(rename = "GrntedPrtcptnDt")]
    #[cfg_attr(feature = "serde", serde(rename = "GrntedPrtcptnDt"))]
    pub grnted_prtcptn_dt: DateFormat30Choice,

    #[yaserde(rename = "ElctnToCtrPtyMktDdln")]
    #[cfg_attr(feature = "serde", serde(rename = "ElctnToCtrPtyMktDdln"))]
    pub elctn_to_ctr_pty_mkt_ddln: DateFormat43Choice,

    #[yaserde(rename = "ElctnToCtrPtyRspnDdln")]
    #[cfg_attr(feature = "serde", serde(rename = "ElctnToCtrPtyRspnDdln"))]
    pub elctn_to_ctr_pty_rspn_ddln: DateFormat43Choice,

    #[yaserde(rename = "LpsdDt")]
    #[cfg_attr(feature = "serde", serde(rename = "LpsdDt"))]
    pub lpsd_dt: DateFormat30Choice,

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

    #[yaserde(rename = "ThrdPtyDdln")]
    #[cfg_attr(feature = "serde", serde(rename = "ThrdPtyDdln"))]
    pub thrd_pty_ddln: DateFormat43Choice,

    #[yaserde(rename = "EarlyThrdPtyDdln")]
    #[cfg_attr(feature = "serde", serde(rename = "EarlyThrdPtyDdln"))]
    pub early_thrd_pty_ddln: DateFormat43Choice,

    #[yaserde(rename = "MktClmTrckgEndDt")]
    #[cfg_attr(feature = "serde", serde(rename = "MktClmTrckgEndDt"))]
    pub mkt_clm_trckg_end_dt: DateFormat30Choice,

    #[yaserde(rename = "LeadPlntffDdln")]
    #[cfg_attr(feature = "serde", serde(rename = "LeadPlntffDdln"))]
    pub lead_plntff_ddln: DateFormat43Choice,

    #[yaserde(rename = "FilgDt")]
    #[cfg_attr(feature = "serde", serde(rename = "FilgDt"))]
    pub filg_dt: DateFormat30Choice,

    #[yaserde(rename = "HrgDt")]
    #[cfg_attr(feature = "serde", serde(rename = "HrgDt"))]
    pub hrg_dt: DateFormat30Choice,
}

impl Validate for CorporateActionDate83 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct CorporateActionDate84 {
    #[yaserde(rename = "PmtDt")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtDt"))]
    pub pmt_dt: DateFormat30Choice,

    #[yaserde(rename = "ValDt")]
    #[cfg_attr(feature = "serde", serde(rename = "ValDt"))]
    pub val_dt: DateFormat57Choice,

    #[yaserde(rename = "FXRateFxgDt")]
    #[cfg_attr(feature = "serde", serde(rename = "FXRateFxgDt"))]
    pub fx_rate_fxg_dt: DateFormat43Choice,

    #[yaserde(rename = "EarlstPmtDt")]
    #[cfg_attr(feature = "serde", serde(rename = "EarlstPmtDt"))]
    pub earlst_pmt_dt: DateFormat30Choice,
}

impl Validate for CorporateActionDate84 {}


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

pub enum CorporateActionEventProcessingType1Code {
    #[yaserde(rename = "GENL")]
    #[cfg_attr(feature = "serde", serde(rename = "GENL"))]
    Genl,
    #[yaserde(rename = "DISN")]
    #[cfg_attr(feature = "serde", serde(rename = "DISN"))]
    Disn,
    #[yaserde(rename = "REOR")]
    #[cfg_attr(feature = "serde", serde(rename = "REOR"))]
    Reor,
    __Unknown__(String),
}

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

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

impl Validate for CorporateActionEventProcessingType2Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct CorporateActionEventReference3 {
    #[yaserde(rename = "EvtId")]
    #[cfg_attr(feature = "serde", serde(rename = "EvtId"))]
    pub evt_id: CorporateActionEventReference3Choice,

    #[yaserde(rename = "LkgTp")]
    #[cfg_attr(feature = "serde", serde(rename = "LkgTp"))]
    pub lkg_tp: ProcessingPosition7Choice,
}

impl Validate for CorporateActionEventReference3 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct CorporateActionEventReference3Choice {
    #[yaserde(rename = "LkdOffclCorpActnEvtId")]
    #[cfg_attr(feature = "serde", serde(rename = "LkdOffclCorpActnEvtId"))]
    pub lkd_offcl_corp_actn_evt_id: Option<Max35Text>,
    #[yaserde(rename = "LkdCorpActnId")]
    #[cfg_attr(feature = "serde", serde(rename = "LkdCorpActnId"))]
    pub lkd_corp_actn_id: Option<Max35Text>,
}

impl Validate for CorporateActionEventReference3Choice {}




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

pub enum CorporateActionEventStage3Code {
    #[yaserde(rename = "APPD")]
    #[cfg_attr(feature = "serde", serde(rename = "APPD"))]
    Appd,
    #[yaserde(rename = "CLDE")]
    #[cfg_attr(feature = "serde", serde(rename = "CLDE"))]
    Clde,
    #[yaserde(rename = "FULL")]
    #[cfg_attr(feature = "serde", serde(rename = "FULL"))]
    Full,
    #[yaserde(rename = "LAPS")]
    #[cfg_attr(feature = "serde", serde(rename = "LAPS"))]
    Laps,
    #[yaserde(rename = "PART")]
    #[cfg_attr(feature = "serde", serde(rename = "PART"))]
    Part,
    #[yaserde(rename = "PWAL")]
    #[cfg_attr(feature = "serde", serde(rename = "PWAL"))]
    Pwal,
    #[yaserde(rename = "RESC")]
    #[cfg_attr(feature = "serde", serde(rename = "RESC"))]
    Resc,
    #[yaserde(rename = "SUAP")]
    #[cfg_attr(feature = "serde", serde(rename = "SUAP"))]
    Suap,
    #[yaserde(rename = "UNAC")]
    #[cfg_attr(feature = "serde", serde(rename = "UNAC"))]
    Unac,
    #[yaserde(rename = "WHOU")]
    #[cfg_attr(feature = "serde", serde(rename = "WHOU"))]
    Whou,
    __Unknown__(String),
}

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

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

impl Validate for CorporateActionEventStageFormat13Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct CorporateActionEventStatus1 {
    #[yaserde(rename = "EvtCmpltnsSts")]
    #[cfg_attr(feature = "serde", serde(rename = "EvtCmpltnsSts"))]
    pub evt_cmpltns_sts: EventCompletenessStatus1Code,

    #[yaserde(rename = "EvtConfSts")]
    #[cfg_attr(feature = "serde", serde(rename = "EvtConfSts"))]
    pub evt_conf_sts: EventConfirmationStatus1Code,
}

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

impl Validate for CorporateActionEventType107Choice {}




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

pub enum CorporateActionEventType35Code {
    #[yaserde(rename = "ACTV")]
    #[cfg_attr(feature = "serde", serde(rename = "ACTV"))]
    Actv,
    #[yaserde(rename = "ATTI")]
    #[cfg_attr(feature = "serde", serde(rename = "ATTI"))]
    Atti,
    #[yaserde(rename = "BRUP")]
    #[cfg_attr(feature = "serde", serde(rename = "BRUP"))]
    Brup,
    #[yaserde(rename = "DFLT")]
    #[cfg_attr(feature = "serde", serde(rename = "DFLT"))]
    Dflt,
    #[yaserde(rename = "BONU")]
    #[cfg_attr(feature = "serde", serde(rename = "BONU"))]
    Bonu,
    #[yaserde(rename = "EXRI")]
    #[cfg_attr(feature = "serde", serde(rename = "EXRI"))]
    Exri,
    #[yaserde(rename = "CAPD")]
    #[cfg_attr(feature = "serde", serde(rename = "CAPD"))]
    Capd,
    #[yaserde(rename = "CAPG")]
    #[cfg_attr(feature = "serde", serde(rename = "CAPG"))]
    Capg,
    #[yaserde(rename = "CAPI")]
    #[cfg_attr(feature = "serde", serde(rename = "CAPI"))]
    Capi,
    #[yaserde(rename = "DRCA")]
    #[cfg_attr(feature = "serde", serde(rename = "DRCA"))]
    Drca,
    #[yaserde(rename = "DVCA")]
    #[cfg_attr(feature = "serde", serde(rename = "DVCA"))]
    Dvca,
    #[yaserde(rename = "CHAN")]
    #[cfg_attr(feature = "serde", serde(rename = "CHAN"))]
    Chan,
    #[yaserde(rename = "COOP")]
    #[cfg_attr(feature = "serde", serde(rename = "COOP"))]
    Coop,
    #[yaserde(rename = "CLSA")]
    #[cfg_attr(feature = "serde", serde(rename = "CLSA"))]
    Clsa,
    #[yaserde(rename = "CONS")]
    #[cfg_attr(feature = "serde", serde(rename = "CONS"))]
    Cons,
    #[yaserde(rename = "CONV")]
    #[cfg_attr(feature = "serde", serde(rename = "CONV"))]
    Conv,
    #[yaserde(rename = "CREV")]
    #[cfg_attr(feature = "serde", serde(rename = "CREV"))]
    Crev,
    #[yaserde(rename = "DECR")]
    #[cfg_attr(feature = "serde", serde(rename = "DECR"))]
    Decr,
    #[yaserde(rename = "DETI")]
    #[cfg_attr(feature = "serde", serde(rename = "DETI"))]
    Deti,
    #[yaserde(rename = "DSCL")]
    #[cfg_attr(feature = "serde", serde(rename = "DSCL"))]
    Dscl,
    #[yaserde(rename = "DVOP")]
    #[cfg_attr(feature = "serde", serde(rename = "DVOP"))]
    Dvop,
    #[yaserde(rename = "DRIP")]
    #[cfg_attr(feature = "serde", serde(rename = "DRIP"))]
    Drip,
    #[yaserde(rename = "DRAW")]
    #[cfg_attr(feature = "serde", serde(rename = "DRAW"))]
    Draw,
    #[yaserde(rename = "DTCH")]
    #[cfg_attr(feature = "serde", serde(rename = "DTCH"))]
    Dtch,
    #[yaserde(rename = "EXOF")]
    #[cfg_attr(feature = "serde", serde(rename = "EXOF"))]
    Exof,
    #[yaserde(rename = "REDM")]
    #[cfg_attr(feature = "serde", serde(rename = "REDM"))]
    Redm,
    #[yaserde(rename = "MCAL")]
    #[cfg_attr(feature = "serde", serde(rename = "MCAL"))]
    Mcal,
    #[yaserde(rename = "INCR")]
    #[cfg_attr(feature = "serde", serde(rename = "INCR"))]
    Incr,
    #[yaserde(rename = "PPMT")]
    #[cfg_attr(feature = "serde", serde(rename = "PPMT"))]
    Ppmt,
    #[yaserde(rename = "INTR")]
    #[cfg_attr(feature = "serde", serde(rename = "INTR"))]
    Intr,
    #[yaserde(rename = "RHDI")]
    #[cfg_attr(feature = "serde", serde(rename = "RHDI"))]
    Rhdi,
    #[yaserde(rename = "LIQU")]
    #[cfg_attr(feature = "serde", serde(rename = "LIQU"))]
    Liqu,
    #[yaserde(rename = "EXTM")]
    #[cfg_attr(feature = "serde", serde(rename = "EXTM"))]
    Extm,
    #[yaserde(rename = "MRGR")]
    #[cfg_attr(feature = "serde", serde(rename = "MRGR"))]
    Mrgr,
    #[yaserde(rename = "NOOF")]
    #[cfg_attr(feature = "serde", serde(rename = "NOOF"))]
    Noof,
    #[yaserde(rename = "CERT")]
    #[cfg_attr(feature = "serde", serde(rename = "CERT"))]
    Cert,
    #[yaserde(rename = "ODLT")]
    #[cfg_attr(feature = "serde", serde(rename = "ODLT"))]
    Odlt,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "PARI")]
    #[cfg_attr(feature = "serde", serde(rename = "PARI"))]
    Pari,
    #[yaserde(rename = "PCAL")]
    #[cfg_attr(feature = "serde", serde(rename = "PCAL"))]
    Pcal,
    #[yaserde(rename = "PRED")]
    #[cfg_attr(feature = "serde", serde(rename = "PRED"))]
    Pred,
    #[yaserde(rename = "PINK")]
    #[cfg_attr(feature = "serde", serde(rename = "PINK"))]
    Pink,
    #[yaserde(rename = "PLAC")]
    #[cfg_attr(feature = "serde", serde(rename = "PLAC"))]
    Plac,
    #[yaserde(rename = "PDEF")]
    #[cfg_attr(feature = "serde", serde(rename = "PDEF"))]
    Pdef,
    #[yaserde(rename = "PRIO")]
    #[cfg_attr(feature = "serde", serde(rename = "PRIO"))]
    Prio,
    #[yaserde(rename = "BPUT")]
    #[cfg_attr(feature = "serde", serde(rename = "BPUT"))]
    Bput,
    #[yaserde(rename = "REDO")]
    #[cfg_attr(feature = "serde", serde(rename = "REDO"))]
    Redo,
    #[yaserde(rename = "REMK")]
    #[cfg_attr(feature = "serde", serde(rename = "REMK"))]
    Remk,
    #[yaserde(rename = "BIDS")]
    #[cfg_attr(feature = "serde", serde(rename = "BIDS"))]
    Bids,
    #[yaserde(rename = "SPLR")]
    #[cfg_attr(feature = "serde", serde(rename = "SPLR"))]
    Splr,
    #[yaserde(rename = "RHTS")]
    #[cfg_attr(feature = "serde", serde(rename = "RHTS"))]
    Rhts,
    #[yaserde(rename = "DVSC")]
    #[cfg_attr(feature = "serde", serde(rename = "DVSC"))]
    Dvsc,
    #[yaserde(rename = "SHPR")]
    #[cfg_attr(feature = "serde", serde(rename = "SHPR"))]
    Shpr,
    #[yaserde(rename = "SMAL")]
    #[cfg_attr(feature = "serde", serde(rename = "SMAL"))]
    Smal,
    #[yaserde(rename = "SOFF")]
    #[cfg_attr(feature = "serde", serde(rename = "SOFF"))]
    Soff,
    #[yaserde(rename = "DVSE")]
    #[cfg_attr(feature = "serde", serde(rename = "DVSE"))]
    Dvse,
    #[yaserde(rename = "SPLF")]
    #[cfg_attr(feature = "serde", serde(rename = "SPLF"))]
    Splf,
    #[yaserde(rename = "TREC")]
    #[cfg_attr(feature = "serde", serde(rename = "TREC"))]
    Trec,
    #[yaserde(rename = "TEND")]
    #[cfg_attr(feature = "serde", serde(rename = "TEND"))]
    Tend,
    #[yaserde(rename = "DLST")]
    #[cfg_attr(feature = "serde", serde(rename = "DLST"))]
    Dlst,
    #[yaserde(rename = "SUSP")]
    #[cfg_attr(feature = "serde", serde(rename = "SUSP"))]
    Susp,
    #[yaserde(rename = "EXWA")]
    #[cfg_attr(feature = "serde", serde(rename = "EXWA"))]
    Exwa,
    #[yaserde(rename = "WTRC")]
    #[cfg_attr(feature = "serde", serde(rename = "WTRC"))]
    Wtrc,
    #[yaserde(rename = "WRTH")]
    #[cfg_attr(feature = "serde", serde(rename = "WRTH"))]
    Wrth,
    #[yaserde(rename = "ACCU")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCU"))]
    Accu,
    #[yaserde(rename = "INFO")]
    #[cfg_attr(feature = "serde", serde(rename = "INFO"))]
    Info,
    #[yaserde(rename = "TNDP")]
    #[cfg_attr(feature = "serde", serde(rename = "TNDP"))]
    Tndp,
    #[yaserde(rename = "RCLA")]
    #[cfg_attr(feature = "serde", serde(rename = "RCLA"))]
    Rcla,
    __Unknown__(String),
}

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

impl Validate for CorporateActionEventType35Code {}



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

pub enum CorporateActionFrequencyType5Code {
    #[yaserde(rename = "FINL")]
    #[cfg_attr(feature = "serde", serde(rename = "FINL"))]
    Finl,
    #[yaserde(rename = "INTE")]
    #[cfg_attr(feature = "serde", serde(rename = "INTE"))]
    Inte,
    #[yaserde(rename = "REIN")]
    #[cfg_attr(feature = "serde", serde(rename = "REIN"))]
    Rein,
    #[yaserde(rename = "REGR")]
    #[cfg_attr(feature = "serde", serde(rename = "REGR"))]
    Regr,
    #[yaserde(rename = "SPEC")]
    #[cfg_attr(feature = "serde", serde(rename = "SPEC"))]
    Spec,
    #[yaserde(rename = "SPRE")]
    #[cfg_attr(feature = "serde", serde(rename = "SPRE"))]
    Spre,
    __Unknown__(String),
}

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

impl Validate for CorporateActionFrequencyType5Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct CorporateActionGeneralInformation176 {
    #[yaserde(rename = "CorpActnEvtId")]
    #[cfg_attr(feature = "serde", serde(rename = "CorpActnEvtId"))]
    pub corp_actn_evt_id: Max35Text,

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

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

    #[yaserde(rename = "EvtPrcgTp")]
    #[cfg_attr(feature = "serde", serde(rename = "EvtPrcgTp"))]
    pub evt_prcg_tp: CorporateActionEventProcessingType2Choice,

    #[yaserde(rename = "EvtTp")]
    #[cfg_attr(feature = "serde", serde(rename = "EvtTp"))]
    pub evt_tp: CorporateActionEventType107Choice,

    #[yaserde(rename = "MndtryVlntryEvtTp")]
    #[cfg_attr(feature = "serde", serde(rename = "MndtryVlntryEvtTp"))]
    pub mndtry_vlntry_evt_tp: CorporateActionMandatoryVoluntary3Choice,

    #[yaserde(rename = "UndrlygScty")]
    #[cfg_attr(feature = "serde", serde(rename = "UndrlygScty"))]
    pub undrlyg_scty: FinancialInstrumentAttributes128,
}

impl Validate for CorporateActionGeneralInformation176 {}


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

pub enum CorporateActionInformationType1Code {
    #[yaserde(rename = "CONF")]
    #[cfg_attr(feature = "serde", serde(rename = "CONF"))]
    Conf,
    __Unknown__(String),
}

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

impl Validate for CorporateActionInformationType1Code {}



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

pub enum CorporateActionMandatoryVoluntary1Code {
    #[yaserde(rename = "MAND")]
    #[cfg_attr(feature = "serde", serde(rename = "MAND"))]
    Mand,
    #[yaserde(rename = "CHOS")]
    #[cfg_attr(feature = "serde", serde(rename = "CHOS"))]
    Chos,
    #[yaserde(rename = "VOLU")]
    #[cfg_attr(feature = "serde", serde(rename = "VOLU"))]
    Volu,
    __Unknown__(String),
}

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

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

impl Validate for CorporateActionMandatoryVoluntary3Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct CorporateActionNarrative58 {
    #[yaserde(rename = "Offerr")]
    #[cfg_attr(feature = "serde", serde(rename = "Offerr"))]
    pub offerr: Vec<Max350Text>,

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

    #[yaserde(rename = "URLAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "URLAdr"))]
    pub url_adr: Vec<UpdatedURLlnformation6>,

    #[yaserde(rename = "EvtPrcgWebSiteAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "EvtPrcgWebSiteAdr"))]
    pub evt_prcg_web_site_adr: Max2048Text,
}

impl Validate for CorporateActionNarrative58 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct CorporateActionNarrative59 {
    #[yaserde(rename = "AddtlTxt")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlTxt"))]
    pub addtl_txt: Vec<UpdatedAdditionalInformation19>,

    #[yaserde(rename = "NrrtvVrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "NrrtvVrsn"))]
    pub nrrtv_vrsn: Vec<UpdatedAdditionalInformation19>,

    #[yaserde(rename = "InfConds")]
    #[cfg_attr(feature = "serde", serde(rename = "InfConds"))]
    pub inf_conds: Vec<UpdatedAdditionalInformation21>,

    #[yaserde(rename = "InfToCmplyWth")]
    #[cfg_attr(feature = "serde", serde(rename = "InfToCmplyWth"))]
    pub inf_to_cmply_wth: Vec<UpdatedAdditionalInformation21>,

    #[yaserde(rename = "SctyRstrctn")]
    #[cfg_attr(feature = "serde", serde(rename = "SctyRstrctn"))]
    pub scty_rstrctn: Vec<UpdatedAdditionalInformation21>,

    #[yaserde(rename = "TaxtnConds")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxtnConds"))]
    pub taxtn_conds: Vec<UpdatedAdditionalInformation21>,

    #[yaserde(rename = "Dsclmr")]
    #[cfg_attr(feature = "serde", serde(rename = "Dsclmr"))]
    pub dsclmr: Vec<UpdatedAdditionalInformation21>,

    #[yaserde(rename = "CertfctnBrkdwn")]
    #[cfg_attr(feature = "serde", serde(rename = "CertfctnBrkdwn"))]
    pub certfctn_brkdwn: Vec<UpdatedAdditionalInformation21>,
}

impl Validate for CorporateActionNarrative59 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct CorporateActionNarrative60 {
    #[yaserde(rename = "AddtlTxt")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlTxt"))]
    pub addtl_txt: Vec<UpdatedAdditionalInformation20>,

    #[yaserde(rename = "NrrtvVrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "NrrtvVrsn"))]
    pub nrrtv_vrsn: Vec<UpdatedAdditionalInformation20>,

    #[yaserde(rename = "InfConds")]
    #[cfg_attr(feature = "serde", serde(rename = "InfConds"))]
    pub inf_conds: Vec<UpdatedAdditionalInformation20>,

    #[yaserde(rename = "InfToCmplyWth")]
    #[cfg_attr(feature = "serde", serde(rename = "InfToCmplyWth"))]
    pub inf_to_cmply_wth: Vec<UpdatedAdditionalInformation20>,

    #[yaserde(rename = "TaxtnConds")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxtnConds"))]
    pub taxtn_conds: Vec<UpdatedAdditionalInformation20>,

    #[yaserde(rename = "Dsclmr")]
    #[cfg_attr(feature = "serde", serde(rename = "Dsclmr"))]
    pub dsclmr: Vec<UpdatedAdditionalInformation20>,

    #[yaserde(rename = "PtyCtctNrrtv")]
    #[cfg_attr(feature = "serde", serde(rename = "PtyCtctNrrtv"))]
    pub pty_ctct_nrrtv: Vec<UpdatedAdditionalInformation20>,

    #[yaserde(rename = "RegnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "RegnDtls"))]
    pub regn_dtls: Vec<UpdatedAdditionalInformation20>,

    #[yaserde(rename = "BsktOrIndxInf")]
    #[cfg_attr(feature = "serde", serde(rename = "BsktOrIndxInf"))]
    pub bskt_or_indx_inf: Vec<UpdatedAdditionalInformation20>,

    #[yaserde(rename = "CertfctnBrkdwn")]
    #[cfg_attr(feature = "serde", serde(rename = "CertfctnBrkdwn"))]
    pub certfctn_brkdwn: Vec<UpdatedAdditionalInformation20>,

    #[yaserde(rename = "URLAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "URLAdr"))]
    pub url_adr: Vec<UpdatedURLlnformation6>,

    #[yaserde(rename = "PrcgTxtForNxtIntrmy")]
    #[cfg_attr(feature = "serde", serde(rename = "PrcgTxtForNxtIntrmy"))]
    pub prcg_txt_for_nxt_intrmy: Vec<UpdatedAdditionalInformation20>,
}

impl Validate for CorporateActionNarrative60 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct CorporateActionNotification9 {
    #[yaserde(rename = "NtfctnId")]
    #[cfg_attr(feature = "serde", serde(rename = "NtfctnId"))]
    pub ntfctn_id: Max35Text,

    #[yaserde(rename = "NtfctnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "NtfctnTp"))]
    pub ntfctn_tp: CorporateActionNotificationType1Code,

    #[yaserde(rename = "PrcgSts")]
    #[cfg_attr(feature = "serde", serde(rename = "PrcgSts"))]
    pub prcg_sts: CorporateActionProcessingStatus5Choice,
}

impl Validate for CorporateActionNotification9 {}


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

pub enum CorporateActionNotificationType1Code {
    #[yaserde(rename = "NEWM")]
    #[cfg_attr(feature = "serde", serde(rename = "NEWM"))]
    Newm,
    #[yaserde(rename = "REPL")]
    #[cfg_attr(feature = "serde", serde(rename = "REPL"))]
    Repl,
    #[yaserde(rename = "RMDR")]
    #[cfg_attr(feature = "serde", serde(rename = "RMDR"))]
    Rmdr,
    __Unknown__(String),
}

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

impl Validate for CorporateActionNotificationType1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct CorporateActionNotificationV16 {
    #[yaserde(rename = "Pgntn")]
    #[cfg_attr(feature = "serde", serde(rename = "Pgntn"))]
    pub pgntn: Pagination1,

    #[yaserde(rename = "NtfctnGnlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "NtfctnGnlInf"))]
    pub ntfctn_gnl_inf: CorporateActionNotification9,

    #[yaserde(rename = "PrvsNtfctnId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvsNtfctnId"))]
    pub prvs_ntfctn_id: DocumentIdentification31,

    #[yaserde(rename = "InstrId")]
    #[cfg_attr(feature = "serde", serde(rename = "InstrId"))]
    pub instr_id: DocumentIdentification9,

    #[yaserde(rename = "OthrDocId")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrDocId"))]
    pub othr_doc_id: Vec<DocumentIdentification32>,

    #[yaserde(rename = "EvtsLkg")]
    #[cfg_attr(feature = "serde", serde(rename = "EvtsLkg"))]
    pub evts_lkg: Vec<CorporateActionEventReference3>,

    #[yaserde(rename = "CorpActnGnlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "CorpActnGnlInf"))]
    pub corp_actn_gnl_inf: CorporateActionGeneralInformation176,

    #[yaserde(rename = "AcctDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctDtls"))]
    pub acct_dtls: AccountIdentification71Choice,

    #[yaserde(rename = "IntrmdtScty")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrmdtScty"))]
    pub intrmdt_scty: FinancialInstrumentAttributes139,

    #[yaserde(rename = "CorpActnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "CorpActnDtls"))]
    pub corp_actn_dtls: CorporateAction94,

    #[yaserde(rename = "CorpActnOptnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "CorpActnOptnDtls"))]
    pub corp_actn_optn_dtls: Vec<CorporateActionOption251>,

    #[yaserde(rename = "AddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
    pub addtl_inf: CorporateActionNarrative60,

    #[yaserde(rename = "IssrAgt")]
    #[cfg_attr(feature = "serde", serde(rename = "IssrAgt"))]
    pub issr_agt: Vec<PartyIdentification129Choice>,

    #[yaserde(rename = "PngAgt")]
    #[cfg_attr(feature = "serde", serde(rename = "PngAgt"))]
    pub png_agt: Vec<PartyIdentification120Choice>,

    #[yaserde(rename = "SubPngAgt")]
    #[cfg_attr(feature = "serde", serde(rename = "SubPngAgt"))]
    pub sub_png_agt: Vec<PartyIdentification120Choice>,

    #[yaserde(rename = "Regar")]
    #[cfg_attr(feature = "serde", serde(rename = "Regar"))]
    pub regar: PartyIdentification120Choice,

    #[yaserde(rename = "RsellngAgt")]
    #[cfg_attr(feature = "serde", serde(rename = "RsellngAgt"))]
    pub rsellng_agt: Vec<PartyIdentification120Choice>,

    #[yaserde(rename = "PhysSctiesAgt")]
    #[cfg_attr(feature = "serde", serde(rename = "PhysSctiesAgt"))]
    pub phys_scties_agt: PartyIdentification120Choice,

    #[yaserde(rename = "DrpAgt")]
    #[cfg_attr(feature = "serde", serde(rename = "DrpAgt"))]
    pub drp_agt: PartyIdentification120Choice,

    #[yaserde(rename = "SlctnAgt")]
    #[cfg_attr(feature = "serde", serde(rename = "SlctnAgt"))]
    pub slctn_agt: Vec<PartyIdentification120Choice>,

    #[yaserde(rename = "InfAgt")]
    #[cfg_attr(feature = "serde", serde(rename = "InfAgt"))]
    pub inf_agt: PartyIdentification120Choice,

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

    #[yaserde(rename = "Offerr")]
    #[cfg_attr(feature = "serde", serde(rename = "Offerr"))]
    pub offerr: Vec<PartyIdentification129Choice>,

    #[yaserde(rename = "TrfAgt")]
    #[cfg_attr(feature = "serde", serde(rename = "TrfAgt"))]
    pub trf_agt: PartyIdentification129Choice,

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

impl Validate for CorporateActionNotificationV16 {}


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

pub enum CorporateActionOption15Code {
    #[yaserde(rename = "ABST")]
    #[cfg_attr(feature = "serde", serde(rename = "ABST"))]
    Abst,
    #[yaserde(rename = "BSPL")]
    #[cfg_attr(feature = "serde", serde(rename = "BSPL"))]
    Bspl,
    #[yaserde(rename = "BUYA")]
    #[cfg_attr(feature = "serde", serde(rename = "BUYA"))]
    Buya,
    #[yaserde(rename = "CASE")]
    #[cfg_attr(feature = "serde", serde(rename = "CASE"))]
    Case,
    #[yaserde(rename = "CASH")]
    #[cfg_attr(feature = "serde", serde(rename = "CASH"))]
    Cash,
    #[yaserde(rename = "CEXC")]
    #[cfg_attr(feature = "serde", serde(rename = "CEXC"))]
    Cexc,
    #[yaserde(rename = "CONN")]
    #[cfg_attr(feature = "serde", serde(rename = "CONN"))]
    Conn,
    #[yaserde(rename = "CONY")]
    #[cfg_attr(feature = "serde", serde(rename = "CONY"))]
    Cony,
    #[yaserde(rename = "CTEN")]
    #[cfg_attr(feature = "serde", serde(rename = "CTEN"))]
    Cten,
    #[yaserde(rename = "EXER")]
    #[cfg_attr(feature = "serde", serde(rename = "EXER"))]
    Exer,
    #[yaserde(rename = "LAPS")]
    #[cfg_attr(feature = "serde", serde(rename = "LAPS"))]
    Laps,
    #[yaserde(rename = "MPUT")]
    #[cfg_attr(feature = "serde", serde(rename = "MPUT"))]
    Mput,
    #[yaserde(rename = "NOAC")]
    #[cfg_attr(feature = "serde", serde(rename = "NOAC"))]
    Noac,
    #[yaserde(rename = "NOQU")]
    #[cfg_attr(feature = "serde", serde(rename = "NOQU"))]
    Noqu,
    #[yaserde(rename = "OFFR")]
    #[cfg_attr(feature = "serde", serde(rename = "OFFR"))]
    Offr,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "OVER")]
    #[cfg_attr(feature = "serde", serde(rename = "OVER"))]
    Over,
    #[yaserde(rename = "QINV")]
    #[cfg_attr(feature = "serde", serde(rename = "QINV"))]
    Qinv,
    #[yaserde(rename = "SECU")]
    #[cfg_attr(feature = "serde", serde(rename = "SECU"))]
    Secu,
    #[yaserde(rename = "SLLE")]
    #[cfg_attr(feature = "serde", serde(rename = "SLLE"))]
    Slle,
    #[yaserde(rename = "PRUN")]
    #[cfg_attr(feature = "serde", serde(rename = "PRUN"))]
    Prun,
    #[yaserde(rename = "BOBD")]
    #[cfg_attr(feature = "serde", serde(rename = "BOBD"))]
    Bobd,
    __Unknown__(String),
}

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

impl Validate for CorporateActionOption15Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct CorporateActionOption251 {
    #[yaserde(rename = "OptnNb")]
    #[cfg_attr(feature = "serde", serde(rename = "OptnNb"))]
    pub optn_nb: Exact3NumericText,

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

    #[yaserde(rename = "FrctnDspstn")]
    #[cfg_attr(feature = "serde", serde(rename = "FrctnDspstn"))]
    pub frctn_dspstn: FractionDispositionType26Choice,

    #[yaserde(rename = "OptnFeatrs")]
    #[cfg_attr(feature = "serde", serde(rename = "OptnFeatrs"))]
    pub optn_featrs: Vec<OptionFeaturesFormat32Choice>,

    #[yaserde(rename = "OptnAvlbtySts")]
    #[cfg_attr(feature = "serde", serde(rename = "OptnAvlbtySts"))]
    pub optn_avlbty_sts: OptionAvailabilityStatus3Choice,

    #[yaserde(rename = "CertfctnBrkdwnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CertfctnBrkdwnTp"))]
    pub certfctn_brkdwn_tp: Vec<BeneficiaryCertificationType13Choice>,

    #[yaserde(rename = "BidRgTp")]
    #[cfg_attr(feature = "serde", serde(rename = "BidRgTp"))]
    pub bid_rg_tp: BidRangeType1Choice,

    #[yaserde(rename = "PrratnBlwMinQty")]
    #[cfg_attr(feature = "serde", serde(rename = "PrratnBlwMinQty"))]
    pub prratn_blw_min_qty: ProrationBelowMinimumQuantity3Choice,

    #[yaserde(rename = "NonDmclCtry")]
    #[cfg_attr(feature = "serde", serde(rename = "NonDmclCtry"))]
    pub non_dmcl_ctry: Vec<CountryCode>,

    #[yaserde(rename = "VldDmclCtry")]
    #[cfg_attr(feature = "serde", serde(rename = "VldDmclCtry"))]
    pub vld_dmcl_ctry: Vec<CountryCode>,

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

    #[yaserde(rename = "DfltPrcgOrStgInstr")]
    #[cfg_attr(feature = "serde", serde(rename = "DfltPrcgOrStgInstr"))]
    pub dflt_prcg_or_stg_instr: DefaultProcessingOrStandingInstruction2Choice,

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

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

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

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

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

    #[yaserde(rename = "FinInstrmId")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrmId"))]
    pub fin_instrm_id: SecurityIdentification19,

    #[yaserde(rename = "DtDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "DtDtls"))]
    pub dt_dtls: CorporateActionDate110,

    #[yaserde(rename = "PrdDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "PrdDtls"))]
    pub prd_dtls: CorporateActionPeriod18,

    #[yaserde(rename = "RateAndAmtDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "RateAndAmtDtls"))]
    pub rate_and_amt_dtls: CorporateActionRate139,

    #[yaserde(rename = "PricDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "PricDtls"))]
    pub pric_dtls: CorporateActionPrice87,

    #[yaserde(rename = "SctiesQty")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesQty"))]
    pub scties_qty: SecuritiesOption81,

    #[yaserde(rename = "SctiesMvmntDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesMvmntDtls"))]
    pub scties_mvmnt_dtls: Vec<SecuritiesOption121>,

    #[yaserde(rename = "CshMvmntDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "CshMvmntDtls"))]
    pub csh_mvmnt_dtls: Vec<CashOption116>,

    #[yaserde(rename = "AddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
    pub addtl_inf: CorporateActionNarrative59,
}

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

impl Validate for CorporateActionOption37Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct CorporateActionPeriod17 {
    #[yaserde(rename = "IntrstPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstPrd"))]
    pub intrst_prd: Period12Choice,

    #[yaserde(rename = "CmplsryPurchsPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "CmplsryPurchsPrd"))]
    pub cmplsry_purchs_prd: Period12Choice,

    #[yaserde(rename = "ClmPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "ClmPrd"))]
    pub clm_prd: Period12Choice,

    #[yaserde(rename = "DpstrySspnsnPrdForBookNtryTrf")]
    #[cfg_attr(feature = "serde", serde(rename = "DpstrySspnsnPrdForBookNtryTrf"))]
    pub dpstry_sspnsn_prd_for_book_ntry_trf: Period12Choice,

    #[yaserde(rename = "DpstrySspnsnPrdForDpstAtAgt")]
    #[cfg_attr(feature = "serde", serde(rename = "DpstrySspnsnPrdForDpstAtAgt"))]
    pub dpstry_sspnsn_prd_for_dpst_at_agt: Period12Choice,

    #[yaserde(rename = "DpstrySspnsnPrdForDpst")]
    #[cfg_attr(feature = "serde", serde(rename = "DpstrySspnsnPrdForDpst"))]
    pub dpstry_sspnsn_prd_for_dpst: Period12Choice,

    #[yaserde(rename = "DpstrySspnsnPrdForPldg")]
    #[cfg_attr(feature = "serde", serde(rename = "DpstrySspnsnPrdForPldg"))]
    pub dpstry_sspnsn_prd_for_pldg: Period12Choice,

    #[yaserde(rename = "DpstrySspnsnPrdForSgrtn")]
    #[cfg_attr(feature = "serde", serde(rename = "DpstrySspnsnPrdForSgrtn"))]
    pub dpstry_sspnsn_prd_for_sgrtn: Period12Choice,

    #[yaserde(rename = "DpstrySspnsnPrdForWdrwlAtAgt")]
    #[cfg_attr(feature = "serde", serde(rename = "DpstrySspnsnPrdForWdrwlAtAgt"))]
    pub dpstry_sspnsn_prd_for_wdrwl_at_agt: Period12Choice,

    #[yaserde(rename = "DpstrySspnsnPrdForWdrwlInNmneeNm")]
    #[cfg_attr(feature = "serde", serde(rename = "DpstrySspnsnPrdForWdrwlInNmneeNm"))]
    pub dpstry_sspnsn_prd_for_wdrwl_in_nmnee_nm: Period12Choice,

    #[yaserde(rename = "DpstrySspnsnPrdForWdrwlInStrtNm")]
    #[cfg_attr(feature = "serde", serde(rename = "DpstrySspnsnPrdForWdrwlInStrtNm"))]
    pub dpstry_sspnsn_prd_for_wdrwl_in_strt_nm: Period12Choice,

    #[yaserde(rename = "BookClsrPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "BookClsrPrd"))]
    pub book_clsr_prd: Period12Choice,

    #[yaserde(rename = "CoDpstriesSspnsnPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "CoDpstriesSspnsnPrd"))]
    pub co_dpstries_sspnsn_prd: Period12Choice,

    #[yaserde(rename = "SpltPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "SpltPrd"))]
    pub splt_prd: Period12Choice,

    #[yaserde(rename = "FsclYrPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "FsclYrPrd"))]
    pub fscl_yr_prd: Period12Choice,
}

impl Validate for CorporateActionPeriod17 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct CorporateActionPeriod18 {
    #[yaserde(rename = "PricClctnPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "PricClctnPrd"))]
    pub pric_clctn_prd: Period12Choice,

    #[yaserde(rename = "ParllTradgPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "ParllTradgPrd"))]
    pub parll_tradg_prd: Period12Choice,

    #[yaserde(rename = "ActnPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "ActnPrd"))]
    pub actn_prd: Period6Choice,

    #[yaserde(rename = "RvcbltyPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "RvcbltyPrd"))]
    pub rvcblty_prd: Period6Choice,

    #[yaserde(rename = "PrvlgSspnsnPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvlgSspnsnPrd"))]
    pub prvlg_sspnsn_prd: Period6Choice,

    #[yaserde(rename = "AcctSvcrRvcbltyPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctSvcrRvcbltyPrd"))]
    pub acct_svcr_rvcblty_prd: Period6Choice,

    #[yaserde(rename = "DpstrySspnsnPrdForWdrwl")]
    #[cfg_attr(feature = "serde", serde(rename = "DpstrySspnsnPrdForWdrwl"))]
    pub dpstry_sspnsn_prd_for_wdrwl: Period12Choice,
}

impl Validate for CorporateActionPeriod18 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct CorporateActionPrice82 {
    #[yaserde(rename = "IndctvOrMktPric")]
    #[cfg_attr(feature = "serde", serde(rename = "IndctvOrMktPric"))]
    pub indctv_or_mkt_pric: IndicativeOrMarketPrice12Choice,

    #[yaserde(rename = "CshInLieuOfShrPric")]
    #[cfg_attr(feature = "serde", serde(rename = "CshInLieuOfShrPric"))]
    pub csh_in_lieu_of_shr_pric: PriceFormat74Choice,

    #[yaserde(rename = "CshValForTax")]
    #[cfg_attr(feature = "serde", serde(rename = "CshValForTax"))]
    pub csh_val_for_tax: PriceFormat46Choice,

    #[yaserde(rename = "GncCshPricPdPerPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "GncCshPricPdPerPdct"))]
    pub gnc_csh_pric_pd_per_pdct: PriceFormat73Choice,

    #[yaserde(rename = "GncCshPricRcvdPerPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "GncCshPricRcvdPerPdct"))]
    pub gnc_csh_pric_rcvd_per_pdct: PriceFormat72Choice,
}

impl Validate for CorporateActionPrice82 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct CorporateActionPrice85 {
    #[yaserde(rename = "MaxPric")]
    #[cfg_attr(feature = "serde", serde(rename = "MaxPric"))]
    pub max_pric: PriceFormat73Choice,

    #[yaserde(rename = "MinPric")]
    #[cfg_attr(feature = "serde", serde(rename = "MinPric"))]
    pub min_pric: PriceFormat73Choice,

    #[yaserde(rename = "FrstBidIncrmtPric")]
    #[cfg_attr(feature = "serde", serde(rename = "FrstBidIncrmtPric"))]
    pub frst_bid_incrmt_pric: PriceFormat73Choice,

    #[yaserde(rename = "LastBidIncrmtPric")]
    #[cfg_attr(feature = "serde", serde(rename = "LastBidIncrmtPric"))]
    pub last_bid_incrmt_pric: PriceFormat73Choice,
}

impl Validate for CorporateActionPrice85 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct CorporateActionPrice87 {
    #[yaserde(rename = "CshInLieuOfShrPric")]
    #[cfg_attr(feature = "serde", serde(rename = "CshInLieuOfShrPric"))]
    pub csh_in_lieu_of_shr_pric: PriceFormat74Choice,

    #[yaserde(rename = "OverSbcptDpstPric")]
    #[cfg_attr(feature = "serde", serde(rename = "OverSbcptDpstPric"))]
    pub over_sbcpt_dpst_pric: PriceFormat74Choice,

    #[yaserde(rename = "MaxCshToInst")]
    #[cfg_attr(feature = "serde", serde(rename = "MaxCshToInst"))]
    pub max_csh_to_inst: PriceFormat61Choice,

    #[yaserde(rename = "MinCshToInst")]
    #[cfg_attr(feature = "serde", serde(rename = "MinCshToInst"))]
    pub min_csh_to_inst: PriceFormat61Choice,

    #[yaserde(rename = "MinMltplCshToInst")]
    #[cfg_attr(feature = "serde", serde(rename = "MinMltplCshToInst"))]
    pub min_mltpl_csh_to_inst: PriceFormat61Choice,

    #[yaserde(rename = "MaxPric")]
    #[cfg_attr(feature = "serde", serde(rename = "MaxPric"))]
    pub max_pric: PriceFormat73Choice,

    #[yaserde(rename = "MinPric")]
    #[cfg_attr(feature = "serde", serde(rename = "MinPric"))]
    pub min_pric: PriceFormat73Choice,

    #[yaserde(rename = "FrstBidIncrmtPric")]
    #[cfg_attr(feature = "serde", serde(rename = "FrstBidIncrmtPric"))]
    pub frst_bid_incrmt_pric: PriceFormat73Choice,

    #[yaserde(rename = "LastBidIncrmtPric")]
    #[cfg_attr(feature = "serde", serde(rename = "LastBidIncrmtPric"))]
    pub last_bid_incrmt_pric: PriceFormat73Choice,
}

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

impl Validate for CorporateActionProcessingStatus5Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct CorporateActionQuantity15 {
    #[yaserde(rename = "MaxQty")]
    #[cfg_attr(feature = "serde", serde(rename = "MaxQty"))]
    pub max_qty: FinancialInstrumentQuantity34Choice,

    #[yaserde(rename = "MinQtySght")]
    #[cfg_attr(feature = "serde", serde(rename = "MinQtySght"))]
    pub min_qty_sght: FinancialInstrumentQuantity34Choice,

    #[yaserde(rename = "NewBrdLotQty")]
    #[cfg_attr(feature = "serde", serde(rename = "NewBrdLotQty"))]
    pub new_brd_lot_qty: FinancialInstrumentQuantity35Choice,

    #[yaserde(rename = "NewDnmtnQty")]
    #[cfg_attr(feature = "serde", serde(rename = "NewDnmtnQty"))]
    pub new_dnmtn_qty: FinancialInstrumentQuantity35Choice,

    #[yaserde(rename = "BaseDnmtn")]
    #[cfg_attr(feature = "serde", serde(rename = "BaseDnmtn"))]
    pub base_dnmtn: FinancialInstrumentQuantity35Choice,

    #[yaserde(rename = "IncrmtlDnmtn")]
    #[cfg_attr(feature = "serde", serde(rename = "IncrmtlDnmtn"))]
    pub incrmtl_dnmtn: FinancialInstrumentQuantity35Choice,

    #[yaserde(rename = "SctyClldQty")]
    #[cfg_attr(feature = "serde", serde(rename = "SctyClldQty"))]
    pub scty_clld_qty: FinancialInstrumentQuantity35Choice,

    #[yaserde(rename = "NewOutsdngQty")]
    #[cfg_attr(feature = "serde", serde(rename = "NewOutsdngQty"))]
    pub new_outsdng_qty: FinancialInstrumentQuantity35Choice,

    #[yaserde(rename = "TtlOutsdngQty")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlOutsdngQty"))]
    pub ttl_outsdng_qty: FinancialInstrumentQuantity35Choice,
}

impl Validate for CorporateActionQuantity15 {}


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

    #[yaserde(rename = "PctgSght")]
    #[cfg_attr(feature = "serde", serde(rename = "PctgSght"))]
    pub pctg_sght: RateFormat25Choice,

    #[yaserde(rename = "RltdIndx")]
    #[cfg_attr(feature = "serde", serde(rename = "RltdIndx"))]
    pub rltd_indx: RateFormat24Choice,

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

    #[yaserde(rename = "BidIntrvl")]
    #[cfg_attr(feature = "serde", serde(rename = "BidIntrvl"))]
    pub bid_intrvl: RateAndAmountFormat58Choice,

    #[yaserde(rename = "PrvsFctr")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvsFctr"))]
    pub prvs_fctr: RateFormat12Choice,

    #[yaserde(rename = "NxtFctr")]
    #[cfg_attr(feature = "serde", serde(rename = "NxtFctr"))]
    pub nxt_fctr: RateFormat12Choice,

    #[yaserde(rename = "RinvstmtDscntRateToMkt")]
    #[cfg_attr(feature = "serde", serde(rename = "RinvstmtDscntRateToMkt"))]
    pub rinvstmt_dscnt_rate_to_mkt: RateFormat24Choice,

    #[yaserde(rename = "IntrstShrtfll")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstShrtfll"))]
    pub intrst_shrtfll: RateAndAmountFormat59Choice,

    #[yaserde(rename = "RealsdLoss")]
    #[cfg_attr(feature = "serde", serde(rename = "RealsdLoss"))]
    pub realsd_loss: RateAndAmountFormat59Choice,

    #[yaserde(rename = "DclrdRate")]
    #[cfg_attr(feature = "serde", serde(rename = "DclrdRate"))]
    pub dclrd_rate: RateAndAmountFormat59Choice,

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

impl Validate for CorporateActionRate122 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct CorporateActionRate128 {
    #[yaserde(rename = "AddtlQtyForSbcbdRsltntScties")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlQtyForSbcbdRsltntScties"))]
    pub addtl_qty_for_sbcbd_rsltnt_scties: RatioFormat17Choice,

    #[yaserde(rename = "AddtlQtyForExstgScties")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlQtyForExstgScties"))]
    pub addtl_qty_for_exstg_scties: RatioFormat17Choice,

    #[yaserde(rename = "NewToOd")]
    #[cfg_attr(feature = "serde", serde(rename = "NewToOd"))]
    pub new_to_od: RatioFormat18Choice,

    #[yaserde(rename = "TrfrmatnRate")]
    #[cfg_attr(feature = "serde", serde(rename = "TrfrmatnRate"))]
    pub trfrmatn_rate: Percentage14Rate,

    #[yaserde(rename = "ChrgsFees")]
    #[cfg_attr(feature = "serde", serde(rename = "ChrgsFees"))]
    pub chrgs_fees: RateAndAmountFormat57Choice,

    #[yaserde(rename = "FsclStmp")]
    #[cfg_attr(feature = "serde", serde(rename = "FsclStmp"))]
    pub fscl_stmp: RateFormat24Choice,

    #[yaserde(rename = "AplblRate")]
    #[cfg_attr(feature = "serde", serde(rename = "AplblRate"))]
    pub aplbl_rate: RateFormat24Choice,

    #[yaserde(rename = "TaxCdtRate")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxCdtRate"))]
    pub tax_cdt_rate: RateFormat26Choice,

    #[yaserde(rename = "FinTxTaxRate")]
    #[cfg_attr(feature = "serde", serde(rename = "FinTxTaxRate"))]
    pub fin_tx_tax_rate: RateFormat24Choice,

    #[yaserde(rename = "WhldgTaxRate")]
    #[cfg_attr(feature = "serde", serde(rename = "WhldgTaxRate"))]
    pub whldg_tax_rate: Vec<RateAndAmountFormat60Choice>,

    #[yaserde(rename = "ScndLvlTax")]
    #[cfg_attr(feature = "serde", serde(rename = "ScndLvlTax"))]
    pub scnd_lvl_tax: Vec<RateAndAmountFormat60Choice>,
}

impl Validate for CorporateActionRate128 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct CorporateActionRate139 {
    #[yaserde(rename = "AddtlTax")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlTax"))]
    pub addtl_tax: RateAndAmountFormat57Choice,

    #[yaserde(rename = "GrssDstrbtnRate")]
    #[cfg_attr(feature = "serde", serde(rename = "GrssDstrbtnRate"))]
    pub grss_dstrbtn_rate: Vec<GrossDividendRateFormat36Choice>,

    #[yaserde(rename = "NetDstrbtnRate")]
    #[cfg_attr(feature = "serde", serde(rename = "NetDstrbtnRate"))]
    pub net_dstrbtn_rate: Vec<NetDividendRateFormat38Choice>,

    #[yaserde(rename = "GrssIntrstRateUsdForPmt")]
    #[cfg_attr(feature = "serde", serde(rename = "GrssIntrstRateUsdForPmt"))]
    pub grss_intrst_rate_usd_for_pmt: Vec<InterestRateUsedForPaymentFormat11Choice>,

    #[yaserde(rename = "MaxAllwdOvrsbcptRate")]
    #[cfg_attr(feature = "serde", serde(rename = "MaxAllwdOvrsbcptRate"))]
    pub max_allwd_ovrsbcpt_rate: RateFormat24Choice,

    #[yaserde(rename = "PrratnRate")]
    #[cfg_attr(feature = "serde", serde(rename = "PrratnRate"))]
    pub prratn_rate: RateFormat32Choice,

    #[yaserde(rename = "WhldgTaxRate")]
    #[cfg_attr(feature = "serde", serde(rename = "WhldgTaxRate"))]
    pub whldg_tax_rate: Vec<RateAndAmountFormat56Choice>,

    #[yaserde(rename = "ScndLvlTax")]
    #[cfg_attr(feature = "serde", serde(rename = "ScndLvlTax"))]
    pub scnd_lvl_tax: Vec<RateAndAmountFormat60Choice>,

    #[yaserde(rename = "TaxblIncmPerDvddShr")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxblIncmPerDvddShr"))]
    pub taxbl_incm_per_dvdd_shr: Vec<RateTypeAndAmountAndStatus26>,

    #[yaserde(rename = "IssrDclrdXchgRate")]
    #[cfg_attr(feature = "serde", serde(rename = "IssrDclrdXchgRate"))]
    pub issr_dclrd_xchg_rate: ForeignExchangeTerms38,

    #[yaserde(rename = "TaxOnIncm")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxOnIncm"))]
    pub tax_on_incm: RateAndAmountFormat57Choice,

    #[yaserde(rename = "BidIntrvl")]
    #[cfg_attr(feature = "serde", serde(rename = "BidIntrvl"))]
    pub bid_intrvl: RateAndAmountFormat58Choice,
}

impl Validate for CorporateActionRate139 {}


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

pub enum CorporateActionTaxableIncomePerShareCalculated1Code {
    #[yaserde(rename = "TDIY")]
    #[cfg_attr(feature = "serde", serde(rename = "TDIY"))]
    Tdiy,
    #[yaserde(rename = "TDIN")]
    #[cfg_attr(feature = "serde", serde(rename = "TDIN"))]
    Tdin,
    #[yaserde(rename = "UKWN")]
    #[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
    Ukwn,
    __Unknown__(String),
}

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

impl Validate for CorporateActionTaxableIncomePerShareCalculated1Code {}



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

pub enum CreditDebitCode {
    #[yaserde(rename = "CRDT")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDT"))]
    Crdt,
    #[yaserde(rename = "DBIT")]
    #[cfg_attr(feature = "serde", serde(rename = "DBIT"))]
    Dbit,
    __Unknown__(String),
}

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

impl Validate for CreditDebitCode {}



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

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

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

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

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

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

impl Validate for DateCode33Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct DateCodeAndTimeFormat3 {
    #[yaserde(rename = "DtCd")]
    #[cfg_attr(feature = "serde", serde(rename = "DtCd"))]
    pub dt_cd: DateCode21Choice,

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

impl Validate for DateCodeAndTimeFormat3 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct DateFormat30Choice {
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Option<Isodate>,
    #[yaserde(rename = "DtCd")]
    #[cfg_attr(feature = "serde", serde(rename = "DtCd"))]
    pub dt_cd: Option<DateCode19Choice>,
}

impl Validate for DateFormat30Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct DateFormat43Choice {
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Option<DateAndDateTime2Choice>,
    #[yaserde(rename = "DtCd")]
    #[cfg_attr(feature = "serde", serde(rename = "DtCd"))]
    pub dt_cd: Option<DateCode19Choice>,
}

impl Validate for DateFormat43Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct DateFormat44Choice {
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Option<DateAndDateTime2Choice>,
    #[yaserde(rename = "DtCdAndTm")]
    #[cfg_attr(feature = "serde", serde(rename = "DtCdAndTm"))]
    pub dt_cd_and_tm: Option<DateCodeAndTimeFormat3>,
    #[yaserde(rename = "DtCd")]
    #[cfg_attr(feature = "serde", serde(rename = "DtCd"))]
    pub dt_cd: Option<DateCode19Choice>,
}

impl Validate for DateFormat44Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct DateFormat45Choice {
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Option<DateAndDateTime2Choice>,
    #[yaserde(rename = "NotSpcfdDt")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdDt"))]
    pub not_spcfd_dt: Option<DateType8Code>,
}

impl Validate for DateFormat45Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct DateFormat46Choice {
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Option<DateAndDateTime2Choice>,
    #[yaserde(rename = "DtCd")]
    #[cfg_attr(feature = "serde", serde(rename = "DtCd"))]
    pub dt_cd: Option<DateCode20Choice>,
}

impl Validate for DateFormat46Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct DateFormat57Choice {
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Option<Isodate>,
    #[yaserde(rename = "DtCd")]
    #[cfg_attr(feature = "serde", serde(rename = "DtCd"))]
    pub dt_cd: Option<DateCode20Choice>,
}

impl Validate for DateFormat57Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct DateFormat59Choice {
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Option<DateAndDateTime2Choice>,
    #[yaserde(rename = "DtCd")]
    #[cfg_attr(feature = "serde", serde(rename = "DtCd"))]
    pub dt_cd: Option<DateCode33Choice>,
}

impl Validate for DateFormat59Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct DateFormat73Choice {
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Option<Isodate>,
    #[yaserde(rename = "NotSpcfdDt")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdDt"))]
    pub not_spcfd_dt: Option<DateType8Code>,
}

impl Validate for DateFormat73Choice {}




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

pub enum DateType1Code {
    #[yaserde(rename = "UKWN")]
    #[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
    Ukwn,
    __Unknown__(String),
}

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

impl Validate for DateType1Code {}



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

pub enum DateType7Code {
    #[yaserde(rename = "ONGO")]
    #[cfg_attr(feature = "serde", serde(rename = "ONGO"))]
    Ongo,
    __Unknown__(String),
}

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

impl Validate for DateType7Code {}



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

pub enum DateType8Code {
    #[yaserde(rename = "UKWN")]
    #[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
    Ukwn,
    #[yaserde(rename = "ONGO")]
    #[cfg_attr(feature = "serde", serde(rename = "ONGO"))]
    Ongo,
    __Unknown__(String),
}

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

impl Validate for DateType8Code {}



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

pub enum DateType9Code {
    #[yaserde(rename = "PWAL")]
    #[cfg_attr(feature = "serde", serde(rename = "PWAL"))]
    Pwal,
    #[yaserde(rename = "MKDT")]
    #[cfg_attr(feature = "serde", serde(rename = "MKDT"))]
    Mkdt,
    #[yaserde(rename = "MEET")]
    #[cfg_attr(feature = "serde", serde(rename = "MEET"))]
    Meet,
    #[yaserde(rename = "PAYD")]
    #[cfg_attr(feature = "serde", serde(rename = "PAYD"))]
    Payd,
    #[yaserde(rename = "RDTE")]
    #[cfg_attr(feature = "serde", serde(rename = "RDTE"))]
    Rdte,
    #[yaserde(rename = "RDDT")]
    #[cfg_attr(feature = "serde", serde(rename = "RDDT"))]
    Rddt,
    #[yaserde(rename = "NARR")]
    #[cfg_attr(feature = "serde", serde(rename = "NARR"))]
    Narr,
    #[yaserde(rename = "UKWN")]
    #[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
    Ukwn,
    __Unknown__(String),
}

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

impl Validate for DateType9Code {}



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

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

impl Validate for DeemedRateType1Choice {}




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

pub enum DeemedRateType1Code {
    #[yaserde(rename = "DEDI")]
    #[cfg_attr(feature = "serde", serde(rename = "DEDI"))]
    Dedi,
    #[yaserde(rename = "DEFP")]
    #[cfg_attr(feature = "serde", serde(rename = "DEFP"))]
    Defp,
    #[yaserde(rename = "DEIT")]
    #[cfg_attr(feature = "serde", serde(rename = "DEIT"))]
    Deit,
    #[yaserde(rename = "DERY")]
    #[cfg_attr(feature = "serde", serde(rename = "DERY"))]
    Dery,
    __Unknown__(String),
}

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

impl Validate for DeemedRateType1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct DefaultProcessingOrStandingInstruction2Choice {
    #[yaserde(rename = "DfltOptnInd")]
    #[cfg_attr(feature = "serde", serde(rename = "DfltOptnInd"))]
    pub dflt_optn_ind: Option<YesNoIndicator>,
    #[yaserde(rename = "StgInstrInd")]
    #[cfg_attr(feature = "serde", serde(rename = "StgInstrInd"))]
    pub stg_instr_ind: Option<YesNoIndicator>,
}

impl Validate for DefaultProcessingOrStandingInstruction2Choice {}




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

pub enum DistributionType3Code {
    #[yaserde(rename = "FINL")]
    #[cfg_attr(feature = "serde", serde(rename = "FINL"))]
    Finl,
    #[yaserde(rename = "INTE")]
    #[cfg_attr(feature = "serde", serde(rename = "INTE"))]
    Inte,
    #[yaserde(rename = "ONGO")]
    #[cfg_attr(feature = "serde", serde(rename = "ONGO"))]
    Ongo,
    #[yaserde(rename = "ROLL")]
    #[cfg_attr(feature = "serde", serde(rename = "ROLL"))]
    Roll,
    __Unknown__(String),
}

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

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

impl Validate for DistributionTypeFormat7Choice {}




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

pub enum DividendRateType1Code {
    #[yaserde(rename = "TXBL")]
    #[cfg_attr(feature = "serde", serde(rename = "TXBL"))]
    Txbl,
    __Unknown__(String),
}

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

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

impl Validate for DividendTypeFormat9Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct Document {
    #[yaserde(rename = "CorpActnNtfctn")]
    #[cfg_attr(feature = "serde", serde(rename = "CorpActnNtfctn"))]
    pub corp_actn_ntfctn: CorporateActionNotificationV16,
}

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:seev.031.001.16")]
pub struct DocumentIdentification31 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

    #[yaserde(rename = "LkgTp")]
    #[cfg_attr(feature = "serde", serde(rename = "LkgTp"))]
    pub lkg_tp: ProcessingPosition7Choice,
}

impl Validate for DocumentIdentification31 {}


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

    #[yaserde(rename = "DocNb")]
    #[cfg_attr(feature = "serde", serde(rename = "DocNb"))]
    pub doc_nb: DocumentNumber5Choice,

    #[yaserde(rename = "LkgTp")]
    #[cfg_attr(feature = "serde", serde(rename = "LkgTp"))]
    pub lkg_tp: ProcessingPosition7Choice,
}

impl Validate for DocumentIdentification32 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct DocumentIdentification3Choice {
    #[yaserde(rename = "AcctSvcrDocId")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctSvcrDocId"))]
    pub acct_svcr_doc_id: Option<Max35Text>,
    #[yaserde(rename = "AcctOwnrDocId")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctOwnrDocId"))]
    pub acct_ownr_doc_id: Option<Max35Text>,
}

impl Validate for DocumentIdentification3Choice {}




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

impl Validate for DocumentIdentification9 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct DocumentNumber5Choice {
    #[yaserde(rename = "ShrtNb")]
    #[cfg_attr(feature = "serde", serde(rename = "ShrtNb"))]
    pub shrt_nb: Option<Exact3NumericText>,
    #[yaserde(rename = "LngNb")]
    #[cfg_attr(feature = "serde", serde(rename = "LngNb"))]
    pub lng_nb: Option<Iso20022MessageIdentificationText>,
    #[yaserde(rename = "PrtryNb")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryNb"))]
    pub prtry_nb: Option<GenericIdentification36>,
}

impl Validate for DocumentNumber5Choice {}




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

pub enum DutchAuctionType1Code {
    #[yaserde(rename = "MDFD")]
    #[cfg_attr(feature = "serde", serde(rename = "MDFD"))]
    Mdfd,
    #[yaserde(rename = "UNMD")]
    #[cfg_attr(feature = "serde", serde(rename = "UNMD"))]
    Unmd,
    __Unknown__(String),
}

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

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

impl Validate for DutchAuctionTypeFormat1Choice {}




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

pub enum EucapitalGain2Code {
    #[yaserde(rename = "EUSI")]
    #[cfg_attr(feature = "serde", serde(rename = "EUSI"))]
    Eusi,
    #[yaserde(rename = "EUSO")]
    #[cfg_attr(feature = "serde", serde(rename = "EUSO"))]
    Euso,
    #[yaserde(rename = "UKWN")]
    #[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
    Ukwn,
    __Unknown__(String),
}

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

impl Validate for EucapitalGain2Code {}



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

pub enum ElectionMovementType2Code {
    #[yaserde(rename = "DRCT")]
    #[cfg_attr(feature = "serde", serde(rename = "DRCT"))]
    Drct,
    #[yaserde(rename = "SEQD")]
    #[cfg_attr(feature = "serde", serde(rename = "SEQD"))]
    Seqd,
    __Unknown__(String),
}

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

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

impl Validate for ElectionTypeFormat3Choice {}




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

pub enum EventCompletenessStatus1Code {
    #[yaserde(rename = "COMP")]
    #[cfg_attr(feature = "serde", serde(rename = "COMP"))]
    Comp,
    #[yaserde(rename = "INCO")]
    #[cfg_attr(feature = "serde", serde(rename = "INCO"))]
    Inco,
    __Unknown__(String),
}

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

impl Validate for EventCompletenessStatus1Code {}



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

pub enum EventConfirmationStatus1Code {
    #[yaserde(rename = "CONF")]
    #[cfg_attr(feature = "serde", serde(rename = "CONF"))]
    Conf,
    #[yaserde(rename = "UCON")]
    #[cfg_attr(feature = "serde", serde(rename = "UCON"))]
    Ucon,
    __Unknown__(String),
}

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

impl Validate for EventConfirmationStatus1Code {}



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

pub enum EventSequenceType1Code {
    #[yaserde(rename = "FINL")]
    #[cfg_attr(feature = "serde", serde(rename = "FINL"))]
    Finl,
    #[yaserde(rename = "INTE")]
    #[cfg_attr(feature = "serde", serde(rename = "INTE"))]
    Inte,
    __Unknown__(String),
}

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

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

impl Validate for EventSequenceTypeFormat1Choice {}




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

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

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

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

impl Validate for ExternalFinancialInstrumentIdentificationType1Code {
    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:seev.031.001.16")]
pub struct FinancialInstrumentAttributes128 {
    #[yaserde(rename = "FinInstrmId")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrmId"))]
    pub fin_instrm_id: SecurityIdentification19,

    #[yaserde(rename = "PlcOfListg")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcOfListg"))]
    pub plc_of_listg: MarketIdentification3Choice,

    #[yaserde(rename = "DayCntBsis")]
    #[cfg_attr(feature = "serde", serde(rename = "DayCntBsis"))]
    pub day_cnt_bsis: InterestComputationMethodFormat4Choice,

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

    #[yaserde(rename = "OptnStyle")]
    #[cfg_attr(feature = "serde", serde(rename = "OptnStyle"))]
    pub optn_style: OptionStyle8Choice,

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

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

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

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

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

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

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

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

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

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

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

    #[yaserde(rename = "NxtIntrstRate")]
    #[cfg_attr(feature = "serde", serde(rename = "NxtIntrstRate"))]
    pub nxt_intrst_rate: RateFormat24Choice,

    #[yaserde(rename = "PctgOfDebtClm")]
    #[cfg_attr(feature = "serde", serde(rename = "PctgOfDebtClm"))]
    pub pctg_of_debt_clm: RateFormat24Choice,

    #[yaserde(rename = "PrvsFctr")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvsFctr"))]
    pub prvs_fctr: RateFormat12Choice,

    #[yaserde(rename = "NxtFctr")]
    #[cfg_attr(feature = "serde", serde(rename = "NxtFctr"))]
    pub nxt_fctr: RateFormat12Choice,

    #[yaserde(rename = "WarrtParity")]
    #[cfg_attr(feature = "serde", serde(rename = "WarrtParity"))]
    pub warrt_parity: QuantityToQuantityRatio1,

    #[yaserde(rename = "MinNmnlQty")]
    #[cfg_attr(feature = "serde", serde(rename = "MinNmnlQty"))]
    pub min_nmnl_qty: FinancialInstrumentQuantity33Choice,

    #[yaserde(rename = "CtrctSz")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrctSz"))]
    pub ctrct_sz: FinancialInstrumentQuantity33Choice,
}

impl Validate for FinancialInstrumentAttributes128 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct FinancialInstrumentAttributes129 {
    #[yaserde(rename = "FinInstrmId")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrmId"))]
    pub fin_instrm_id: SecurityIdentification19,

    #[yaserde(rename = "PlcOfListg")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcOfListg"))]
    pub plc_of_listg: MarketIdentification3Choice,

    #[yaserde(rename = "DayCntBsis")]
    #[cfg_attr(feature = "serde", serde(rename = "DayCntBsis"))]
    pub day_cnt_bsis: InterestComputationMethodFormat4Choice,

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

    #[yaserde(rename = "OptnStyle")]
    #[cfg_attr(feature = "serde", serde(rename = "OptnStyle"))]
    pub optn_style: OptionStyle8Choice,

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

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

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

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

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

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

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

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

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

    #[yaserde(rename = "PrvsFctr")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvsFctr"))]
    pub prvs_fctr: RateFormat12Choice,

    #[yaserde(rename = "NxtFctr")]
    #[cfg_attr(feature = "serde", serde(rename = "NxtFctr"))]
    pub nxt_fctr: RateFormat12Choice,

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

    #[yaserde(rename = "NxtIntrstRate")]
    #[cfg_attr(feature = "serde", serde(rename = "NxtIntrstRate"))]
    pub nxt_intrst_rate: RateFormat24Choice,

    #[yaserde(rename = "MinNmnlQty")]
    #[cfg_attr(feature = "serde", serde(rename = "MinNmnlQty"))]
    pub min_nmnl_qty: FinancialInstrumentQuantity33Choice,

    #[yaserde(rename = "MinQtyToInst")]
    #[cfg_attr(feature = "serde", serde(rename = "MinQtyToInst"))]
    pub min_qty_to_inst: FinancialInstrumentQuantity33Choice,

    #[yaserde(rename = "MinMltplQtyToInst")]
    #[cfg_attr(feature = "serde", serde(rename = "MinMltplQtyToInst"))]
    pub min_mltpl_qty_to_inst: FinancialInstrumentQuantity33Choice,

    #[yaserde(rename = "CtrctSz")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrctSz"))]
    pub ctrct_sz: FinancialInstrumentQuantity33Choice,

    #[yaserde(rename = "IssePric")]
    #[cfg_attr(feature = "serde", serde(rename = "IssePric"))]
    pub isse_pric: PriceFormat74Choice,
}

impl Validate for FinancialInstrumentAttributes129 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct FinancialInstrumentAttributes139 {
    #[yaserde(rename = "SctyId")]
    #[cfg_attr(feature = "serde", serde(rename = "SctyId"))]
    pub scty_id: SecurityIdentification19,

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

    #[yaserde(rename = "RnncblEntitlmntStsTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RnncblEntitlmntStsTp"))]
    pub rnncbl_entitlmnt_sts_tp: RenounceableEntitlementStatusTypeFormat3Choice,

    #[yaserde(rename = "FrctnDspstn")]
    #[cfg_attr(feature = "serde", serde(rename = "FrctnDspstn"))]
    pub frctn_dspstn: FractionDispositionType25Choice,

    #[yaserde(rename = "IntrmdtSctiesToUndrlygRatio")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrmdtSctiesToUndrlygRatio"))]
    pub intrmdt_scties_to_undrlyg_ratio: QuantityToQuantityRatio1,

    #[yaserde(rename = "MktPric")]
    #[cfg_attr(feature = "serde", serde(rename = "MktPric"))]
    pub mkt_pric: AmountPrice2,

    #[yaserde(rename = "XpryDt")]
    #[cfg_attr(feature = "serde", serde(rename = "XpryDt"))]
    pub xpry_dt: DateFormat30Choice,

    #[yaserde(rename = "PstngDt")]
    #[cfg_attr(feature = "serde", serde(rename = "PstngDt"))]
    pub pstng_dt: DateFormat30Choice,

    #[yaserde(rename = "TradgPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "TradgPrd"))]
    pub tradg_prd: Period18,

    #[yaserde(rename = "UinstdBal")]
    #[cfg_attr(feature = "serde", serde(rename = "UinstdBal"))]
    pub uinstd_bal: BalanceFormat11Choice,

    #[yaserde(rename = "InstdBal")]
    #[cfg_attr(feature = "serde", serde(rename = "InstdBal"))]
    pub instd_bal: BalanceFormat11Choice,
}

impl Validate for FinancialInstrumentAttributes139 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct FinancialInstrumentQuantity33Choice {
    #[yaserde(rename = "Unit")]
    #[cfg_attr(feature = "serde", serde(rename = "Unit"))]
    pub unit: Option<DecimalNumber>,
    #[yaserde(rename = "FaceAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "FaceAmt"))]
    pub face_amt: Option<ImpliedCurrencyAndAmount>,
    #[yaserde(rename = "AmtsdVal")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtsdVal"))]
    pub amtsd_val: Option<ImpliedCurrencyAndAmount>,
    #[yaserde(rename = "DgtlTknUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "DgtlTknUnit"))]
    pub dgtl_tkn_unit: Option<Max30DecimalNumber>,
}

impl Validate for FinancialInstrumentQuantity33Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct FinancialInstrumentQuantity34Choice {
    #[yaserde(rename = "Unit")]
    #[cfg_attr(feature = "serde", serde(rename = "Unit"))]
    pub unit: Option<DecimalNumber>,
    #[yaserde(rename = "FaceAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "FaceAmt"))]
    pub face_amt: Option<ImpliedCurrencyAndAmount>,
    #[yaserde(rename = "AmtsdVal")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtsdVal"))]
    pub amtsd_val: Option<ImpliedCurrencyAndAmount>,
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<Quantity4Code>,
    #[yaserde(rename = "DgtlTknUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "DgtlTknUnit"))]
    pub dgtl_tkn_unit: Option<Max30DecimalNumber>,
}

impl Validate for FinancialInstrumentQuantity34Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct FinancialInstrumentQuantity35Choice {
    #[yaserde(rename = "Unit")]
    #[cfg_attr(feature = "serde", serde(rename = "Unit"))]
    pub unit: Option<DecimalNumber>,
    #[yaserde(rename = "FaceAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "FaceAmt"))]
    pub face_amt: Option<ImpliedCurrencyAndAmount>,
    #[yaserde(rename = "AmtsdVal")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtsdVal"))]
    pub amtsd_val: Option<ImpliedCurrencyAndAmount>,
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<Quantity5Code>,
    #[yaserde(rename = "DgtlTknUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "DgtlTknUnit"))]
    pub dgtl_tkn_unit: Option<Max30DecimalNumber>,
}

impl Validate for FinancialInstrumentQuantity35Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct ForeignExchangeTerms38 {
    #[yaserde(rename = "UnitCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitCcy"))]
    pub unit_ccy: ActiveCurrencyCode,

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

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

impl Validate for ForeignExchangeTerms38 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct ForeignExchangeTerms39 {
    #[yaserde(rename = "UnitCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitCcy"))]
    pub unit_ccy: ActiveCurrencyCode,

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

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

    #[yaserde(rename = "RsltgAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "RsltgAmt"))]
    pub rsltg_amt: ActiveCurrencyAndAmount,
}

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

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

impl Validate for FractionDispositionType26Choice {}




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

pub enum FractionDispositionType8Code {
    #[yaserde(rename = "BUYU")]
    #[cfg_attr(feature = "serde", serde(rename = "BUYU"))]
    Buyu,
    #[yaserde(rename = "CINL")]
    #[cfg_attr(feature = "serde", serde(rename = "CINL"))]
    Cinl,
    #[yaserde(rename = "DIST")]
    #[cfg_attr(feature = "serde", serde(rename = "DIST"))]
    Dist,
    #[yaserde(rename = "RDDN")]
    #[cfg_attr(feature = "serde", serde(rename = "RDDN"))]
    Rddn,
    #[yaserde(rename = "STAN")]
    #[cfg_attr(feature = "serde", serde(rename = "STAN"))]
    Stan,
    #[yaserde(rename = "RDUP")]
    #[cfg_attr(feature = "serde", serde(rename = "RDUP"))]
    Rdup,
    #[yaserde(rename = "UKWN")]
    #[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
    Ukwn,
    __Unknown__(String),
}

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

impl Validate for FractionDispositionType8Code {}



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

pub enum FractionDispositionType9Code {
    #[yaserde(rename = "DIST")]
    #[cfg_attr(feature = "serde", serde(rename = "DIST"))]
    Dist,
    #[yaserde(rename = "RDDN")]
    #[cfg_attr(feature = "serde", serde(rename = "RDDN"))]
    Rddn,
    #[yaserde(rename = "STAN")]
    #[cfg_attr(feature = "serde", serde(rename = "STAN"))]
    Stan,
    #[yaserde(rename = "RDUP")]
    #[cfg_attr(feature = "serde", serde(rename = "RDUP"))]
    Rdup,
    #[yaserde(rename = "UKWN")]
    #[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
    Ukwn,
    __Unknown__(String),
}

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

impl Validate for FractionDispositionType9Code {}



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

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

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

impl Validate for GenericIdentification30 {}


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

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

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

impl Validate for GenericIdentification36 {}


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

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

impl Validate for GenericIdentification78 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct GrossDividendRateFormat36Choice {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<ActiveCurrencyAnd13DecimalAmount>,
    #[yaserde(rename = "AmtAndRateSts")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtAndRateSts"))]
    pub amt_and_rate_sts: Option<AmountAndRateStatus1>,
    #[yaserde(rename = "RateTpAndAmtAndRateSts")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTpAndAmtAndRateSts"))]
    pub rate_tp_and_amt_and_rate_sts: Option<RateTypeAndAmountAndStatus55>,
    #[yaserde(rename = "NotSpcfdRate")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdRate"))]
    pub not_spcfd_rate: Option<RateType13Code>,
}

impl Validate for GrossDividendRateFormat36Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct GrossDividendRateFormat38Choice {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<ActiveCurrencyAnd13DecimalAmount>,
    #[yaserde(rename = "AmtAndRateSts")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtAndRateSts"))]
    pub amt_and_rate_sts: Option<AmountAndRateStatus1>,
    #[yaserde(rename = "RateTpAndAmtAndRateSts")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTpAndAmtAndRateSts"))]
    pub rate_tp_and_amt_and_rate_sts: Option<RateTypeAndAmountAndStatus57>,
    #[yaserde(rename = "NotSpcfdRate")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdRate"))]
    pub not_spcfd_rate: Option<RateType13Code>,
}

impl Validate for GrossDividendRateFormat38Choice {}




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

pub enum GrossDividendRateType6Code {
    #[yaserde(rename = "CAPO")]
    #[cfg_attr(feature = "serde", serde(rename = "CAPO"))]
    Capo,
    #[yaserde(rename = "FLFR")]
    #[cfg_attr(feature = "serde", serde(rename = "FLFR"))]
    Flfr,
    #[yaserde(rename = "INCO")]
    #[cfg_attr(feature = "serde", serde(rename = "INCO"))]
    Inco,
    #[yaserde(rename = "INTR")]
    #[cfg_attr(feature = "serde", serde(rename = "INTR"))]
    Intr,
    #[yaserde(rename = "LTCG")]
    #[cfg_attr(feature = "serde", serde(rename = "LTCG"))]
    Ltcg,
    #[yaserde(rename = "REES")]
    #[cfg_attr(feature = "serde", serde(rename = "REES"))]
    Rees,
    #[yaserde(rename = "STCG")]
    #[cfg_attr(feature = "serde", serde(rename = "STCG"))]
    Stcg,
    #[yaserde(rename = "SOIC")]
    #[cfg_attr(feature = "serde", serde(rename = "SOIC"))]
    Soic,
    #[yaserde(rename = "TXBL")]
    #[cfg_attr(feature = "serde", serde(rename = "TXBL"))]
    Txbl,
    #[yaserde(rename = "TXDF")]
    #[cfg_attr(feature = "serde", serde(rename = "TXDF"))]
    Txdf,
    #[yaserde(rename = "TXFR")]
    #[cfg_attr(feature = "serde", serde(rename = "TXFR"))]
    Txfr,
    #[yaserde(rename = "UNFR")]
    #[cfg_attr(feature = "serde", serde(rename = "UNFR"))]
    Unfr,
    #[yaserde(rename = "CDFI")]
    #[cfg_attr(feature = "serde", serde(rename = "CDFI"))]
    Cdfi,
    __Unknown__(String),
}

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

impl Validate for GrossDividendRateType6Code {}



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

pub enum GrossDividendRateType7Code {
    #[yaserde(rename = "CAPO")]
    #[cfg_attr(feature = "serde", serde(rename = "CAPO"))]
    Capo,
    #[yaserde(rename = "CDFI")]
    #[cfg_attr(feature = "serde", serde(rename = "CDFI"))]
    Cdfi,
    #[yaserde(rename = "FUPU")]
    #[cfg_attr(feature = "serde", serde(rename = "FUPU"))]
    Fupu,
    #[yaserde(rename = "FLFR")]
    #[cfg_attr(feature = "serde", serde(rename = "FLFR"))]
    Flfr,
    #[yaserde(rename = "INCO")]
    #[cfg_attr(feature = "serde", serde(rename = "INCO"))]
    Inco,
    #[yaserde(rename = "INTR")]
    #[cfg_attr(feature = "serde", serde(rename = "INTR"))]
    Intr,
    #[yaserde(rename = "LTCG")]
    #[cfg_attr(feature = "serde", serde(rename = "LTCG"))]
    Ltcg,
    #[yaserde(rename = "PAPU")]
    #[cfg_attr(feature = "serde", serde(rename = "PAPU"))]
    Papu,
    #[yaserde(rename = "REES")]
    #[cfg_attr(feature = "serde", serde(rename = "REES"))]
    Rees,
    #[yaserde(rename = "STCG")]
    #[cfg_attr(feature = "serde", serde(rename = "STCG"))]
    Stcg,
    #[yaserde(rename = "SOIC")]
    #[cfg_attr(feature = "serde", serde(rename = "SOIC"))]
    Soic,
    #[yaserde(rename = "TXBL")]
    #[cfg_attr(feature = "serde", serde(rename = "TXBL"))]
    Txbl,
    #[yaserde(rename = "TXDF")]
    #[cfg_attr(feature = "serde", serde(rename = "TXDF"))]
    Txdf,
    #[yaserde(rename = "TXFR")]
    #[cfg_attr(feature = "serde", serde(rename = "TXFR"))]
    Txfr,
    #[yaserde(rename = "UNFR")]
    #[cfg_attr(feature = "serde", serde(rename = "UNFR"))]
    Unfr,
    __Unknown__(String),
}

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

impl Validate for GrossDividendRateType7Code {}



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

impl Validate for Iban2007Identifier {}
#[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 Iso20022MessageIdentificationText (pub String);
crate::simple_type!(Iso20022MessageIdentificationText);

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

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

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

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

impl Validate for Isotime {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct IdentificationFormat3Choice {
    #[yaserde(rename = "ShrtId")]
    #[cfg_attr(feature = "serde", serde(rename = "ShrtId"))]
    pub shrt_id: Option<Exact3UpperCaseAlphaNumericText>,
    #[yaserde(rename = "LngId")]
    #[cfg_attr(feature = "serde", serde(rename = "LngId"))]
    pub lng_id: Option<Max30Text>,
    #[yaserde(rename = "PrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
    pub prtry_id: Option<GenericIdentification36>,
}

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

impl Validate for IdentificationSource3Choice {}




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

impl Validate for ImpliedCurrencyAndAmount {
    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:seev.031.001.16")]
pub struct IndicativeOrMarketPrice12Choice {
    #[yaserde(rename = "IndctvPric")]
    #[cfg_attr(feature = "serde", serde(rename = "IndctvPric"))]
    pub indctv_pric: Option<PriceFormat74Choice>,
    #[yaserde(rename = "MktPric")]
    #[cfg_attr(feature = "serde", serde(rename = "MktPric"))]
    pub mkt_pric: Option<PriceFormat74Choice>,
}

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

impl Validate for InformationTypeFormat4Choice {}




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

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

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

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

impl Validate for InterestComputationMethodFormat4Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct InterestRateUsedForPaymentFormat11Choice {
    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: Option<Percentage14Rate>,
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<ActiveCurrencyAnd13DecimalAmount>,
    #[yaserde(rename = "RateTpAndAmtAndRateSts")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTpAndAmtAndRateSts"))]
    pub rate_tp_and_amt_and_rate_sts: Option<RateTypeAndAmountAndStatus24>,
    #[yaserde(rename = "NotSpcfdRate")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdRate"))]
    pub not_spcfd_rate: Option<RateType13Code>,
}

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

impl Validate for IntermediateSecuritiesDistributionTypeFormat19Choice {}




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

pub enum IntermediateSecurityDistributionType6Code {
    #[yaserde(rename = "BIDS")]
    #[cfg_attr(feature = "serde", serde(rename = "BIDS"))]
    Bids,
    #[yaserde(rename = "DRIP")]
    #[cfg_attr(feature = "serde", serde(rename = "DRIP"))]
    Drip,
    #[yaserde(rename = "DVCA")]
    #[cfg_attr(feature = "serde", serde(rename = "DVCA"))]
    Dvca,
    #[yaserde(rename = "DVOP")]
    #[cfg_attr(feature = "serde", serde(rename = "DVOP"))]
    Dvop,
    #[yaserde(rename = "EXRI")]
    #[cfg_attr(feature = "serde", serde(rename = "EXRI"))]
    Exri,
    #[yaserde(rename = "PRIO")]
    #[cfg_attr(feature = "serde", serde(rename = "PRIO"))]
    Prio,
    #[yaserde(rename = "DVSC")]
    #[cfg_attr(feature = "serde", serde(rename = "DVSC"))]
    Dvsc,
    #[yaserde(rename = "DVSE")]
    #[cfg_attr(feature = "serde", serde(rename = "DVSE"))]
    Dvse,
    #[yaserde(rename = "INTR")]
    #[cfg_attr(feature = "serde", serde(rename = "INTR"))]
    Intr,
    #[yaserde(rename = "LIQU")]
    #[cfg_attr(feature = "serde", serde(rename = "LIQU"))]
    Liqu,
    #[yaserde(rename = "SOFF")]
    #[cfg_attr(feature = "serde", serde(rename = "SOFF"))]
    Soff,
    #[yaserde(rename = "SPLF")]
    #[cfg_attr(feature = "serde", serde(rename = "SPLF"))]
    Splf,
    #[yaserde(rename = "BONU")]
    #[cfg_attr(feature = "serde", serde(rename = "BONU"))]
    Bonu,
    #[yaserde(rename = "EXOF")]
    #[cfg_attr(feature = "serde", serde(rename = "EXOF"))]
    Exof,
    #[yaserde(rename = "MRGR")]
    #[cfg_attr(feature = "serde", serde(rename = "MRGR"))]
    Mrgr,
    #[yaserde(rename = "UKWN")]
    #[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
    Ukwn,
    __Unknown__(String),
}

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

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

impl Validate for IssuerOfferorTaxabilityIndicator2Choice {}




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

pub enum IssuerTaxability2Code {
    #[yaserde(rename = "TXBL")]
    #[cfg_attr(feature = "serde", serde(rename = "TXBL"))]
    Txbl,
    __Unknown__(String),
}

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

impl Validate for IssuerTaxability2Code {}



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

pub enum LotteryType1Code {
    #[yaserde(rename = "ORIG")]
    #[cfg_attr(feature = "serde", serde(rename = "ORIG"))]
    Orig,
    #[yaserde(rename = "SUPP")]
    #[cfg_attr(feature = "serde", serde(rename = "SUPP"))]
    Supp,
    __Unknown__(String),
}

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

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

impl Validate for LotteryTypeFormat4Choice {}




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

impl Validate for Micidentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct MarketIdentification3Choice {
    #[yaserde(rename = "MktIdrCd")]
    #[cfg_attr(feature = "serde", serde(rename = "MktIdrCd"))]
    pub mkt_idr_cd: Option<Micidentifier>,
    #[yaserde(rename = "Desc")]
    #[cfg_attr(feature = "serde", serde(rename = "Desc"))]
    pub desc: Option<Max35Text>,
}

impl Validate for MarketIdentification3Choice {}




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

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

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

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

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

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

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

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

impl Validate for Max30Text {
    fn validate(&self) -> Result<(), String> { 
        if self.0.len() > 30 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 30 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

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

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

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

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

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

impl Validate for Max8000Text {
    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() > 8000 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 8000 \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:seev.031.001.16")]
pub struct NameAndAddress5 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max350Text,

    #[yaserde(rename = "Adr")]
    #[cfg_attr(feature = "serde", serde(rename = "Adr"))]
    pub adr: PostalAddress1,
}

impl Validate for NameAndAddress5 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct NetDividendRateFormat38Choice {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<ActiveCurrencyAnd13DecimalAmount>,
    #[yaserde(rename = "AmtAndRateSts")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtAndRateSts"))]
    pub amt_and_rate_sts: Option<AmountAndRateStatus1>,
    #[yaserde(rename = "RateTpAndAmtAndRateSts")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTpAndAmtAndRateSts"))]
    pub rate_tp_and_amt_and_rate_sts: Option<RateTypeAndAmountAndStatus56>,
    #[yaserde(rename = "NotSpcfdRate")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdRate"))]
    pub not_spcfd_rate: Option<RateValueType7Code>,
}

impl Validate for NetDividendRateFormat38Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct NetDividendRateFormat39Choice {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<ActiveCurrencyAnd13DecimalAmount>,
    #[yaserde(rename = "AmtAndRateSts")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtAndRateSts"))]
    pub amt_and_rate_sts: Option<AmountAndRateStatus1>,
    #[yaserde(rename = "RateTpAndAmtAndRateSts")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTpAndAmtAndRateSts"))]
    pub rate_tp_and_amt_and_rate_sts: Option<RateTypeAndAmountAndStatus58>,
    #[yaserde(rename = "NotSpcfdRate")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdRate"))]
    pub not_spcfd_rate: Option<RateValueType7Code>,
}

impl Validate for NetDividendRateFormat39Choice {}




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

pub enum NetDividendRateType6Code {
    #[yaserde(rename = "CAPO")]
    #[cfg_attr(feature = "serde", serde(rename = "CAPO"))]
    Capo,
    #[yaserde(rename = "CDFI")]
    #[cfg_attr(feature = "serde", serde(rename = "CDFI"))]
    Cdfi,
    #[yaserde(rename = "FLFR")]
    #[cfg_attr(feature = "serde", serde(rename = "FLFR"))]
    Flfr,
    #[yaserde(rename = "INCO")]
    #[cfg_attr(feature = "serde", serde(rename = "INCO"))]
    Inco,
    #[yaserde(rename = "INTR")]
    #[cfg_attr(feature = "serde", serde(rename = "INTR"))]
    Intr,
    #[yaserde(rename = "REES")]
    #[cfg_attr(feature = "serde", serde(rename = "REES"))]
    Rees,
    #[yaserde(rename = "SOIC")]
    #[cfg_attr(feature = "serde", serde(rename = "SOIC"))]
    Soic,
    #[yaserde(rename = "TXBL")]
    #[cfg_attr(feature = "serde", serde(rename = "TXBL"))]
    Txbl,
    #[yaserde(rename = "TXDF")]
    #[cfg_attr(feature = "serde", serde(rename = "TXDF"))]
    Txdf,
    #[yaserde(rename = "TXFR")]
    #[cfg_attr(feature = "serde", serde(rename = "TXFR"))]
    Txfr,
    #[yaserde(rename = "UNFR")]
    #[cfg_attr(feature = "serde", serde(rename = "UNFR"))]
    Unfr,
    __Unknown__(String),
}

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

impl Validate for NetDividendRateType6Code {}



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

pub enum NetDividendRateType7Code {
    #[yaserde(rename = "CAPO")]
    #[cfg_attr(feature = "serde", serde(rename = "CAPO"))]
    Capo,
    #[yaserde(rename = "CDFI")]
    #[cfg_attr(feature = "serde", serde(rename = "CDFI"))]
    Cdfi,
    #[yaserde(rename = "FUPU")]
    #[cfg_attr(feature = "serde", serde(rename = "FUPU"))]
    Fupu,
    #[yaserde(rename = "FLFR")]
    #[cfg_attr(feature = "serde", serde(rename = "FLFR"))]
    Flfr,
    #[yaserde(rename = "INCO")]
    #[cfg_attr(feature = "serde", serde(rename = "INCO"))]
    Inco,
    #[yaserde(rename = "INTR")]
    #[cfg_attr(feature = "serde", serde(rename = "INTR"))]
    Intr,
    #[yaserde(rename = "SOIC")]
    #[cfg_attr(feature = "serde", serde(rename = "SOIC"))]
    Soic,
    #[yaserde(rename = "TXBL")]
    #[cfg_attr(feature = "serde", serde(rename = "TXBL"))]
    Txbl,
    #[yaserde(rename = "TXDF")]
    #[cfg_attr(feature = "serde", serde(rename = "TXDF"))]
    Txdf,
    #[yaserde(rename = "TXFR")]
    #[cfg_attr(feature = "serde", serde(rename = "TXFR"))]
    Txfr,
    #[yaserde(rename = "UNFR")]
    #[cfg_attr(feature = "serde", serde(rename = "UNFR"))]
    Unfr,
    #[yaserde(rename = "PAPU")]
    #[cfg_attr(feature = "serde", serde(rename = "PAPU"))]
    Papu,
    #[yaserde(rename = "REES")]
    #[cfg_attr(feature = "serde", serde(rename = "REES"))]
    Rees,
    __Unknown__(String),
}

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

impl Validate for NetDividendRateType7Code {}



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

pub enum NewSecuritiesIssuanceType5Code {
    #[yaserde(rename = "DEFE")]
    #[cfg_attr(feature = "serde", serde(rename = "DEFE"))]
    Defe,
    #[yaserde(rename = "EXIS")]
    #[cfg_attr(feature = "serde", serde(rename = "EXIS"))]
    Exis,
    #[yaserde(rename = "NEIS")]
    #[cfg_attr(feature = "serde", serde(rename = "NEIS"))]
    Neis,
    #[yaserde(rename = "NDEF")]
    #[cfg_attr(feature = "serde", serde(rename = "NDEF"))]
    Ndef,
    #[yaserde(rename = "UKWN")]
    #[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
    Ukwn,
    #[yaserde(rename = "NREF")]
    #[cfg_attr(feature = "serde", serde(rename = "NREF"))]
    Nref,
    #[yaserde(rename = "REFU")]
    #[cfg_attr(feature = "serde", serde(rename = "REFU"))]
    Refu,
    __Unknown__(String),
}

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

impl Validate for NewSecuritiesIssuanceType5Code {}



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

pub enum NonEligibleProceedsIndicator2Code {
    #[yaserde(rename = "NELC")]
    #[cfg_attr(feature = "serde", serde(rename = "NELC"))]
    Nelc,
    #[yaserde(rename = "ACLI")]
    #[cfg_attr(feature = "serde", serde(rename = "ACLI"))]
    Acli,
    #[yaserde(rename = "ONEL")]
    #[cfg_attr(feature = "serde", serde(rename = "ONEL"))]
    Onel,
    #[yaserde(rename = "NELS")]
    #[cfg_attr(feature = "serde", serde(rename = "NELS"))]
    Nels,
    __Unknown__(String),
}

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

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

impl Validate for NonEligibleProceedsIndicator5Choice {}




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

pub enum OfferType7Code {
    #[yaserde(rename = "DISS")]
    #[cfg_attr(feature = "serde", serde(rename = "DISS"))]
    Diss,
    #[yaserde(rename = "ERUN")]
    #[cfg_attr(feature = "serde", serde(rename = "ERUN"))]
    Erun,
    #[yaserde(rename = "FINL")]
    #[cfg_attr(feature = "serde", serde(rename = "FINL"))]
    Finl,
    #[yaserde(rename = "PART")]
    #[cfg_attr(feature = "serde", serde(rename = "PART"))]
    Part,
    #[yaserde(rename = "SQUE")]
    #[cfg_attr(feature = "serde", serde(rename = "SQUE"))]
    Sque,
    #[yaserde(rename = "NDIS")]
    #[cfg_attr(feature = "serde", serde(rename = "NDIS"))]
    Ndis,
    #[yaserde(rename = "ACPR")]
    #[cfg_attr(feature = "serde", serde(rename = "ACPR"))]
    Acpr,
    __Unknown__(String),
}

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

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

impl Validate for OfferTypeFormat18Choice {}




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

pub enum OptionAvailabilityStatus1Code {
    #[yaserde(rename = "INTV")]
    #[cfg_attr(feature = "serde", serde(rename = "INTV"))]
    Intv,
    #[yaserde(rename = "CANC")]
    #[cfg_attr(feature = "serde", serde(rename = "CANC"))]
    Canc,
    __Unknown__(String),
}

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

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

impl Validate for OptionAvailabilityStatus3Choice {}




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

pub enum OptionFeatures15Code {
    #[yaserde(rename = "NOSE")]
    #[cfg_attr(feature = "serde", serde(rename = "NOSE"))]
    Nose,
    #[yaserde(rename = "CAOS")]
    #[cfg_attr(feature = "serde", serde(rename = "CAOS"))]
    Caos,
    #[yaserde(rename = "COND")]
    #[cfg_attr(feature = "serde", serde(rename = "COND"))]
    Cond,
    #[yaserde(rename = "MAXC")]
    #[cfg_attr(feature = "serde", serde(rename = "MAXC"))]
    Maxc,
    #[yaserde(rename = "MAXS")]
    #[cfg_attr(feature = "serde", serde(rename = "MAXS"))]
    Maxs,
    #[yaserde(rename = "OPLF")]
    #[cfg_attr(feature = "serde", serde(rename = "OPLF"))]
    Oplf,
    #[yaserde(rename = "PROR")]
    #[cfg_attr(feature = "serde", serde(rename = "PROR"))]
    Pror,
    #[yaserde(rename = "VVPR")]
    #[cfg_attr(feature = "serde", serde(rename = "VVPR"))]
    Vvpr,
    #[yaserde(rename = "PINS")]
    #[cfg_attr(feature = "serde", serde(rename = "PINS"))]
    Pins,
    #[yaserde(rename = "ASVO")]
    #[cfg_attr(feature = "serde", serde(rename = "ASVO"))]
    Asvo,
    #[yaserde(rename = "BOIS")]
    #[cfg_attr(feature = "serde", serde(rename = "BOIS"))]
    Bois,
    #[yaserde(rename = "QCAS")]
    #[cfg_attr(feature = "serde", serde(rename = "QCAS"))]
    Qcas,
    #[yaserde(rename = "SHAR")]
    #[cfg_attr(feature = "serde", serde(rename = "SHAR"))]
    Shar,
    #[yaserde(rename = "RGRS")]
    #[cfg_attr(feature = "serde", serde(rename = "RGRS"))]
    Rgrs,
    #[yaserde(rename = "RNET")]
    #[cfg_attr(feature = "serde", serde(rename = "RNET"))]
    Rnet,
    #[yaserde(rename = "FCFS")]
    #[cfg_attr(feature = "serde", serde(rename = "FCFS"))]
    Fcfs,
    __Unknown__(String),
}

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

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

impl Validate for OptionFeaturesFormat32Choice {}




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

pub enum OptionStyle2Code {
    #[yaserde(rename = "AMER")]
    #[cfg_attr(feature = "serde", serde(rename = "AMER"))]
    Amer,
    #[yaserde(rename = "EURO")]
    #[cfg_attr(feature = "serde", serde(rename = "EURO"))]
    Euro,
    __Unknown__(String),
}

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

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

impl Validate for OptionStyle8Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct OriginalAndCurrentQuantities1 {
    #[yaserde(rename = "FaceAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "FaceAmt"))]
    pub face_amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "AmtsdVal")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtsdVal"))]
    pub amtsd_val: ImpliedCurrencyAndAmount,
}

impl Validate for OriginalAndCurrentQuantities1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct OriginalAndCurrentQuantities6 {
    #[yaserde(rename = "ShrtLngPos")]
    #[cfg_attr(feature = "serde", serde(rename = "ShrtLngPos"))]
    pub shrt_lng_pos: ShortLong1Code,

    #[yaserde(rename = "FaceAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "FaceAmt"))]
    pub face_amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "AmtsdVal")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtsdVal"))]
    pub amtsd_val: ImpliedCurrencyAndAmount,
}

impl Validate for OriginalAndCurrentQuantities6 {}


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

    #[yaserde(rename = "Sfx")]
    #[cfg_attr(feature = "serde", serde(rename = "Sfx"))]
    pub sfx: Max16Text,

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

impl Validate for OtherIdentification1 {}


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

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

impl Validate for Pagination1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct PartyIdentification120Choice {
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_b_i_c: Option<AnyBICDec2014Identifier>,
    #[yaserde(rename = "PrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
    pub prtry_id: Option<GenericIdentification36>,
    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: Option<NameAndAddress5>,
}

impl Validate for PartyIdentification120Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct PartyIdentification127Choice {
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_b_i_c: Option<AnyBICDec2014Identifier>,
    #[yaserde(rename = "PrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
    pub prtry_id: Option<GenericIdentification36>,
}

impl Validate for PartyIdentification127Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct PartyIdentification129Choice {
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_b_i_c: Option<AnyBICDec2014Identifier>,
    #[yaserde(rename = "PrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
    pub prtry_id: Option<GenericIdentification36>,
    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: Option<NameAndAddress5>,
    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Option<Leiidentifier>,
}

impl Validate for PartyIdentification129Choice {}




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

pub enum Payment2Code {
    #[yaserde(rename = "ACTU")]
    #[cfg_attr(feature = "serde", serde(rename = "ACTU"))]
    Actu,
    __Unknown__(String),
}

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

impl Validate for Payment2Code {}



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

impl Validate for Percentage14Rate {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct PercentagePrice2 {
    #[yaserde(rename = "PctgPricTp")]
    #[cfg_attr(feature = "serde", serde(rename = "PctgPricTp"))]
    pub pctg_pric_tp: PriceRateType3Code,

    #[yaserde(rename = "PricVal")]
    #[cfg_attr(feature = "serde", serde(rename = "PricVal"))]
    pub pric_val: Percentage14Rate,
}

impl Validate for PercentagePrice2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct Period11 {
    #[yaserde(rename = "StartDt")]
    #[cfg_attr(feature = "serde", serde(rename = "StartDt"))]
    pub start_dt: DateFormat45Choice,

    #[yaserde(rename = "EndDt")]
    #[cfg_attr(feature = "serde", serde(rename = "EndDt"))]
    pub end_dt: DateFormat45Choice,
}

impl Validate for Period11 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct Period12Choice {
    #[yaserde(rename = "Prd")]
    #[cfg_attr(feature = "serde", serde(rename = "Prd"))]
    pub prd: Option<Period18>,
    #[yaserde(rename = "PrdCd")]
    #[cfg_attr(feature = "serde", serde(rename = "PrdCd"))]
    pub prd_cd: Option<DateType8Code>,
}

impl Validate for Period12Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct Period18 {
    #[yaserde(rename = "StartDt")]
    #[cfg_attr(feature = "serde", serde(rename = "StartDt"))]
    pub start_dt: DateFormat73Choice,

    #[yaserde(rename = "EndDt")]
    #[cfg_attr(feature = "serde", serde(rename = "EndDt"))]
    pub end_dt: DateFormat73Choice,
}

impl Validate for Period18 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct Period6Choice {
    #[yaserde(rename = "Prd")]
    #[cfg_attr(feature = "serde", serde(rename = "Prd"))]
    pub prd: Option<Period11>,
    #[yaserde(rename = "PrdCd")]
    #[cfg_attr(feature = "serde", serde(rename = "PrdCd"))]
    pub prd_cd: Option<DateType8Code>,
}

impl Validate for Period6Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct PostalAddress1 {
    #[yaserde(rename = "AdrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "AdrTp"))]
    pub adr_tp: AddressType2Code,

    #[yaserde(rename = "AdrLine")]
    #[cfg_attr(feature = "serde", serde(rename = "AdrLine"))]
    pub adr_line: Vec<Max70Text>,

    #[yaserde(rename = "StrtNm")]
    #[cfg_attr(feature = "serde", serde(rename = "StrtNm"))]
    pub strt_nm: Max70Text,

    #[yaserde(rename = "BldgNb")]
    #[cfg_attr(feature = "serde", serde(rename = "BldgNb"))]
    pub bldg_nb: Max16Text,

    #[yaserde(rename = "PstCd")]
    #[cfg_attr(feature = "serde", serde(rename = "PstCd"))]
    pub pst_cd: Max16Text,

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

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

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

impl Validate for PostalAddress1 {}


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

pub enum PriceCalculationMethod1Code {
    #[yaserde(rename = "VWAP")]
    #[cfg_attr(feature = "serde", serde(rename = "VWAP"))]
    Vwap,
    #[yaserde(rename = "NAVF")]
    #[cfg_attr(feature = "serde", serde(rename = "NAVF"))]
    Navf,
    #[yaserde(rename = "MIMP")]
    #[cfg_attr(feature = "serde", serde(rename = "MIMP"))]
    Mimp,
    #[yaserde(rename = "NAVA")]
    #[cfg_attr(feature = "serde", serde(rename = "NAVA"))]
    Nava,
    #[yaserde(rename = "AVCL")]
    #[cfg_attr(feature = "serde", serde(rename = "AVCL"))]
    Avcl,
    __Unknown__(String),
}

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

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

impl Validate for PriceCalculationMethod2Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct PriceDetails38 {
    #[yaserde(rename = "GncCshPricPdPerPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "GncCshPricPdPerPdct"))]
    pub gnc_csh_pric_pd_per_pdct: PriceFormat73Choice,

    #[yaserde(rename = "GncCshPricRcvdPerPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "GncCshPricRcvdPerPdct"))]
    pub gnc_csh_pric_rcvd_per_pdct: PriceFormat72Choice,

    #[yaserde(rename = "CshInLieuOfShrPric")]
    #[cfg_attr(feature = "serde", serde(rename = "CshInLieuOfShrPric"))]
    pub csh_in_lieu_of_shr_pric: PriceFormat74Choice,
}

impl Validate for PriceDetails38 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct PriceFormat46Choice {
    #[yaserde(rename = "AmtPric")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtPric"))]
    pub amt_pric: Option<AmountPrice2>,
    #[yaserde(rename = "NotSpcfdPric")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdPric"))]
    pub not_spcfd_pric: Option<PriceValueType10Code>,
}

impl Validate for PriceFormat46Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct PriceFormat61Choice {
    #[yaserde(rename = "AmtPric")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtPric"))]
    pub amt_pric: Option<AmountPrice6>,
    #[yaserde(rename = "NotSpcfdPric")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdPric"))]
    pub not_spcfd_pric: Option<PriceValueType10Code>,
}

impl Validate for PriceFormat61Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct PriceFormat72Choice {
    #[yaserde(rename = "PctgPric")]
    #[cfg_attr(feature = "serde", serde(rename = "PctgPric"))]
    pub pctg_pric: Option<PercentagePrice2>,
    #[yaserde(rename = "AmtPric")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtPric"))]
    pub amt_pric: Option<AmountPrice3>,
    #[yaserde(rename = "NotSpcfdPric")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdPric"))]
    pub not_spcfd_pric: Option<PriceValueType8Code>,
    #[yaserde(rename = "AmtPricPerFinInstrmQty")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtPricPerFinInstrmQty"))]
    pub amt_pric_per_fin_instrm_qty: Option<AmountPricePerFinancialInstrumentQuantity10>,
    #[yaserde(rename = "AmtPricPerAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtPricPerAmt"))]
    pub amt_pric_per_amt: Option<AmountPricePerAmount2>,
    #[yaserde(rename = "IndxPts")]
    #[cfg_attr(feature = "serde", serde(rename = "IndxPts"))]
    pub indx_pts: Option<DecimalNumber>,
}

impl Validate for PriceFormat72Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct PriceFormat73Choice {
    #[yaserde(rename = "PctgPric")]
    #[cfg_attr(feature = "serde", serde(rename = "PctgPric"))]
    pub pctg_pric: Option<PercentagePrice2>,
    #[yaserde(rename = "AmtPric")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtPric"))]
    pub amt_pric: Option<AmountPrice3>,
    #[yaserde(rename = "NotSpcfdPric")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdPric"))]
    pub not_spcfd_pric: Option<PriceValueType10Code>,
    #[yaserde(rename = "IndxPts")]
    #[cfg_attr(feature = "serde", serde(rename = "IndxPts"))]
    pub indx_pts: Option<DecimalNumber>,
}

impl Validate for PriceFormat73Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct PriceFormat74Choice {
    #[yaserde(rename = "PctgPric")]
    #[cfg_attr(feature = "serde", serde(rename = "PctgPric"))]
    pub pctg_pric: Option<PercentagePrice2>,
    #[yaserde(rename = "AmtPric")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtPric"))]
    pub amt_pric: Option<AmountPrice3>,
    #[yaserde(rename = "NotSpcfdPric")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdPric"))]
    pub not_spcfd_pric: Option<PriceValueType10Code>,
}

impl Validate for PriceFormat74Choice {}




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

pub enum PriceRateType3Code {
    #[yaserde(rename = "DISC")]
    #[cfg_attr(feature = "serde", serde(rename = "DISC"))]
    Disc,
    #[yaserde(rename = "PREM")]
    #[cfg_attr(feature = "serde", serde(rename = "PREM"))]
    Prem,
    #[yaserde(rename = "PRCT")]
    #[cfg_attr(feature = "serde", serde(rename = "PRCT"))]
    Prct,
    #[yaserde(rename = "YIEL")]
    #[cfg_attr(feature = "serde", serde(rename = "YIEL"))]
    Yiel,
    __Unknown__(String),
}

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

impl Validate for PriceRateType3Code {}



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

pub enum PriceValueType10Code {
    #[yaserde(rename = "UKWN")]
    #[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
    Ukwn,
    __Unknown__(String),
}

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

impl Validate for PriceValueType10Code {}



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

pub enum PriceValueType8Code {
    #[yaserde(rename = "TBSP")]
    #[cfg_attr(feature = "serde", serde(rename = "TBSP"))]
    Tbsp,
    #[yaserde(rename = "UNSP")]
    #[cfg_attr(feature = "serde", serde(rename = "UNSP"))]
    Unsp,
    #[yaserde(rename = "UKWN")]
    #[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
    Ukwn,
    #[yaserde(rename = "NILP")]
    #[cfg_attr(feature = "serde", serde(rename = "NILP"))]
    Nilp,
    __Unknown__(String),
}

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

impl Validate for PriceValueType8Code {}



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

pub enum ProcessingPosition3Code {
    #[yaserde(rename = "AFTE")]
    #[cfg_attr(feature = "serde", serde(rename = "AFTE"))]
    Afte,
    #[yaserde(rename = "WITH")]
    #[cfg_attr(feature = "serde", serde(rename = "WITH"))]
    With,
    #[yaserde(rename = "BEFO")]
    #[cfg_attr(feature = "serde", serde(rename = "BEFO"))]
    Befo,
    #[yaserde(rename = "INFO")]
    #[cfg_attr(feature = "serde", serde(rename = "INFO"))]
    Info,
    __Unknown__(String),
}

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

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

impl Validate for ProcessingPosition7Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct ProprietaryQuantity7 {
    #[yaserde(rename = "ShrtLngPos")]
    #[cfg_attr(feature = "serde", serde(rename = "ShrtLngPos"))]
    pub shrt_lng_pos: ShortLong1Code,

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

    #[yaserde(rename = "QtyTp")]
    #[cfg_attr(feature = "serde", serde(rename = "QtyTp"))]
    pub qty_tp: Exact4AlphaNumericText,

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

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

impl Validate for ProprietaryQuantity7 {}


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

    #[yaserde(rename = "QtyTp")]
    #[cfg_attr(feature = "serde", serde(rename = "QtyTp"))]
    pub qty_tp: Exact4AlphaNumericText,

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

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

impl Validate for ProprietaryQuantity8 {}


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

pub enum ProrationBelowMinimumQuantity2Code {
    #[yaserde(rename = "FULL")]
    #[cfg_attr(feature = "serde", serde(rename = "FULL"))]
    Full,
    #[yaserde(rename = "MIEX")]
    #[cfg_attr(feature = "serde", serde(rename = "MIEX"))]
    Miex,
    #[yaserde(rename = "REJT")]
    #[cfg_attr(feature = "serde", serde(rename = "REJT"))]
    Rejt,
    #[yaserde(rename = "MILD")]
    #[cfg_attr(feature = "serde", serde(rename = "MILD"))]
    Mild,
    #[yaserde(rename = "MILU")]
    #[cfg_attr(feature = "serde", serde(rename = "MILU"))]
    Milu,
    #[yaserde(rename = "UKWN")]
    #[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
    Ukwn,
    __Unknown__(String),
}

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

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

impl Validate for ProrationBelowMinimumQuantity3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct Quantity48Choice {
    #[yaserde(rename = "Qty")]
    #[cfg_attr(feature = "serde", serde(rename = "Qty"))]
    pub qty: Option<FinancialInstrumentQuantity33Choice>,
    #[yaserde(rename = "PrtryQty")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryQty"))]
    pub prtry_qty: Option<ProprietaryQuantity8>,
}

impl Validate for Quantity48Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct Quantity49Choice {
    #[yaserde(rename = "QtyChc")]
    #[cfg_attr(feature = "serde", serde(rename = "QtyChc"))]
    pub qty_chc: Option<Quantity50Choice>,
    #[yaserde(rename = "PrtryQty")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryQty"))]
    pub prtry_qty: Option<ProprietaryQuantity7>,
}

impl Validate for Quantity49Choice {}




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

pub enum Quantity4Code {
    #[yaserde(rename = "UKWN")]
    #[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
    Ukwn,
    #[yaserde(rename = "ANYA")]
    #[cfg_attr(feature = "serde", serde(rename = "ANYA"))]
    Anya,
    __Unknown__(String),
}

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

impl Validate for Quantity4Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct Quantity50Choice {
    #[yaserde(rename = "OrgnlAndCurFaceAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlAndCurFaceAmt"))]
    pub orgnl_and_cur_face_amt: Option<OriginalAndCurrentQuantities6>,
    #[yaserde(rename = "SgndQty")]
    #[cfg_attr(feature = "serde", serde(rename = "SgndQty"))]
    pub sgnd_qty: Option<SignedQuantityFormat10>,
}

impl Validate for Quantity50Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct Quantity51Choice {
    #[yaserde(rename = "Qty")]
    #[cfg_attr(feature = "serde", serde(rename = "Qty"))]
    pub qty: Option<FinancialInstrumentQuantity33Choice>,
    #[yaserde(rename = "OrgnlAndCurFace")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlAndCurFace"))]
    pub orgnl_and_cur_face: Option<OriginalAndCurrentQuantities1>,
}

impl Validate for Quantity51Choice {}




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

pub enum Quantity5Code {
    #[yaserde(rename = "UKWN")]
    #[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
    Ukwn,
    __Unknown__(String),
}

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

impl Validate for Quantity5Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct QuantityToQuantityRatio1 {
    #[yaserde(rename = "Qty1")]
    #[cfg_attr(feature = "serde", serde(rename = "Qty1"))]
    pub qty_1: DecimalNumber,

    #[yaserde(rename = "Qty2")]
    #[cfg_attr(feature = "serde", serde(rename = "Qty2"))]
    pub qty_2: DecimalNumber,
}

impl Validate for QuantityToQuantityRatio1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct Rate48 {
    #[yaserde(rename = "AddtlTax")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlTax"))]
    pub addtl_tax: RateAndAmountFormat57Choice,

    #[yaserde(rename = "GrssDstrbtnRate")]
    #[cfg_attr(feature = "serde", serde(rename = "GrssDstrbtnRate"))]
    pub grss_dstrbtn_rate: Vec<GrossDividendRateFormat38Choice>,

    #[yaserde(rename = "GrssIntrstRateUsdForPmt")]
    #[cfg_attr(feature = "serde", serde(rename = "GrssIntrstRateUsdForPmt"))]
    pub grss_intrst_rate_usd_for_pmt: Vec<InterestRateUsedForPaymentFormat11Choice>,

    #[yaserde(rename = "WhldgTaxRate")]
    #[cfg_attr(feature = "serde", serde(rename = "WhldgTaxRate"))]
    pub whldg_tax_rate: Vec<RateAndAmountFormat60Choice>,

    #[yaserde(rename = "ScndLvlTax")]
    #[cfg_attr(feature = "serde", serde(rename = "ScndLvlTax"))]
    pub scnd_lvl_tax: Vec<RateAndAmountFormat60Choice>,

    #[yaserde(rename = "ChrgsFees")]
    #[cfg_attr(feature = "serde", serde(rename = "ChrgsFees"))]
    pub chrgs_fees: RateAndAmountFormat57Choice,

    #[yaserde(rename = "EarlySlctnFeeRate")]
    #[cfg_attr(feature = "serde", serde(rename = "EarlySlctnFeeRate"))]
    pub early_slctn_fee_rate: SolicitationFeeRateFormat11Choice,

    #[yaserde(rename = "FsclStmp")]
    #[cfg_attr(feature = "serde", serde(rename = "FsclStmp"))]
    pub fscl_stmp: RateFormat24Choice,

    #[yaserde(rename = "ThrdPtyIncntivRate")]
    #[cfg_attr(feature = "serde", serde(rename = "ThrdPtyIncntivRate"))]
    pub thrd_pty_incntiv_rate: RateFormat26Choice,

    #[yaserde(rename = "NetDstrbtnRate")]
    #[cfg_attr(feature = "serde", serde(rename = "NetDstrbtnRate"))]
    pub net_dstrbtn_rate: Vec<NetDividendRateFormat39Choice>,

    #[yaserde(rename = "AplblRate")]
    #[cfg_attr(feature = "serde", serde(rename = "AplblRate"))]
    pub aplbl_rate: RateFormat31Choice,

    #[yaserde(rename = "SlctnFeeRate")]
    #[cfg_attr(feature = "serde", serde(rename = "SlctnFeeRate"))]
    pub slctn_fee_rate: SolicitationFeeRateFormat11Choice,

    #[yaserde(rename = "TaxCdtRate")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxCdtRate"))]
    pub tax_cdt_rate: RateFormat26Choice,

    #[yaserde(rename = "TaxOnIncm")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxOnIncm"))]
    pub tax_on_incm: RateAndAmountFormat57Choice,

    #[yaserde(rename = "TaxOnPrfts")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxOnPrfts"))]
    pub tax_on_prfts: RateFormat24Choice,

    #[yaserde(rename = "TaxRclmRate")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxRclmRate"))]
    pub tax_rclm_rate: RateFormat24Choice,

    #[yaserde(rename = "EqulstnRate")]
    #[cfg_attr(feature = "serde", serde(rename = "EqulstnRate"))]
    pub equlstn_rate: RateAndAmountFormat42Choice,

    #[yaserde(rename = "DmdRate")]
    #[cfg_attr(feature = "serde", serde(rename = "DmdRate"))]
    pub dmd_rate: Vec<RateAndAmountFormat61Choice>,
}

impl Validate for Rate48 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct RateAndAmountFormat42Choice {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<ActiveCurrencyAnd13DecimalAmount>,
    #[yaserde(rename = "NotSpcfdRate")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdRate"))]
    pub not_spcfd_rate: Option<RateValueType7Code>,
}

impl Validate for RateAndAmountFormat42Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct RateAndAmountFormat56Choice {
    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: Option<Percentage14Rate>,
    #[yaserde(rename = "NotSpcfdRate")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdRate"))]
    pub not_spcfd_rate: Option<RateValueType7Code>,
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<ActiveCurrencyAnd13DecimalAmount>,
    #[yaserde(rename = "RateTpAndRate")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTpAndRate"))]
    pub rate_tp_and_rate: Option<RateTypeAndPercentageRate12>,
}

impl Validate for RateAndAmountFormat56Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct RateAndAmountFormat57Choice {
    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: Option<Percentage14Rate>,
    #[yaserde(rename = "NotSpcfdRate")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdRate"))]
    pub not_spcfd_rate: Option<RateValueType7Code>,
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<ActiveCurrencyAnd13DecimalAmount>,
}

impl Validate for RateAndAmountFormat57Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct RateAndAmountFormat58Choice {
    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: Option<Percentage14Rate>,
    #[yaserde(rename = "NotSpcfdRate")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdRate"))]
    pub not_spcfd_rate: Option<RateValueType7Code>,
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<ActiveCurrencyAnd13DecimalAmount>,
    #[yaserde(rename = "IndxPts")]
    #[cfg_attr(feature = "serde", serde(rename = "IndxPts"))]
    pub indx_pts: Option<DecimalNumber>,
}

impl Validate for RateAndAmountFormat58Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct RateAndAmountFormat59Choice {
    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: Option<Percentage14Rate>,
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<ActiveCurrencyAnd13DecimalAmount>,
}

impl Validate for RateAndAmountFormat59Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct RateAndAmountFormat60Choice {
    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: Option<Percentage14Rate>,
    #[yaserde(rename = "NotSpcfdRate")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdRate"))]
    pub not_spcfd_rate: Option<RateValueType7Code>,
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<ActiveCurrencyAnd13DecimalAmount>,
    #[yaserde(rename = "RateTpAndRate")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTpAndRate"))]
    pub rate_tp_and_rate: Option<RateTypeAndPercentageRate13>,
}

impl Validate for RateAndAmountFormat60Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct RateAndAmountFormat61Choice {
    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: Option<Percentage14Rate>,
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<ActiveCurrencyAnd13DecimalAmount>,
    #[yaserde(rename = "NotSpcfdRate")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdRate"))]
    pub not_spcfd_rate: Option<RateValueType7Code>,
    #[yaserde(rename = "RateTpAndAmtAndRateSts")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTpAndAmtAndRateSts"))]
    pub rate_tp_and_amt_and_rate_sts: Option<RateTypeAndAmountAndStatus37>,
    #[yaserde(rename = "RateTpAndRate")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTpAndRate"))]
    pub rate_tp_and_rate: Option<RateTypeAndPercentageRate14>,
}

impl Validate for RateAndAmountFormat61Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct RateFormat12Choice {
    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: Option<BaseOne14Rate>,
    #[yaserde(rename = "NotSpcfdRate")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdRate"))]
    pub not_spcfd_rate: Option<RateType5Code>,
}

impl Validate for RateFormat12Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct RateFormat24Choice {
    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: Option<Percentage14Rate>,
    #[yaserde(rename = "NotSpcfdRate")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdRate"))]
    pub not_spcfd_rate: Option<RateType5Code>,
}

impl Validate for RateFormat24Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct RateFormat25Choice {
    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: Option<Percentage14Rate>,
    #[yaserde(rename = "NotSpcfdRate")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdRate"))]
    pub not_spcfd_rate: Option<RateType10Code>,
}

impl Validate for RateFormat25Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct RateFormat26Choice {
    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: Option<Percentage14Rate>,
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<ActiveCurrencyAnd13DecimalAmount>,
    #[yaserde(rename = "NotSpcfdRate")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdRate"))]
    pub not_spcfd_rate: Option<RateValueType7Code>,
}

impl Validate for RateFormat26Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct RateFormat31Choice {
    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: Option<Percentage14Rate>,
    #[yaserde(rename = "NotSpcfdRate")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdRate"))]
    pub not_spcfd_rate: Option<RateType5Code>,
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<ActiveCurrencyAnd13DecimalAmount>,
}

impl Validate for RateFormat31Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct RateFormat32Choice {
    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: Option<Percentage14Rate>,
    #[yaserde(rename = "NotSpcfdRate")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdRate"))]
    pub not_spcfd_rate: Option<RateType14Code>,
}

impl Validate for RateFormat32Choice {}




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

pub enum RateStatus1Code {
    #[yaserde(rename = "ACTU")]
    #[cfg_attr(feature = "serde", serde(rename = "ACTU"))]
    Actu,
    #[yaserde(rename = "INDI")]
    #[cfg_attr(feature = "serde", serde(rename = "INDI"))]
    Indi,
    __Unknown__(String),
}

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

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

impl Validate for RateStatus3Choice {}




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

pub enum RateType10Code {
    #[yaserde(rename = "ANYA")]
    #[cfg_attr(feature = "serde", serde(rename = "ANYA"))]
    Anya,
    #[yaserde(rename = "UKWN")]
    #[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
    Ukwn,
    __Unknown__(String),
}

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

impl Validate for RateType10Code {}



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

pub enum RateType13Code {
    #[yaserde(rename = "UKWN")]
    #[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
    Ukwn,
    #[yaserde(rename = "NILP")]
    #[cfg_attr(feature = "serde", serde(rename = "NILP"))]
    Nilp,
    __Unknown__(String),
}

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

impl Validate for RateType13Code {}



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

pub enum RateType14Code {
    #[yaserde(rename = "UKWN")]
    #[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
    Ukwn,
    #[yaserde(rename = "JLID")]
    #[cfg_attr(feature = "serde", serde(rename = "JLID"))]
    Jlid,
    __Unknown__(String),
}

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

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

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

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

impl Validate for RateType42Choice {}




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

pub enum RateType5Code {
    #[yaserde(rename = "UKWN")]
    #[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
    Ukwn,
    __Unknown__(String),
}

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

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

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

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

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

impl Validate for RateType79Choice {}




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

pub enum RateType7Code {
    #[yaserde(rename = "SCHD")]
    #[cfg_attr(feature = "serde", serde(rename = "SCHD"))]
    Schd,
    #[yaserde(rename = "USCD")]
    #[cfg_attr(feature = "serde", serde(rename = "USCD"))]
    Uscd,
    __Unknown__(String),
}

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

impl Validate for RateType7Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct RateTypeAndAmountAndStatus24 {
    #[yaserde(rename = "RateTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTp"))]
    pub rate_tp: RateType33Choice,

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

    #[yaserde(rename = "RateSts")]
    #[cfg_attr(feature = "serde", serde(rename = "RateSts"))]
    pub rate_sts: RateStatus3Choice,
}

impl Validate for RateTypeAndAmountAndStatus24 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct RateTypeAndAmountAndStatus26 {
    #[yaserde(rename = "RateTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTp"))]
    pub rate_tp: RateType36Choice,

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

    #[yaserde(rename = "RateSts")]
    #[cfg_attr(feature = "serde", serde(rename = "RateSts"))]
    pub rate_sts: RateStatus3Choice,
}

impl Validate for RateTypeAndAmountAndStatus26 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct RateTypeAndAmountAndStatus37 {
    #[yaserde(rename = "RateTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTp"))]
    pub rate_tp: DeemedRateType1Choice,

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

    #[yaserde(rename = "RateSts")]
    #[cfg_attr(feature = "serde", serde(rename = "RateSts"))]
    pub rate_sts: RateStatus3Choice,
}

impl Validate for RateTypeAndAmountAndStatus37 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct RateTypeAndAmountAndStatus55 {
    #[yaserde(rename = "RateTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTp"))]
    pub rate_tp: RateType76Choice,

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

    #[yaserde(rename = "RateSts")]
    #[cfg_attr(feature = "serde", serde(rename = "RateSts"))]
    pub rate_sts: RateStatus3Choice,
}

impl Validate for RateTypeAndAmountAndStatus55 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct RateTypeAndAmountAndStatus56 {
    #[yaserde(rename = "RateTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTp"))]
    pub rate_tp: RateType77Choice,

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

    #[yaserde(rename = "RateSts")]
    #[cfg_attr(feature = "serde", serde(rename = "RateSts"))]
    pub rate_sts: RateStatus3Choice,
}

impl Validate for RateTypeAndAmountAndStatus56 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct RateTypeAndAmountAndStatus57 {
    #[yaserde(rename = "RateTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTp"))]
    pub rate_tp: RateType78Choice,

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

    #[yaserde(rename = "RateSts")]
    #[cfg_attr(feature = "serde", serde(rename = "RateSts"))]
    pub rate_sts: RateStatus3Choice,
}

impl Validate for RateTypeAndAmountAndStatus57 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct RateTypeAndAmountAndStatus58 {
    #[yaserde(rename = "RateTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTp"))]
    pub rate_tp: RateType79Choice,

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

    #[yaserde(rename = "RateSts")]
    #[cfg_attr(feature = "serde", serde(rename = "RateSts"))]
    pub rate_sts: RateStatus3Choice,
}

impl Validate for RateTypeAndAmountAndStatus58 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct RateTypeAndPercentageRate12 {
    #[yaserde(rename = "RateTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTp"))]
    pub rate_tp: RateType42Choice,

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

impl Validate for RateTypeAndPercentageRate12 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct RateTypeAndPercentageRate13 {
    #[yaserde(rename = "RateTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTp"))]
    pub rate_tp: RateType42Choice,

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

impl Validate for RateTypeAndPercentageRate13 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct RateTypeAndPercentageRate14 {
    #[yaserde(rename = "RateTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTp"))]
    pub rate_tp: DeemedRateType1Choice,

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

impl Validate for RateTypeAndPercentageRate14 {}


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

pub enum RateValueType7Code {
    #[yaserde(rename = "UKWN")]
    #[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
    Ukwn,
    __Unknown__(String),
}

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

impl Validate for RateValueType7Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct RatioFormat17Choice {
    #[yaserde(rename = "QtyToQty")]
    #[cfg_attr(feature = "serde", serde(rename = "QtyToQty"))]
    pub qty_to_qty: Option<QuantityToQuantityRatio1>,
    #[yaserde(rename = "NotSpcfdRate")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdRate"))]
    pub not_spcfd_rate: Option<RateValueType7Code>,
    #[yaserde(rename = "AmtToAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtToAmt"))]
    pub amt_to_amt: Option<AmountToAmountRatio2>,
}

impl Validate for RatioFormat17Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct RatioFormat18Choice {
    #[yaserde(rename = "QtyToQty")]
    #[cfg_attr(feature = "serde", serde(rename = "QtyToQty"))]
    pub qty_to_qty: Option<QuantityToQuantityRatio1>,
    #[yaserde(rename = "NotSpcfdRate")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdRate"))]
    pub not_spcfd_rate: Option<RateValueType7Code>,
    #[yaserde(rename = "AmtToAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtToAmt"))]
    pub amt_to_amt: Option<AmountToAmountRatio2>,
    #[yaserde(rename = "AmtToQty")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtToQty"))]
    pub amt_to_qty: Option<AmountAndQuantityRatio4>,
    #[yaserde(rename = "QtyToAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "QtyToAmt"))]
    pub qty_to_amt: Option<AmountAndQuantityRatio4>,
}

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

impl Validate for RenounceableEntitlementStatusTypeFormat3Choice {}




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

pub enum RenounceableStatus1Code {
    #[yaserde(rename = "NREN")]
    #[cfg_attr(feature = "serde", serde(rename = "NREN"))]
    Nren,
    #[yaserde(rename = "RENO")]
    #[cfg_attr(feature = "serde", serde(rename = "RENO"))]
    Reno,
    __Unknown__(String),
}

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

impl Validate for RenounceableStatus1Code {}



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

pub enum SafekeepingAccountIdentification1Code {
    #[yaserde(rename = "GENR")]
    #[cfg_attr(feature = "serde", serde(rename = "GENR"))]
    Genr,
    __Unknown__(String),
}

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

impl Validate for SafekeepingAccountIdentification1Code {}



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

pub enum SafekeepingPlace1Code {
    #[yaserde(rename = "CUST")]
    #[cfg_attr(feature = "serde", serde(rename = "CUST"))]
    Cust,
    #[yaserde(rename = "ICSD")]
    #[cfg_attr(feature = "serde", serde(rename = "ICSD"))]
    Icsd,
    #[yaserde(rename = "NCSD")]
    #[cfg_attr(feature = "serde", serde(rename = "NCSD"))]
    Ncsd,
    #[yaserde(rename = "SHHE")]
    #[cfg_attr(feature = "serde", serde(rename = "SHHE"))]
    Shhe,
    __Unknown__(String),
}

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

impl Validate for SafekeepingPlace1Code {}



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

pub enum SafekeepingPlace2Code {
    #[yaserde(rename = "SHHE")]
    #[cfg_attr(feature = "serde", serde(rename = "SHHE"))]
    Shhe,
    #[yaserde(rename = "ALLP")]
    #[cfg_attr(feature = "serde", serde(rename = "ALLP"))]
    Allp,
    __Unknown__(String),
}

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

impl Validate for SafekeepingPlace2Code {}



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

pub enum SafekeepingPlace3Code {
    #[yaserde(rename = "SHHE")]
    #[cfg_attr(feature = "serde", serde(rename = "SHHE"))]
    Shhe,
    __Unknown__(String),
}

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

impl Validate for SafekeepingPlace3Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct SafekeepingPlaceFormat41Choice {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Option<SafekeepingPlaceTypeAndText8>,
    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: Option<CountryCode>,
    #[yaserde(rename = "DgtlLdgrId")]
    #[cfg_attr(feature = "serde", serde(rename = "DgtlLdgrId"))]
    pub dgtl_ldgr_id: Option<Dti2024Identifier>,
    #[yaserde(rename = "TpAndId")]
    #[cfg_attr(feature = "serde", serde(rename = "TpAndId"))]
    pub tp_and_id: Option<SafekeepingPlaceTypeAndIdentification1>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification78>,
}

impl Validate for SafekeepingPlaceFormat41Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct SafekeepingPlaceFormat42Choice {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Option<SafekeepingPlaceTypeAndText6>,
    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: Option<CountryCode>,
    #[yaserde(rename = "DgtlLdgrId")]
    #[cfg_attr(feature = "serde", serde(rename = "DgtlLdgrId"))]
    pub dgtl_ldgr_id: Option<Dti2024Identifier>,
    #[yaserde(rename = "TpAndId")]
    #[cfg_attr(feature = "serde", serde(rename = "TpAndId"))]
    pub tp_and_id: Option<SafekeepingPlaceTypeAndIdentification1>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification78>,
}

impl Validate for SafekeepingPlaceFormat42Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct SafekeepingPlaceTypeAndIdentification1 {
    #[yaserde(rename = "SfkpgPlcTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgPlcTp"))]
    pub sfkpg_plc_tp: SafekeepingPlace1Code,

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

impl Validate for SafekeepingPlaceTypeAndIdentification1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct SafekeepingPlaceTypeAndText6 {
    #[yaserde(rename = "SfkpgPlcTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgPlcTp"))]
    pub sfkpg_plc_tp: SafekeepingPlace2Code,

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

impl Validate for SafekeepingPlaceTypeAndText6 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct SafekeepingPlaceTypeAndText8 {
    #[yaserde(rename = "SfkpgPlcTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgPlcTp"))]
    pub sfkpg_plc_tp: SafekeepingPlace3Code,

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

impl Validate for SafekeepingPlaceTypeAndText8 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct SecuritiesOption121 {
    #[yaserde(rename = "SctyDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "SctyDtls"))]
    pub scty_dtls: FinancialInstrumentAttributes129,

    #[yaserde(rename = "CdtDbtInd")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtDbtInd"))]
    pub cdt_dbt_ind: CreditDebitCode,

    #[yaserde(rename = "TempFinInstrmInd")]
    #[cfg_attr(feature = "serde", serde(rename = "TempFinInstrmInd"))]
    pub temp_fin_instrm_ind: TemporaryFinancialInstrumentIndicator3Choice,

    #[yaserde(rename = "NonElgblPrcdsInd")]
    #[cfg_attr(feature = "serde", serde(rename = "NonElgblPrcdsInd"))]
    pub non_elgbl_prcds_ind: NonEligibleProceedsIndicator5Choice,

    #[yaserde(rename = "IssrOfferrTaxbltyInd")]
    #[cfg_attr(feature = "serde", serde(rename = "IssrOfferrTaxbltyInd"))]
    pub issr_offerr_taxblty_ind: IssuerOfferorTaxabilityIndicator2Choice,

    #[yaserde(rename = "NewSctiesIssncInd")]
    #[cfg_attr(feature = "serde", serde(rename = "NewSctiesIssncInd"))]
    pub new_scties_issnc_ind: NewSecuritiesIssuanceType5Code,

    #[yaserde(rename = "IncmTp")]
    #[cfg_attr(feature = "serde", serde(rename = "IncmTp"))]
    pub incm_tp: GenericIdentification30,

    #[yaserde(rename = "OthrIncmTp")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrIncmTp"))]
    pub othr_incm_tp: Vec<GenericIdentification30>,

    #[yaserde(rename = "XmptnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "XmptnTp"))]
    pub xmptn_tp: Vec<GenericIdentification30>,

    #[yaserde(rename = "EntitldQty")]
    #[cfg_attr(feature = "serde", serde(rename = "EntitldQty"))]
    pub entitld_qty: Quantity51Choice,

    #[yaserde(rename = "SfkpgPlc")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgPlc"))]
    pub sfkpg_plc: SafekeepingPlaceFormat41Choice,

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

    #[yaserde(rename = "FrctnDspstn")]
    #[cfg_attr(feature = "serde", serde(rename = "FrctnDspstn"))]
    pub frctn_dspstn: FractionDispositionType26Choice,

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

    #[yaserde(rename = "TradgPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "TradgPrd"))]
    pub tradg_prd: Period12Choice,

    #[yaserde(rename = "DtDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "DtDtls"))]
    pub dt_dtls: SecurityDate20,

    #[yaserde(rename = "RateDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "RateDtls"))]
    pub rate_dtls: CorporateActionRate128,

    #[yaserde(rename = "PricDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "PricDtls"))]
    pub pric_dtls: CorporateActionPrice82,

    #[yaserde(rename = "AmtDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtDtls"))]
    pub amt_dtls: CorporateActionAmounts60,
}

impl Validate for SecuritiesOption121 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct SecuritiesOption81 {
    #[yaserde(rename = "MaxQtyToInst")]
    #[cfg_attr(feature = "serde", serde(rename = "MaxQtyToInst"))]
    pub max_qty_to_inst: FinancialInstrumentQuantity34Choice,

    #[yaserde(rename = "MinQtyToInst")]
    #[cfg_attr(feature = "serde", serde(rename = "MinQtyToInst"))]
    pub min_qty_to_inst: FinancialInstrumentQuantity34Choice,

    #[yaserde(rename = "MinMltplQtyToInst")]
    #[cfg_attr(feature = "serde", serde(rename = "MinMltplQtyToInst"))]
    pub min_mltpl_qty_to_inst: FinancialInstrumentQuantity35Choice,

    #[yaserde(rename = "NewBrdLotQty")]
    #[cfg_attr(feature = "serde", serde(rename = "NewBrdLotQty"))]
    pub new_brd_lot_qty: FinancialInstrumentQuantity35Choice,

    #[yaserde(rename = "NewDnmtnQty")]
    #[cfg_attr(feature = "serde", serde(rename = "NewDnmtnQty"))]
    pub new_dnmtn_qty: FinancialInstrumentQuantity35Choice,

    #[yaserde(rename = "FrntEndOddLotQty")]
    #[cfg_attr(feature = "serde", serde(rename = "FrntEndOddLotQty"))]
    pub frnt_end_odd_lot_qty: FinancialInstrumentQuantity35Choice,

    #[yaserde(rename = "BckEndOddLotQty")]
    #[cfg_attr(feature = "serde", serde(rename = "BckEndOddLotQty"))]
    pub bck_end_odd_lot_qty: FinancialInstrumentQuantity35Choice,
}

impl Validate for SecuritiesOption81 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct SecurityDate20 {
    #[yaserde(rename = "PmtDt")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtDt"))]
    pub pmt_dt: DateFormat30Choice,

    #[yaserde(rename = "AvlblDt")]
    #[cfg_attr(feature = "serde", serde(rename = "AvlblDt"))]
    pub avlbl_dt: DateFormat30Choice,

    #[yaserde(rename = "DvddRnkgDt")]
    #[cfg_attr(feature = "serde", serde(rename = "DvddRnkgDt"))]
    pub dvdd_rnkg_dt: DateFormat30Choice,

    #[yaserde(rename = "EarlstPmtDt")]
    #[cfg_attr(feature = "serde", serde(rename = "EarlstPmtDt"))]
    pub earlst_pmt_dt: DateFormat30Choice,

    #[yaserde(rename = "PrpssDt")]
    #[cfg_attr(feature = "serde", serde(rename = "PrpssDt"))]
    pub prpss_dt: DateFormat30Choice,

    #[yaserde(rename = "LastTradgDt")]
    #[cfg_attr(feature = "serde", serde(rename = "LastTradgDt"))]
    pub last_tradg_dt: DateFormat30Choice,
}

impl Validate for SecurityDate20 {}


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

    #[yaserde(rename = "OthrId")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrId"))]
    pub othr_id: Vec<OtherIdentification1>,

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

impl Validate for SecurityIdentification19 {}


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

pub enum ShortLong1Code {
    #[yaserde(rename = "SHOR")]
    #[cfg_attr(feature = "serde", serde(rename = "SHOR"))]
    Shor,
    #[yaserde(rename = "LONG")]
    #[cfg_attr(feature = "serde", serde(rename = "LONG"))]
    Long,
    __Unknown__(String),
}

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

impl Validate for ShortLong1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct SignedQuantityFormat10 {
    #[yaserde(rename = "ShrtLngPos")]
    #[cfg_attr(feature = "serde", serde(rename = "ShrtLngPos"))]
    pub shrt_lng_pos: ShortLong1Code,

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

impl Validate for SignedQuantityFormat10 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct SignedQuantityFormat11 {
    #[yaserde(rename = "ShrtLngPos")]
    #[cfg_attr(feature = "serde", serde(rename = "ShrtLngPos"))]
    pub shrt_lng_pos: ShortLong1Code,

    #[yaserde(rename = "QtyChc")]
    #[cfg_attr(feature = "serde", serde(rename = "QtyChc"))]
    pub qty_chc: Quantity48Choice,
}

impl Validate for SignedQuantityFormat11 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct SolicitationFeeRateFormat11Choice {
    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: Option<Percentage14Rate>,
    #[yaserde(rename = "AmtToQty")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtToQty"))]
    pub amt_to_qty: Option<AmountAndQuantityRatio4>,
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<ActiveCurrencyAnd13DecimalAmount>,
    #[yaserde(rename = "NotSpcfdRate")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdRate"))]
    pub not_spcfd_rate: Option<RateValueType7Code>,
}

impl Validate for SolicitationFeeRateFormat11Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
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:seev.031.001.16")]
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:seev.031.001.16")]
pub struct TaxableIncomePerShareCalculatedFormat3Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<CorporateActionTaxableIncomePerShareCalculated1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification30>,
}

impl Validate for TaxableIncomePerShareCalculatedFormat3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct TemporaryFinancialInstrumentIndicator3Choice {
    #[yaserde(rename = "TempInd")]
    #[cfg_attr(feature = "serde", serde(rename = "TempInd"))]
    pub temp_ind: Option<YesNoIndicator>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification30>,
}

impl Validate for TemporaryFinancialInstrumentIndicator3Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct TotalEligibleBalanceFormat10 {
    #[yaserde(rename = "Bal")]
    #[cfg_attr(feature = "serde", serde(rename = "Bal"))]
    pub bal: Quantity49Choice,

    #[yaserde(rename = "FullPrdUnits")]
    #[cfg_attr(feature = "serde", serde(rename = "FullPrdUnits"))]
    pub full_prd_units: SignedQuantityFormat10,

    #[yaserde(rename = "PartWayPrdUnits")]
    #[cfg_attr(feature = "serde", serde(rename = "PartWayPrdUnits"))]
    pub part_way_prd_units: SignedQuantityFormat10,
}

impl Validate for TotalEligibleBalanceFormat10 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct UpdatedAdditionalInformation19 {
    #[yaserde(rename = "Lang")]
    #[cfg_attr(feature = "serde", serde(rename = "Lang"))]
    pub lang: Iso2AlanguageCode,

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

impl Validate for UpdatedAdditionalInformation19 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct UpdatedAdditionalInformation20 {
    #[yaserde(rename = "Lang")]
    #[cfg_attr(feature = "serde", serde(rename = "Lang"))]
    pub lang: Iso2AlanguageCode,

    #[yaserde(rename = "AddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
    pub addtl_inf: Vec<Max8000Text>,
}

impl Validate for UpdatedAdditionalInformation20 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct UpdatedAdditionalInformation21 {
    #[yaserde(rename = "Lang")]
    #[cfg_attr(feature = "serde", serde(rename = "Lang"))]
    pub lang: Iso2AlanguageCode,

    #[yaserde(rename = "AddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
    pub addtl_inf: Vec<Max350Text>,
}

impl Validate for UpdatedAdditionalInformation21 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.001.16")]
pub struct UpdatedURLlnformation6 {
    #[yaserde(rename = "Lang")]
    #[cfg_attr(feature = "serde", serde(rename = "Lang"))]
    pub lang: Iso2AlanguageCode,

    #[yaserde(rename = "URLAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "URLAdr"))]
    pub url_adr: Max2048Text,
}

impl Validate for UpdatedURLlnformation6 {}


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

pub enum WithholdingTaxRateType1Code {
    #[yaserde(rename = "BWIT")]
    #[cfg_attr(feature = "serde", serde(rename = "BWIT"))]
    Bwit,
    #[yaserde(rename = "FTCA")]
    #[cfg_attr(feature = "serde", serde(rename = "FTCA"))]
    Ftca,
    #[yaserde(rename = "NRAT")]
    #[cfg_attr(feature = "serde", serde(rename = "NRAT"))]
    Nrat,
    __Unknown__(String),
}

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

impl Validate for WithholdingTaxRateType1Code {}



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

impl Validate for YesNoIndicator {}

impl crate::MxMessage for Document {
    const BUSINESS_AREA: crate::BusinessArea = crate::BusinessArea::seev;
    const FUNCTIONALITY: &'static str = "031";
    const VARIANT: &'static str = "001";
    const VERSION: &'static str = "16";
    const MESSAGE_NAME: &'static str = "seev.031.001.16";
    const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:seev.031.001.16";
}