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.002.15")]
pub struct AccountAndBalance65 {
    #[yaserde(rename = "SfkpgAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgAcct"))]
    pub sfkpg_acct: RestrictedFINXMax35Text,

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

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

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

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

impl Validate for AccountAndBalance65 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
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.002.15")]
pub struct AccountIdentification78Choice {
    #[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<AccountAndBalance65>,
}

impl Validate for AccountIdentification78Choice {}




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

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.002.15")]
pub struct AdditionalBusinessProcessFormat22Choice {
    #[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<GenericIdentification47>,
}

impl Validate for AdditionalBusinessProcessFormat22Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct AmountAndQuantityRatio5 {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: RestrictedFINActiveCurrencyAnd13DecimalAmount,

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

impl Validate for AmountAndQuantityRatio5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct AmountAndRateStatus2 {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: RestrictedFINActiveCurrencyAnd13DecimalAmount,

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

impl Validate for AmountAndRateStatus2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct AmountPrice4 {
    #[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: RestrictedFINActiveCurrencyAnd13DecimalAmount,
}

impl Validate for AmountPrice4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct AmountPrice5 {
    #[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: RestrictedFINActiveCurrencyAnd13DecimalAmount,
}

impl Validate for AmountPrice5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct AmountPrice7 {
    #[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: RestrictedFINActiveCurrencyAnd13DecimalAmount,
}

impl Validate for AmountPrice7 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct AmountPricePerAmount3 {
    #[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: RestrictedFINActiveCurrencyAnd13DecimalAmount,

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

impl Validate for AmountPricePerAmount3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct AmountPricePerFinancialInstrumentQuantity11 {
    #[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: RestrictedFINActiveCurrencyAnd13DecimalAmount,

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

impl Validate for AmountPricePerFinancialInstrumentQuantity11 {}


#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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

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

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.002.15")]
pub struct AmountToAmountRatio3 {
    #[yaserde(rename = "Amt1")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt1"))]
    pub amt_1: RestrictedFINActiveCurrencyAnd13DecimalAmount,

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

impl Validate for AmountToAmountRatio3 {}


#[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.002.15")]
pub struct BalanceFormat14Choice {
    #[yaserde(rename = "Bal")]
    #[cfg_attr(feature = "serde", serde(rename = "Bal"))]
    pub bal: Option<SignedQuantityFormat12>,
    #[yaserde(rename = "ElgblBal")]
    #[cfg_attr(feature = "serde", serde(rename = "ElgblBal"))]
    pub elgbl_bal: Option<SignedQuantityFormat13>,
    #[yaserde(rename = "NotElgblBal")]
    #[cfg_attr(feature = "serde", serde(rename = "NotElgblBal"))]
    pub not_elgbl_bal: Option<SignedQuantityFormat13>,
}

impl Validate for BalanceFormat14Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct BalanceFormat16Choice {
    #[yaserde(rename = "Bal")]
    #[cfg_attr(feature = "serde", serde(rename = "Bal"))]
    pub bal: Option<SignedQuantityFormat12>,
    #[yaserde(rename = "ElgblBal")]
    #[cfg_attr(feature = "serde", serde(rename = "ElgblBal"))]
    pub elgbl_bal: Option<SignedQuantityFormat13>,
    #[yaserde(rename = "NotElgblBal")]
    #[cfg_attr(feature = "serde", serde(rename = "NotElgblBal"))]
    pub not_elgbl_bal: Option<SignedQuantityFormat13>,
    #[yaserde(rename = "FullPrdUnits")]
    #[cfg_attr(feature = "serde", serde(rename = "FullPrdUnits"))]
    pub full_prd_units: Option<SignedQuantityFormat13>,
    #[yaserde(rename = "PartWayPrdUnits")]
    #[cfg_attr(feature = "serde", serde(rename = "PartWayPrdUnits"))]
    pub part_way_prd_units: Option<SignedQuantityFormat13>,
}

impl Validate for BalanceFormat16Choice {}




#[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.002.15")]
pub struct BeneficiaryCertificationType15Choice {
    #[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<GenericIdentification47>,
}

impl Validate for BeneficiaryCertificationType15Choice {}




#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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

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.002.15")]
pub struct BidRangeType2Choice {
    #[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<GenericIdentification47>,
}

impl Validate for BidRangeType2Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct BlockChainAddressWallet11 {
    #[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: GenericIdentification47,

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

impl Validate for BlockChainAddressWallet11 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct BorrowerLendingDeadline6 {
    #[yaserde(rename = "StockLndgDdln")]
    #[cfg_attr(feature = "serde", serde(rename = "StockLndgDdln"))]
    pub stock_lndg_ddln: DateFormat49Choice,

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

impl Validate for BorrowerLendingDeadline6 {}


#[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.002.15")]
pub struct CapitalGainFormat4Choice {
    #[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<GenericIdentification47>,
}

impl Validate for CapitalGainFormat4Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct CashAccountIdentification15Choice {
    #[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<BlockChainAddressWallet11>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<RestrictedFINX2Max34Text>,
}

impl Validate for CashAccountIdentification15Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct CashOption113 {
    #[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: NonEligibleProceedsIndicator6Choice,

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

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

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

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

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

    #[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: CashAccountIdentification15Choice,

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

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

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

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

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

impl Validate for CashOption113 {}


#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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.002.15")]
pub struct CertificationTypeFormat4Choice {
    #[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<GenericIdentification47>,
}

impl Validate for CertificationTypeFormat4Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct ClassificationType33Choice {
    #[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<GenericIdentification86>,
}

impl Validate for ClassificationType33Choice {}




#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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.002.15")]
pub struct ConsentTypeFormat5Choice {
    #[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<GenericIdentification47>,
}

impl Validate for ConsentTypeFormat5Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct CorporateAction87 {
    #[yaserde(rename = "DtDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "DtDtls"))]
    pub dt_dtls: CorporateActionDate96,

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

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

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

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

    #[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<IdentificationFormat4Choice>,

    #[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: DividendTypeFormat10Choice,

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

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

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

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

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

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

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

    #[yaserde(rename = "IntrmdtSctiesDstrbtnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrmdtSctiesDstrbtnTp"))]
    pub intrmdt_scties_dstrbtn_tp: IntermediateSecuritiesDistributionTypeFormat18Choice,

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

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

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

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

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

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

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

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

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

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

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

impl Validate for CorporateAction87 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct CorporateActionAmounts61 {
    #[yaserde(rename = "WhldgTaxAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "WhldgTaxAmt"))]
    pub whldg_tax_amt: RestrictedFINActiveCurrencyAndAmount,

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

impl Validate for CorporateActionAmounts61 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct CorporateActionAmounts76 {
    #[yaserde(rename = "GrssAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "GrssAmt"))]
    pub grss_amt: RestrictedFINActiveCurrencyAndAmount,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Validate for CorporateActionAmounts76 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct CorporateActionBalanceDetails46 {
    #[yaserde(rename = "TtlElgblBal")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlElgblBal"))]
    pub ttl_elgbl_bal: TotalEligibleBalanceFormat11,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Validate for CorporateActionBalanceDetails46 {}


#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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.002.15")]
pub struct CorporateActionChangeTypeFormat8Choice {
    #[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<GenericIdentification47>,
}

impl Validate for CorporateActionChangeTypeFormat8Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct CorporateActionDate108 {
    #[yaserde(rename = "EarlyRspnDdln")]
    #[cfg_attr(feature = "serde", serde(rename = "EarlyRspnDdln"))]
    pub early_rspn_ddln: DateFormat49Choice,

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

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

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

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

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

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

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

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

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

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

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

impl Validate for CorporateActionDate108 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct CorporateActionDate96 {
    #[yaserde(rename = "AnncmntDt")]
    #[cfg_attr(feature = "serde", serde(rename = "AnncmntDt"))]
    pub anncmnt_dt: DateFormat49Choice,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Validate for CorporateActionDate96 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct CorporateActionDate97 {
    #[yaserde(rename = "PmtDt")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtDt"))]
    pub pmt_dt: DateFormat41Choice,

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

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

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

impl Validate for CorporateActionDate97 {}


#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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.002.15")]
pub struct CorporateActionEventProcessingType3Choice {
    #[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<GenericIdentification47>,
}

impl Validate for CorporateActionEventProcessingType3Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct CorporateActionEventReference4 {
    #[yaserde(rename = "EvtId")]
    #[cfg_attr(feature = "serde", serde(rename = "EvtId"))]
    pub evt_id: CorporateActionEventReference4Choice,

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

impl Validate for CorporateActionEventReference4 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct CorporateActionEventReference4Choice {
    #[yaserde(rename = "LkdOffclCorpActnEvtId")]
    #[cfg_attr(feature = "serde", serde(rename = "LkdOffclCorpActnEvtId"))]
    pub lkd_offcl_corp_actn_evt_id: Option<RestrictedFINXMax16Text>,
    #[yaserde(rename = "LkdCorpActnId")]
    #[cfg_attr(feature = "serde", serde(rename = "LkdCorpActnId"))]
    pub lkd_corp_actn_id: Option<RestrictedFINXMax16Text>,
}

impl Validate for CorporateActionEventReference4Choice {}




#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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.002.15")]
pub struct CorporateActionEventStageFormat20Choice {
    #[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<GenericIdentification47>,
}

impl Validate for CorporateActionEventStageFormat20Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
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.002.15")]
pub struct CorporateActionEventType124Choice {
    #[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<GenericIdentification47>,
}

impl Validate for CorporateActionEventType124Choice {}




#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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

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.002.15")]
pub struct CorporateActionGeneralInformation194 {
    #[yaserde(rename = "CorpActnEvtId")]
    #[cfg_attr(feature = "serde", serde(rename = "CorpActnEvtId"))]
    pub corp_actn_evt_id: RestrictedFINXMax16Text,

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

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

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

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

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

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

impl Validate for CorporateActionGeneralInformation194 {}


#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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

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.002.15")]
pub struct CorporateActionMandatoryVoluntary4Choice {
    #[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<GenericIdentification47>,
}

impl Validate for CorporateActionMandatoryVoluntary4Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct CorporateActionNarrative63 {
    #[yaserde(rename = "Offerr")]
    #[cfg_attr(feature = "serde", serde(rename = "Offerr"))]
    pub offerr: Vec<RestrictedFINXMax350Text>,

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

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

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

impl Validate for CorporateActionNarrative63 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct CorporateActionNarrative64 {
    #[yaserde(rename = "AddtlTxt")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlTxt"))]
    pub addtl_txt: Vec<UpdatedAdditionalInformation24>,

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

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

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

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

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

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

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

impl Validate for CorporateActionNarrative64 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct CorporateActionNarrative65 {
    #[yaserde(rename = "AddtlTxt")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlTxt"))]
    pub addtl_txt: Vec<UpdatedAdditionalInformation26>,

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

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

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

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

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

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

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

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

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

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

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

impl Validate for CorporateActionNarrative65 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct CorporateActionNotification002V15 {
    #[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: CorporateActionNotification11,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Validate for CorporateActionNotification002V15 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct CorporateActionNotification11 {
    #[yaserde(rename = "NtfctnId")]
    #[cfg_attr(feature = "serde", serde(rename = "NtfctnId"))]
    pub ntfctn_id: RestrictedFINXMax16Text,

    #[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: CorporateActionProcessingStatus6Choice,
}

impl Validate for CorporateActionNotification11 {}


#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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

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.002.15")]
pub struct CorporateActionOption247 {
    #[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: CorporateActionOption46Choice,

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

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

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

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

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

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

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

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

    #[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: SecurityIdentification20,

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

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

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

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

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

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

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

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

impl Validate for CorporateActionOption247 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct CorporateActionOption46Choice {
    #[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<GenericIdentification47>,
}

impl Validate for CorporateActionOption46Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct CorporateActionPeriod12 {
    #[yaserde(rename = "PricClctnPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "PricClctnPrd"))]
    pub pric_clctn_prd: Period6Choice,

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

    #[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: Period6Choice,
}

impl Validate for CorporateActionPeriod12 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct CorporateActionPeriod16 {
    #[yaserde(rename = "PricClctnPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "PricClctnPrd"))]
    pub pric_clctn_prd: Period6Choice,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Validate for CorporateActionPeriod16 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct CorporateActionPrice96 {
    #[yaserde(rename = "MaxPric")]
    #[cfg_attr(feature = "serde", serde(rename = "MaxPric"))]
    pub max_pric: PriceFormat91Choice,

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

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

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

impl Validate for CorporateActionPrice96 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct CorporateActionPrice97 {
    #[yaserde(rename = "CshInLieuOfShrPric")]
    #[cfg_attr(feature = "serde", serde(rename = "CshInLieuOfShrPric"))]
    pub csh_in_lieu_of_shr_pric: PriceFormat92Choice,

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

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

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

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

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

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

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

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

impl Validate for CorporateActionPrice97 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct CorporateActionPrice98 {
    #[yaserde(rename = "IndctvOrMktPric")]
    #[cfg_attr(feature = "serde", serde(rename = "IndctvOrMktPric"))]
    pub indctv_or_mkt_pric: IndicativeOrMarketPrice18Choice,

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

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

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

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

impl Validate for CorporateActionPrice98 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct CorporateActionProcessingStatus6Choice {
    #[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<GenericIdentification47>,
}

impl Validate for CorporateActionProcessingStatus6Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct CorporateActionQuantity14 {
    #[yaserde(rename = "MaxQty")]
    #[cfg_attr(feature = "serde", serde(rename = "MaxQty"))]
    pub max_qty: FinancialInstrumentQuantity44Choice,

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

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

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

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

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

impl Validate for CorporateActionQuantity14 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct CorporateActionRate135 {
    #[yaserde(rename = "IntrstRate")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstRate"))]
    pub intrst_rate: RateAndAmountFormat72Choice,

    #[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: RateAndAmountFormat73Choice,

    #[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: RateAndAmountFormat74Choice,

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

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

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

impl Validate for CorporateActionRate135 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct CorporateActionRate136 {
    #[yaserde(rename = "AddtlTax")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlTax"))]
    pub addtl_tax: RateAndAmountFormat72Choice,

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

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

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

    #[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: RateFormat24Choice,

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

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

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

    #[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: RateAndAmountFormat72Choice,

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

impl Validate for CorporateActionRate136 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct CorporateActionRate137 {
    #[yaserde(rename = "AddtlQtyForSbcbdRsltntScties")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlQtyForSbcbdRsltntScties"))]
    pub addtl_qty_for_sbcbd_rsltnt_scties: RatioFormat23Choice,

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

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

    #[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: RateAndAmountFormat72Choice,

    #[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: RateFormat30Choice,

    #[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<RateAndAmountFormat76Choice>,

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

impl Validate for CorporateActionRate137 {}


#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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

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.002.15")]
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.002.15")]
pub struct DateCode22Choice {
    #[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<GenericIdentification47>,
}

impl Validate for DateCode22Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct DateCode26Choice {
    #[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<GenericIdentification47>,
}

impl Validate for DateCode26Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct DateCode27Choice {
    #[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<GenericIdentification47>,
}

impl Validate for DateCode27Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct DateCode39Choice {
    #[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<GenericIdentification47>,
}

impl Validate for DateCode39Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct DateCodeAndTimeFormat4 {
    #[yaserde(rename = "DtCd")]
    #[cfg_attr(feature = "serde", serde(rename = "DtCd"))]
    pub dt_cd: DateCode26Choice,

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

impl Validate for DateCodeAndTimeFormat4 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct DateFormat41Choice {
    #[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<DateCode22Choice>,
}

impl Validate for DateFormat41Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
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.002.15")]
pub struct DateFormat49Choice {
    #[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<DateCode22Choice>,
}

impl Validate for DateFormat49Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct DateFormat54Choice {
    #[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<DateCodeAndTimeFormat4>,
    #[yaserde(rename = "DtCd")]
    #[cfg_attr(feature = "serde", serde(rename = "DtCd"))]
    pub dt_cd: Option<DateCode22Choice>,
}

impl Validate for DateFormat54Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct DateFormat64Choice {
    #[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<DateCode27Choice>,
}

impl Validate for DateFormat64Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct DateFormat71Choice {
    #[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<DateCode39Choice>,
}

impl Validate for DateFormat71Choice {}




#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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

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

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

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

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.002.15")]
pub struct DeemedRateType2Choice {
    #[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<GenericIdentification47>,
}

impl Validate for DeemedRateType2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
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.002.15")]

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.002.15")]
pub struct DistributionTypeFormat8Choice {
    #[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<GenericIdentification47>,
}

impl Validate for DistributionTypeFormat8Choice {}




#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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.002.15")]
pub struct DividendTypeFormat10Choice {
    #[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<GenericIdentification47>,
}

impl Validate for DividendTypeFormat10Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct Document {
    #[yaserde(rename = "CorpActnNtfctn")]
    #[cfg_attr(feature = "serde", serde(rename = "CorpActnNtfctn"))]
    pub corp_actn_ntfctn: CorporateActionNotification002V15,
}

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.002.15")]
pub struct DocumentIdentification17 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: RestrictedFINXMax16Text,
}

impl Validate for DocumentIdentification17 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct DocumentIdentification37 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: RestrictedFINXMax16Text,

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

impl Validate for DocumentIdentification37 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct DocumentIdentification38 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: DocumentIdentification4Choice,

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

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

impl Validate for DocumentIdentification38 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct DocumentIdentification4Choice {
    #[yaserde(rename = "AcctSvcrDocId")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctSvcrDocId"))]
    pub acct_svcr_doc_id: Option<RestrictedFINXMax16Text>,
    #[yaserde(rename = "AcctOwnrDocId")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctOwnrDocId"))]
    pub acct_ownr_doc_id: Option<RestrictedFINXMax16Text>,
}

impl Validate for DocumentIdentification4Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct DocumentNumber6Choice {
    #[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<GenericIdentification86>,
}

impl Validate for DocumentNumber6Choice {}




#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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.002.15")]
pub struct DutchAuctionTypeFormat2Choice {
    #[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<GenericIdentification47>,
}

impl Validate for DutchAuctionTypeFormat2Choice {}




#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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

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.002.15")]
pub struct ElectionTypeFormat4Choice {
    #[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<GenericIdentification47>,
}

impl Validate for ElectionTypeFormat4Choice {}




#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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

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

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.002.15")]
pub struct EventSequenceTypeFormat2Choice {
    #[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<GenericIdentification47>,
}

impl Validate for EventSequenceTypeFormat2Choice {}




#[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.002.15")]
pub struct FinancialInstrumentAttributes117 {
    #[yaserde(rename = "SctyId")]
    #[cfg_attr(feature = "serde", serde(rename = "SctyId"))]
    pub scty_id: SecurityIdentification20,

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

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

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

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

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

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

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

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

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

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

impl Validate for FinancialInstrumentAttributes117 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct FinancialInstrumentAttributes136 {
    #[yaserde(rename = "FinInstrmId")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrmId"))]
    pub fin_instrm_id: SecurityIdentification20,

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

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

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

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

    #[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: QuantityToQuantityRatio2,

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

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

impl Validate for FinancialInstrumentAttributes136 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct FinancialInstrumentAttributes137 {
    #[yaserde(rename = "FinInstrmId")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrmId"))]
    pub fin_instrm_id: SecurityIdentification20,

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

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

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

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

    #[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: FinancialInstrumentQuantity36Choice,

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

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

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

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

impl Validate for FinancialInstrumentAttributes137 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct FinancialInstrumentQuantity36Choice {
    #[yaserde(rename = "Unit")]
    #[cfg_attr(feature = "serde", serde(rename = "Unit"))]
    pub unit: Option<RestrictedFINDecimalNumber>,
    #[yaserde(rename = "FaceAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "FaceAmt"))]
    pub face_amt: Option<RestrictedFINImpliedCurrencyAndAmount>,
    #[yaserde(rename = "AmtsdVal")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtsdVal"))]
    pub amtsd_val: Option<RestrictedFINImpliedCurrencyAndAmount>,
    #[yaserde(rename = "DgtlTknUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "DgtlTknUnit"))]
    pub dgtl_tkn_unit: Option<Max30DecimalNumber>,
}

impl Validate for FinancialInstrumentQuantity36Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct FinancialInstrumentQuantity43Choice {
    #[yaserde(rename = "Unit")]
    #[cfg_attr(feature = "serde", serde(rename = "Unit"))]
    pub unit: Option<RestrictedFINDecimalNumber>,
    #[yaserde(rename = "FaceAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "FaceAmt"))]
    pub face_amt: Option<RestrictedFINImpliedCurrencyAndAmount>,
    #[yaserde(rename = "AmtsdVal")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtsdVal"))]
    pub amtsd_val: Option<RestrictedFINImpliedCurrencyAndAmount>,
    #[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 FinancialInstrumentQuantity43Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct FinancialInstrumentQuantity44Choice {
    #[yaserde(rename = "Unit")]
    #[cfg_attr(feature = "serde", serde(rename = "Unit"))]
    pub unit: Option<RestrictedFINDecimalNumber>,
    #[yaserde(rename = "FaceAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "FaceAmt"))]
    pub face_amt: Option<RestrictedFINImpliedCurrencyAndAmount>,
    #[yaserde(rename = "AmtsdVal")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtsdVal"))]
    pub amtsd_val: Option<RestrictedFINImpliedCurrencyAndAmount>,
    #[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 FinancialInstrumentQuantity44Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
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.002.15")]
pub struct ForeignExchangeTerms43 {
    #[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: RestrictedFINActiveCurrencyAndAmount,
}

impl Validate for ForeignExchangeTerms43 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct FractionDispositionType31Choice {
    #[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<GenericIdentification47>,
}

impl Validate for FractionDispositionType31Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct FractionDispositionType32Choice {
    #[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<GenericIdentification47>,
}

impl Validate for FractionDispositionType32Choice {}




#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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

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.002.15")]
pub struct GenericIdentification47 {
    #[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: Max4AlphaNumericText,

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

impl Validate for GenericIdentification47 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct GenericIdentification84 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: RestrictedFINXMax34Text,

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

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

impl Validate for GenericIdentification84 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct GenericIdentification85 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: GenericIdentification47,

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

impl Validate for GenericIdentification85 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct GenericIdentification86 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: RestrictedFINXMax30Text,

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

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

impl Validate for GenericIdentification86 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct GrossDividendRateFormat41Choice {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<RestrictedFINActiveCurrencyAnd13DecimalAmount>,
    #[yaserde(rename = "AmtAndRateSts")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtAndRateSts"))]
    pub amt_and_rate_sts: Option<AmountAndRateStatus2>,
    #[yaserde(rename = "RateTpAndAmtAndRateSts")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTpAndAmtAndRateSts"))]
    pub rate_tp_and_amt_and_rate_sts: Option<RateTypeAndAmountAndStatus59>,
    #[yaserde(rename = "NotSpcfdRate")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdRate"))]
    pub not_spcfd_rate: Option<RateType13Code>,
}

impl Validate for GrossDividendRateFormat41Choice {}




#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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(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.002.15")]
pub struct IdentificationFormat4Choice {
    #[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<RestrictedFINXMax30Text>,
    #[yaserde(rename = "PrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
    pub prtry_id: Option<GenericIdentification86>,
}

impl Validate for IdentificationFormat4Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct IdentificationSource4Choice {
    #[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<RestrictedFINExact2Text>,
}

impl Validate for IdentificationSource4Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct IndicativeOrMarketPrice18Choice {
    #[yaserde(rename = "IndctvPric")]
    #[cfg_attr(feature = "serde", serde(rename = "IndctvPric"))]
    pub indctv_pric: Option<PriceFormat92Choice>,
    #[yaserde(rename = "MktPric")]
    #[cfg_attr(feature = "serde", serde(rename = "MktPric"))]
    pub mkt_pric: Option<PriceFormat92Choice>,
}

impl Validate for IndicativeOrMarketPrice18Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct InformationTypeFormat5Choice {
    #[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<GenericIdentification47>,
}

impl Validate for InformationTypeFormat5Choice {}




#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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.002.15")]
pub struct InterestComputationMethodFormat5Choice {
    #[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<GenericIdentification47>,
}

impl Validate for InterestComputationMethodFormat5Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct InterestRateUsedForPaymentFormat18Choice {
    #[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<RestrictedFINActiveCurrencyAnd13DecimalAmount>,
    #[yaserde(rename = "RateTpAndAmtAndRateSts")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTpAndAmtAndRateSts"))]
    pub rate_tp_and_amt_and_rate_sts: Option<RateTypeAndAmountAndStatus32>,
    #[yaserde(rename = "NotSpcfdRate")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdRate"))]
    pub not_spcfd_rate: Option<RateType13Code>,
}

impl Validate for InterestRateUsedForPaymentFormat18Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct IntermediateSecuritiesDistributionTypeFormat18Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<IntermediateSecurityDistributionType5Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for IntermediateSecuritiesDistributionTypeFormat18Choice {}




#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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

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

impl Validate for IntermediateSecurityDistributionType5Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct IssuerOfferorTaxabilityIndicator1Choice {
    #[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<GenericIdentification47>,
}

impl Validate for IssuerOfferorTaxabilityIndicator1Choice {}




#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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

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.002.15")]
pub struct LotteryTypeFormat5Choice {
    #[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<GenericIdentification47>,
}

impl Validate for LotteryTypeFormat5Choice {}




#[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.002.15")]
pub struct MarketIdentification4Choice {
    #[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<RestrictedFINXMax30Text>,
}

impl Validate for MarketIdentification4Choice {}




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

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

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

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

impl Validate for NameAndAddress12 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct NetDividendRateFormat43Choice {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<RestrictedFINActiveCurrencyAnd13DecimalAmount>,
    #[yaserde(rename = "AmtAndRateSts")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtAndRateSts"))]
    pub amt_and_rate_sts: Option<AmountAndRateStatus2>,
    #[yaserde(rename = "RateTpAndAmtAndRateSts")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTpAndAmtAndRateSts"))]
    pub rate_tp_and_amt_and_rate_sts: Option<RateTypeAndAmountAndStatus60>,
    #[yaserde(rename = "NotSpcfdRate")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdRate"))]
    pub not_spcfd_rate: Option<RateValueType7Code>,
}

impl Validate for NetDividendRateFormat43Choice {}




#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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

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

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.002.15")]
pub struct NonEligibleProceedsIndicator6Choice {
    #[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<GenericIdentification47>,
}

impl Validate for NonEligibleProceedsIndicator6Choice {}




#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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

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

impl Validate for OfferType5Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct OfferTypeFormat16Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<OfferType5Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for OfferTypeFormat16Choice {}




#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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.002.15")]
pub struct OptionAvailabilityStatus4Choice {
    #[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<GenericIdentification47>,
}

impl Validate for OptionAvailabilityStatus4Choice {}




#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

pub enum OptionFeatures13Code {
    #[yaserde(rename = "ASVO")]
    #[cfg_attr(feature = "serde", serde(rename = "ASVO"))]
    Asvo,
    #[yaserde(rename = "BOIS")]
    #[cfg_attr(feature = "serde", serde(rename = "BOIS"))]
    Bois,
    #[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 = "NOSE")]
    #[cfg_attr(feature = "serde", serde(rename = "NOSE"))]
    Nose,
    #[yaserde(rename = "OPLF")]
    #[cfg_attr(feature = "serde", serde(rename = "OPLF"))]
    Oplf,
    #[yaserde(rename = "CAOS")]
    #[cfg_attr(feature = "serde", serde(rename = "CAOS"))]
    Caos,
    #[yaserde(rename = "PINS")]
    #[cfg_attr(feature = "serde", serde(rename = "PINS"))]
    Pins,
    #[yaserde(rename = "PROR")]
    #[cfg_attr(feature = "serde", serde(rename = "PROR"))]
    Pror,
    #[yaserde(rename = "VVPR")]
    #[cfg_attr(feature = "serde", serde(rename = "VVPR"))]
    Vvpr,
    #[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,
    __Unknown__(String),
}

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

impl Validate for OptionFeatures13Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct OptionFeaturesFormat31Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<OptionFeatures13Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for OptionFeaturesFormat31Choice {}




#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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.002.15")]
pub struct OptionStyle9Choice {
    #[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<GenericIdentification47>,
}

impl Validate for OptionStyle9Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct OriginalAndCurrentQuantities4 {
    #[yaserde(rename = "FaceAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "FaceAmt"))]
    pub face_amt: RestrictedFINImpliedCurrencyAndAmount,

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

impl Validate for OriginalAndCurrentQuantities4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct OriginalAndCurrentQuantities7 {
    #[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: RestrictedFINImpliedCurrencyAndAmount,

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

impl Validate for OriginalAndCurrentQuantities7 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct OtherIdentification2 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: RestrictedFINXMax31Text,

    #[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: IdentificationSource4Choice,
}

impl Validate for OtherIdentification2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
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.002.15")]
pub struct PartyIdentification136Choice {
    #[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<GenericIdentification84>,
}

impl Validate for PartyIdentification136Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct PartyIdentification137Choice {
    #[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<GenericIdentification84>,
    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: Option<NameAndAddress12>,
}

impl Validate for PartyIdentification137Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct PartyIdentification151Choice {
    #[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<GenericIdentification84>,
    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: Option<NameAndAddress12>,
    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Option<Leiidentifier>,
}

impl Validate for PartyIdentification151Choice {}




#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
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.002.15")]
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.002.15")]
pub struct PriceCalculationMethod1Choice {
    #[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<GenericIdentification47>,
}

impl Validate for PriceCalculationMethod1Choice {}




#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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.002.15")]
pub struct PriceDetails43 {
    #[yaserde(rename = "GncCshPricPdPerPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "GncCshPricPdPerPdct"))]
    pub gnc_csh_pric_pd_per_pdct: PriceFormat93Choice,

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

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

impl Validate for PriceDetails43 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct PriceFormat58Choice {
    #[yaserde(rename = "AmtPric")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtPric"))]
    pub amt_pric: Option<AmountPrice4>,
    #[yaserde(rename = "NotSpcfdPric")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdPric"))]
    pub not_spcfd_pric: Option<PriceValueType10Code>,
}

impl Validate for PriceFormat58Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct PriceFormat62Choice {
    #[yaserde(rename = "AmtPric")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtPric"))]
    pub amt_pric: Option<AmountPrice7>,
    #[yaserde(rename = "NotSpcfdPric")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdPric"))]
    pub not_spcfd_pric: Option<PriceValueType10Code>,
}

impl Validate for PriceFormat62Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct PriceFormat91Choice {
    #[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<AmountPrice5>,
    #[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<RestrictedFINDecimalNumber>,
}

impl Validate for PriceFormat91Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct PriceFormat92Choice {
    #[yaserde(rename = "PctgPric")]
    #[cfg_attr(feature = "serde", serde(rename = "PctgPric"))]
    pub pctg_pric: Option<PercentagePrice3>,
    #[yaserde(rename = "AmtPric")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtPric"))]
    pub amt_pric: Option<AmountPrice5>,
    #[yaserde(rename = "NotSpcfdPric")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdPric"))]
    pub not_spcfd_pric: Option<PriceValueType10Code>,
}

impl Validate for PriceFormat92Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct PriceFormat93Choice {
    #[yaserde(rename = "PctgPric")]
    #[cfg_attr(feature = "serde", serde(rename = "PctgPric"))]
    pub pctg_pric: Option<PercentagePrice3>,
    #[yaserde(rename = "AmtPric")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtPric"))]
    pub amt_pric: Option<AmountPrice5>,
    #[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<RestrictedFINDecimalNumber>,
}

impl Validate for PriceFormat93Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct PriceFormat94Choice {
    #[yaserde(rename = "PctgPric")]
    #[cfg_attr(feature = "serde", serde(rename = "PctgPric"))]
    pub pctg_pric: Option<PercentagePrice3>,
    #[yaserde(rename = "AmtPric")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtPric"))]
    pub amt_pric: Option<AmountPrice5>,
    #[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<AmountPricePerFinancialInstrumentQuantity11>,
    #[yaserde(rename = "AmtPricPerAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtPricPerAmt"))]
    pub amt_pric_per_amt: Option<AmountPricePerAmount3>,
    #[yaserde(rename = "IndxPts")]
    #[cfg_attr(feature = "serde", serde(rename = "IndxPts"))]
    pub indx_pts: Option<RestrictedFINDecimalNumber>,
}

impl Validate for PriceFormat94Choice {}




#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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

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

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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.002.15")]
pub struct ProcessingPosition10Choice {
    #[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<GenericIdentification47>,
}

impl Validate for ProcessingPosition10Choice {}




#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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.002.15")]
pub struct ProprietaryQuantity10 {
    #[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: RestrictedFINDecimalNumber,

    #[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: Max4AlphaNumericText,

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

impl Validate for ProprietaryQuantity10 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct ProprietaryQuantity9 {
    #[yaserde(rename = "Qty")]
    #[cfg_attr(feature = "serde", serde(rename = "Qty"))]
    pub qty: RestrictedFINDecimalNumber,

    #[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: Max4AlphaNumericText,

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

impl Validate for ProprietaryQuantity9 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct ProrationBelowMinimumQuantity1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ProrationBelowMinimumQuantity1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for ProrationBelowMinimumQuantity1Choice {}




#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

pub enum ProrationBelowMinimumQuantity1Code {
    #[yaserde(rename = "FULL")]
    #[cfg_attr(feature = "serde", serde(rename = "FULL"))]
    Full,
    #[yaserde(rename = "MIEX")]
    #[cfg_attr(feature = "serde", serde(rename = "MIEX"))]
    Miex,
    #[yaserde(rename = "MILT")]
    #[cfg_attr(feature = "serde", serde(rename = "MILT"))]
    Milt,
    #[yaserde(rename = "REJT")]
    #[cfg_attr(feature = "serde", serde(rename = "REJT"))]
    Rejt,
    #[yaserde(rename = "UKWN")]
    #[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
    Ukwn,
    __Unknown__(String),
}

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

impl Validate for ProrationBelowMinimumQuantity1Code {}



#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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.002.15")]
pub struct Quantity53Choice {
    #[yaserde(rename = "Qty")]
    #[cfg_attr(feature = "serde", serde(rename = "Qty"))]
    pub qty: Option<FinancialInstrumentQuantity36Choice>,
    #[yaserde(rename = "PrtryQty")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryQty"))]
    pub prtry_qty: Option<ProprietaryQuantity9>,
}

impl Validate for Quantity53Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct Quantity54Choice {
    #[yaserde(rename = "Qty")]
    #[cfg_attr(feature = "serde", serde(rename = "Qty"))]
    pub qty: Option<FinancialInstrumentQuantity36Choice>,
    #[yaserde(rename = "OrgnlAndCurFace")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlAndCurFace"))]
    pub orgnl_and_cur_face: Option<OriginalAndCurrentQuantities4>,
}

impl Validate for Quantity54Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct Quantity57Choice {
    #[yaserde(rename = "OrgnlAndCurFaceAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlAndCurFaceAmt"))]
    pub orgnl_and_cur_face_amt: Option<OriginalAndCurrentQuantities7>,
    #[yaserde(rename = "SgndQty")]
    #[cfg_attr(feature = "serde", serde(rename = "SgndQty"))]
    pub sgnd_qty: Option<SignedQuantityFormat13>,
}

impl Validate for Quantity57Choice {}




#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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.002.15")]
pub struct Quantity80Choice {
    #[yaserde(rename = "QtyChc")]
    #[cfg_attr(feature = "serde", serde(rename = "QtyChc"))]
    pub qty_chc: Option<Quantity57Choice>,
    #[yaserde(rename = "PrtryQty")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryQty"))]
    pub prtry_qty: Option<ProprietaryQuantity10>,
}

impl Validate for Quantity80Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct QuantityToQuantityRatio2 {
    #[yaserde(rename = "Qty1")]
    #[cfg_attr(feature = "serde", serde(rename = "Qty1"))]
    pub qty_1: RestrictedFINDecimalNumber,

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

impl Validate for QuantityToQuantityRatio2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct Rate47 {
    #[yaserde(rename = "AddtlTax")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlTax"))]
    pub addtl_tax: RateAndAmountFormat72Choice,

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

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

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

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

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

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

    #[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: RateFormat30Choice,

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

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

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

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

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

    #[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: RateAndAmountFormat48Choice,

    #[yaserde(rename = "DmdRate")]
    #[cfg_attr(feature = "serde", serde(rename = "DmdRate"))]
    pub dmd_rate: Vec<RateAndAmountFormat77Choice>,
}

impl Validate for Rate47 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct RateAndAmountFormat48Choice {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<RestrictedFINActiveCurrencyAnd13DecimalAmount>,
    #[yaserde(rename = "NotSpcfdRate")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdRate"))]
    pub not_spcfd_rate: Option<RateValueType7Code>,
}

impl Validate for RateAndAmountFormat48Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
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.002.15")]
pub struct RateAndAmountFormat72Choice {
    #[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<RestrictedFINActiveCurrencyAnd13DecimalAmount>,
}

impl Validate for RateAndAmountFormat72Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct RateAndAmountFormat73Choice {
    #[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<RestrictedFINActiveCurrencyAnd13DecimalAmount>,
    #[yaserde(rename = "IndxPts")]
    #[cfg_attr(feature = "serde", serde(rename = "IndxPts"))]
    pub indx_pts: Option<RestrictedFINDecimalNumber>,
}

impl Validate for RateAndAmountFormat73Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct RateAndAmountFormat74Choice {
    #[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<RestrictedFINActiveCurrencyAnd13DecimalAmount>,
}

impl Validate for RateAndAmountFormat74Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct RateAndAmountFormat75Choice {
    #[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<RestrictedFINActiveCurrencyAnd13DecimalAmount>,
    #[yaserde(rename = "RateTpAndRate")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTpAndRate"))]
    pub rate_tp_and_rate: Option<RateTypeAndPercentageRate20>,
}

impl Validate for RateAndAmountFormat75Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct RateAndAmountFormat76Choice {
    #[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<RestrictedFINActiveCurrencyAnd13DecimalAmount>,
    #[yaserde(rename = "RateTpAndRate")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTpAndRate"))]
    pub rate_tp_and_rate: Option<RateTypeAndPercentageRate21>,
}

impl Validate for RateAndAmountFormat76Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct RateAndAmountFormat77Choice {
    #[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<RestrictedFINActiveCurrencyAnd13DecimalAmount>,
    #[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<RateTypeAndAmountAndStatus54>,
    #[yaserde(rename = "RateTpAndRate")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTpAndRate"))]
    pub rate_tp_and_rate: Option<RateTypeAndPercentageRate22>,
}

impl Validate for RateAndAmountFormat77Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
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.002.15")]
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.002.15")]
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.002.15")]
pub struct RateFormat30Choice {
    #[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<RestrictedFINActiveCurrencyAnd13DecimalAmount>,
    #[yaserde(rename = "NotSpcfdRate")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdRate"))]
    pub not_spcfd_rate: Option<RateValueType7Code>,
}

impl Validate for RateFormat30Choice {}




#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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.002.15")]
pub struct RateStatus4Choice {
    #[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<GenericIdentification47>,
}

impl Validate for RateStatus4Choice {}




#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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

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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.031.002.15")]
pub struct RateType45Choice {
    #[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<GenericIdentification47>,
}

impl Validate for RateType45Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct RateType46Choice {
    #[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<GenericIdentification47>,
}

impl Validate for RateType46Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct RateType47Choice {
    #[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<GenericIdentification47>,
}

impl Validate for RateType47Choice {}




#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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

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.002.15")]
pub struct RateType80Choice {
    #[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<GenericIdentification47>,
}

impl Validate for RateType80Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct RateType81Choice {
    #[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<GenericIdentification47>,
}

impl Validate for RateType81Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct RateTypeAndAmountAndStatus32 {
    #[yaserde(rename = "RateTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTp"))]
    pub rate_tp: RateType45Choice,

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

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

impl Validate for RateTypeAndAmountAndStatus32 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct RateTypeAndAmountAndStatus33 {
    #[yaserde(rename = "RateTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTp"))]
    pub rate_tp: RateType47Choice,

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

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

impl Validate for RateTypeAndAmountAndStatus33 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct RateTypeAndAmountAndStatus54 {
    #[yaserde(rename = "RateTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTp"))]
    pub rate_tp: DeemedRateType2Choice,

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

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

impl Validate for RateTypeAndAmountAndStatus54 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct RateTypeAndAmountAndStatus59 {
    #[yaserde(rename = "RateTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTp"))]
    pub rate_tp: RateType80Choice,

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

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

impl Validate for RateTypeAndAmountAndStatus59 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct RateTypeAndAmountAndStatus60 {
    #[yaserde(rename = "RateTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTp"))]
    pub rate_tp: RateType81Choice,

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

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

impl Validate for RateTypeAndAmountAndStatus60 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct RateTypeAndPercentageRate20 {
    #[yaserde(rename = "RateTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTp"))]
    pub rate_tp: RateType46Choice,

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

impl Validate for RateTypeAndPercentageRate20 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct RateTypeAndPercentageRate21 {
    #[yaserde(rename = "RateTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTp"))]
    pub rate_tp: RateType46Choice,

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

impl Validate for RateTypeAndPercentageRate21 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct RateTypeAndPercentageRate22 {
    #[yaserde(rename = "RateTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTp"))]
    pub rate_tp: DeemedRateType2Choice,

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

impl Validate for RateTypeAndPercentageRate22 {}


#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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.002.15")]
pub struct RatioFormat23Choice {
    #[yaserde(rename = "QtyToQty")]
    #[cfg_attr(feature = "serde", serde(rename = "QtyToQty"))]
    pub qty_to_qty: Option<QuantityToQuantityRatio2>,
    #[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<AmountToAmountRatio3>,
}

impl Validate for RatioFormat23Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct RatioFormat24Choice {
    #[yaserde(rename = "QtyToQty")]
    #[cfg_attr(feature = "serde", serde(rename = "QtyToQty"))]
    pub qty_to_qty: Option<QuantityToQuantityRatio2>,
    #[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<AmountToAmountRatio3>,
    #[yaserde(rename = "AmtToQty")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtToQty"))]
    pub amt_to_qty: Option<AmountAndQuantityRatio5>,
    #[yaserde(rename = "QtyToAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "QtyToAmt"))]
    pub qty_to_amt: Option<AmountAndQuantityRatio5>,
}

impl Validate for RatioFormat24Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct RenounceableEntitlementStatusTypeFormat4Choice {
    #[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<GenericIdentification47>,
}

impl Validate for RenounceableEntitlementStatusTypeFormat4Choice {}




#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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(Default, Clone, PartialEq, Debug)]
pub struct RestrictedFINActiveCurrencyAnd13DecimalAmountSimpleType (pub String);
crate::simple_type!(RestrictedFINActiveCurrencyAnd13DecimalAmountSimpleType);

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

impl Validate for RestrictedFINActiveCurrencyAnd13DecimalAmount {}


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

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

impl Validate for RestrictedFINActiveCurrencyAndAmount {}


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

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

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

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

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

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

impl Validate for RestrictedFINX2Max34Text {
    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 RestrictedFINXMax140Text (pub String);
crate::simple_type!(RestrictedFINXMax140Text);

impl Validate for RestrictedFINXMax140Text {
    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 RestrictedFINXMax16Text (pub String);
crate::simple_type!(RestrictedFINXMax16Text);

impl Validate for RestrictedFINXMax16Text {
    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 RestrictedFINXMax30Text (pub String);
crate::simple_type!(RestrictedFINXMax30Text);

impl Validate for RestrictedFINXMax30Text {
    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() > 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 RestrictedFINXMax31Text (pub String);
crate::simple_type!(RestrictedFINXMax31Text);

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

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

impl Validate for RestrictedFINXMax34Text {
    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 RestrictedFINXMax350Text (pub String);
crate::simple_type!(RestrictedFINXMax350Text);

impl Validate for RestrictedFINXMax350Text {
    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 RestrictedFINXMax35Text (pub String);
crate::simple_type!(RestrictedFINXMax35Text);

impl Validate for RestrictedFINXMax35Text {
    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 RestrictedFINZMax2048Text (pub String);
crate::simple_type!(RestrictedFINZMax2048Text);

impl Validate for RestrictedFINZMax2048Text {
    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 RestrictedFINZMax8000Text (pub String);
crate::simple_type!(RestrictedFINZMax8000Text);

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

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

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

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

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.002.15")]
pub struct SafekeepingPlaceFormat55Choice {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Option<SafekeepingPlaceTypeAndText9>,
    #[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<GenericIdentification85>,
}

impl Validate for SafekeepingPlaceFormat55Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct SafekeepingPlaceFormat56Choice {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Option<SafekeepingPlaceTypeAndText15>,
    #[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<GenericIdentification85>,
}

impl Validate for SafekeepingPlaceFormat56Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
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.002.15")]
pub struct SafekeepingPlaceTypeAndText15 {
    #[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: RestrictedFINXMax30Text,
}

impl Validate for SafekeepingPlaceTypeAndText15 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct SafekeepingPlaceTypeAndText9 {
    #[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: RestrictedFINXMax30Text,
}

impl Validate for SafekeepingPlaceTypeAndText9 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct SecuritiesOption117 {
    #[yaserde(rename = "SctyDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "SctyDtls"))]
    pub scty_dtls: FinancialInstrumentAttributes137,

    #[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: TemporaryFinancialInstrumentIndicator4Choice,

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

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

    #[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: GenericIdentification47,

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

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

    #[yaserde(rename = "EntitldQty")]
    #[cfg_attr(feature = "serde", serde(rename = "EntitldQty"))]
    pub entitld_qty: Quantity54Choice,

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

    #[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: FractionDispositionType31Choice,

    #[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: Period6Choice,

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

    #[yaserde(rename = "RateDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "RateDtls"))]
    pub rate_dtls: CorporateActionRate137,

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

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

impl Validate for SecuritiesOption117 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct SecuritiesOption84 {
    #[yaserde(rename = "MaxQtyToInst")]
    #[cfg_attr(feature = "serde", serde(rename = "MaxQtyToInst"))]
    pub max_qty_to_inst: FinancialInstrumentQuantity44Choice,

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

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

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

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

    #[yaserde(rename = "FrntEndOddLotQty")]
    #[cfg_attr(feature = "serde", serde(rename = "FrntEndOddLotQty"))]
    pub frnt_end_odd_lot_qty: FinancialInstrumentQuantity43Choice,

    #[yaserde(rename = "BckEndOddLotQty")]
    #[cfg_attr(feature = "serde", serde(rename = "BckEndOddLotQty"))]
    pub bck_end_odd_lot_qty: FinancialInstrumentQuantity43Choice,
}

impl Validate for SecuritiesOption84 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct SecurityDate24 {
    #[yaserde(rename = "PmtDt")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtDt"))]
    pub pmt_dt: DateFormat41Choice,

    #[yaserde(rename = "AvlblDt")]
    #[cfg_attr(feature = "serde", serde(rename = "AvlblDt"))]
    pub avlbl_dt: DateFormat41Choice,

    #[yaserde(rename = "DvddRnkgDt")]
    #[cfg_attr(feature = "serde", serde(rename = "DvddRnkgDt"))]
    pub dvdd_rnkg_dt: DateFormat41Choice,

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

    #[yaserde(rename = "PrpssDt")]
    #[cfg_attr(feature = "serde", serde(rename = "PrpssDt"))]
    pub prpss_dt: DateFormat41Choice,

    #[yaserde(rename = "LastTradgDt")]
    #[cfg_attr(feature = "serde", serde(rename = "LastTradgDt"))]
    pub last_tradg_dt: DateFormat41Choice,
}

impl Validate for SecurityDate24 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct SecurityIdentification20 {
    #[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<OtherIdentification2>,

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

impl Validate for SecurityIdentification20 {}


#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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.002.15")]
pub struct SignedQuantityFormat12 {
    #[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: Quantity53Choice,
}

impl Validate for SignedQuantityFormat12 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct SignedQuantityFormat13 {
    #[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: FinancialInstrumentQuantity36Choice,
}

impl Validate for SignedQuantityFormat13 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct SolicitationFeeRateFormat15Choice {
    #[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<AmountAndQuantityRatio5>,
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<RestrictedFINActiveCurrencyAnd13DecimalAmount>,
    #[yaserde(rename = "NotSpcfdRate")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdRate"))]
    pub not_spcfd_rate: Option<RateValueType7Code>,
}

impl Validate for SolicitationFeeRateFormat15Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
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.002.15")]
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.002.15")]
pub struct TaxableIncomePerShareCalculatedFormat4Choice {
    #[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<GenericIdentification47>,
}

impl Validate for TaxableIncomePerShareCalculatedFormat4Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct TemporaryFinancialInstrumentIndicator4Choice {
    #[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<GenericIdentification47>,
}

impl Validate for TemporaryFinancialInstrumentIndicator4Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct TotalEligibleBalanceFormat11 {
    #[yaserde(rename = "Bal")]
    #[cfg_attr(feature = "serde", serde(rename = "Bal"))]
    pub bal: Quantity80Choice,

    #[yaserde(rename = "FullPrdUnits")]
    #[cfg_attr(feature = "serde", serde(rename = "FullPrdUnits"))]
    pub full_prd_units: SignedQuantityFormat13,

    #[yaserde(rename = "PartWayPrdUnits")]
    #[cfg_attr(feature = "serde", serde(rename = "PartWayPrdUnits"))]
    pub part_way_prd_units: SignedQuantityFormat13,
}

impl Validate for TotalEligibleBalanceFormat11 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct UpdatedAdditionalInformation24 {
    #[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: RestrictedFINXMax350Text,
}

impl Validate for UpdatedAdditionalInformation24 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct UpdatedAdditionalInformation25 {
    #[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<RestrictedFINXMax350Text>,
}

impl Validate for UpdatedAdditionalInformation25 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct UpdatedAdditionalInformation26 {
    #[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<RestrictedFINZMax8000Text>,
}

impl Validate for UpdatedAdditionalInformation26 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.15")]
pub struct UpdatedURLlnformation7 {
    #[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: RestrictedFINZMax2048Text,
}

impl Validate for UpdatedURLlnformation7 {}


#[cfg_attr(feature = "serde", derive(serde::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.002.15")]

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 = "002";
    const VERSION: &'static str = "15";
    const MESSAGE_NAME: &'static str = "seev.031.002.15";
    const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:seev.031.002.15";
}