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

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

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

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

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

impl Validate for AccountAndBalance61 {}


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

impl Validate for ActiveCurrencyAnd13DecimalAmount {}


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

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

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

impl Validate for ActiveCurrencyAndAmount {}


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

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

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

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

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

impl Validate for AddressType2Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.033.001.14")]
pub struct AlternatePartyIdentification12 {
    #[yaserde(rename = "IdTp")]
    #[cfg_attr(feature = "serde", serde(rename = "IdTp"))]
    pub id_tp: IdentificationType42Choice,

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

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

    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Leiidentifier,
}

impl Validate for AlternatePartyIdentification12 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.033.001.14")]
pub struct AlternatePartyIdentification7 {
    #[yaserde(rename = "IdTp")]
    #[cfg_attr(feature = "serde", serde(rename = "IdTp"))]
    pub id_tp: IdentificationType42Choice,

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

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

impl Validate for AlternatePartyIdentification7 {}


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

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

impl Validate for AmountPrice3 {}


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

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

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

impl Validate for AmountPricePerAmount2 {}


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

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

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

impl Validate for AmountPricePerFinancialInstrumentQuantity10 {}


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

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

impl Validate for BalanceFormat11Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
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.033.001.14")]
pub struct BeneficiaryCertificationType10Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<BeneficiaryCertificationType5Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification30>,
}

impl Validate for BeneficiaryCertificationType10Choice {}




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

pub enum BeneficiaryCertificationType5Code {
    #[yaserde(rename = "ACCI")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCI"))]
    Acci,
    #[yaserde(rename = "NCOM")]
    #[cfg_attr(feature = "serde", serde(rename = "NCOM"))]
    Ncom,
    #[yaserde(rename = "QIBB")]
    #[cfg_attr(feature = "serde", serde(rename = "QIBB"))]
    Qibb,
    __Unknown__(String),
}

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

impl Validate for BeneficiaryCertificationType5Code {}



#[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.033.001.14")]
pub struct ClassificationType32Choice {
    #[yaserde(rename = "ClssfctnFinInstrm")]
    #[cfg_attr(feature = "serde", serde(rename = "ClssfctnFinInstrm"))]
    pub clssfctn_fin_instrm: Option<Cfioct2015Identifier>,
    #[yaserde(rename = "AltrnClssfctn")]
    #[cfg_attr(feature = "serde", serde(rename = "AltrnClssfctn"))]
    pub altrn_clssfctn: Option<GenericIdentification36>,
}

impl Validate for ClassificationType32Choice {}




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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Validate for CorporateActionBalanceDetails42 {}


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

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

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

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

impl Validate for CorporateActionChangeTypeFormat6Choice {}




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

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

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

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

impl Validate for CorporateActionEventType112Choice {}




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

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

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

impl Validate for CorporateActionEventType40Code {}



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

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

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

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

impl Validate for CorporateActionGeneralInformation180 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.033.001.14")]
pub struct CorporateActionInstructionV14 {
    #[yaserde(rename = "ChngInstrInd")]
    #[cfg_attr(feature = "serde", serde(rename = "ChngInstrInd"))]
    pub chng_instr_ind: YesNoIndicator,

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

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

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

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

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

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

    #[yaserde(rename = "BnfclOwnrDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "BnfclOwnrDtls"))]
    pub bnfcl_ownr_dtls: Vec<PartyIdentification340>,

    #[yaserde(rename = "CorpActnInstr")]
    #[cfg_attr(feature = "serde", serde(rename = "CorpActnInstr"))]
    pub corp_actn_instr: CorporateActionOption237,

    #[yaserde(rename = "PrtctInstr")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtctInstr"))]
    pub prtct_instr: ProtectInstruction1,

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

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

impl Validate for CorporateActionInstructionV14 {}


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

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

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

impl Validate for CorporateActionNarrative30 {}


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

    #[yaserde(rename = "DlvryDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "DlvryDtls"))]
    pub dlvry_dtls: Vec<Max350Text>,

    #[yaserde(rename = "FXInstrsAddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "FXInstrsAddtlInf"))]
    pub fx_instrs_addtl_inf: Vec<Max350Text>,

    #[yaserde(rename = "InstrAddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "InstrAddtlInf"))]
    pub instr_addtl_inf: Vec<Max350Text>,
}

impl Validate for CorporateActionNarrative32 {}


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

pub enum CorporateActionOption16Code {
    #[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 = "CERT")]
    #[cfg_attr(feature = "serde", serde(rename = "CERT"))]
    Cert,
    #[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 = "MKDW")]
    #[cfg_attr(feature = "serde", serde(rename = "MKDW"))]
    Mkdw,
    #[yaserde(rename = "MKUP")]
    #[cfg_attr(feature = "serde", serde(rename = "MKUP"))]
    Mkup,
    #[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 = "TAXI")]
    #[cfg_attr(feature = "serde", serde(rename = "TAXI"))]
    Taxi,
    #[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 CorporateActionOption16Code {
    fn default() -> CorporateActionOption16Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for CorporateActionOption16Code {}



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

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

    #[yaserde(rename = "OptnFeatrs")]
    #[cfg_attr(feature = "serde", serde(rename = "OptnFeatrs"))]
    pub optn_featrs: OptionFeaturesFormat25Choice,

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

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

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

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

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

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

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

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

    #[yaserde(rename = "SctiesQtyOrInstdAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesQtyOrInstdAmt"))]
    pub scties_qty_or_instd_amt: SecuritiesQuantityOrAmount6Choice,

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

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

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

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

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

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

impl Validate for CorporateActionOption40Choice {}




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

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

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

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

impl Validate for CorporateActionPrice88 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.033.001.14")]
pub struct CorporateActionRate127 {
    #[yaserde(rename = "PropsdRate")]
    #[cfg_attr(feature = "serde", serde(rename = "PropsdRate"))]
    pub propsd_rate: Percentage14Rate,

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

    #[yaserde(rename = "ReqdWhldgTaxRate")]
    #[cfg_attr(feature = "serde", serde(rename = "ReqdWhldgTaxRate"))]
    pub reqd_whldg_tax_rate: Vec<RateAndAmountFormat55Choice>,

    #[yaserde(rename = "ReqdScndLvlTaxRate")]
    #[cfg_attr(feature = "serde", serde(rename = "ReqdScndLvlTaxRate"))]
    pub reqd_scnd_lvl_tax_rate: Vec<RateAndAmountFormat55Choice>,
}

impl Validate for CorporateActionRate127 {}


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

impl Validate for CountryCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct 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.033.001.14")]
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)]
pub struct DecimalNumber (pub String);
crate::simple_type!(DecimalNumber);

impl Validate for DecimalNumber {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.033.001.14")]
pub struct Document {
    #[yaserde(rename = "CorpActnInstr")]
    #[cfg_attr(feature = "serde", serde(rename = "CorpActnInstr"))]
    pub corp_actn_instr: CorporateActionInstructionV14,
}

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

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

impl Validate for DocumentIdentification31 {}


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

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

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

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

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

impl Validate for DocumentNumber5Choice {}




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

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

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

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

    #[yaserde(rename = "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 = "PrvsFctr")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvsFctr"))]
    pub prvs_fctr: BaseOne14Rate,

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

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

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

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

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

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

impl Validate for FinancialInstrumentQuantity33Choice {}




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

pub enum FractionDispositionType10Code {
    #[yaserde(rename = "BUYU")]
    #[cfg_attr(feature = "serde", serde(rename = "BUYU"))]
    Buyu,
    #[yaserde(rename = "CINL")]
    #[cfg_attr(feature = "serde", serde(rename = "CINL"))]
    Cinl,
    #[yaserde(rename = "EXPI")]
    #[cfg_attr(feature = "serde", serde(rename = "EXPI"))]
    Expi,
    #[yaserde(rename = "DIST")]
    #[cfg_attr(feature = "serde", serde(rename = "DIST"))]
    Dist,
    __Unknown__(String),
}

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

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

impl Validate for FractionDispositionType28Choice {}




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

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

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

impl Validate for GenericIdentification30 {}


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

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

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

impl Validate for GenericIdentification36 {}


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

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

impl Validate for GenericIdentification78 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
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 Isodate (pub String);
crate::simple_type!(Isodate);

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

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

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

impl Validate for IdentificationType42Choice {}




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

impl Validate for ImpliedCurrencyAndAmount {
    fn validate(&self) -> Result<(), String> { 
        if self.0 < "0".parse::<String>().unwrap() {
            return Err(format!("MinInclusive validation error: invalid value of 0! \nExpected: 0 >= 0.\nActual: 0 == {}", self.0));
        }
        Ok(())
    }
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.033.001.14")]
pub struct IndicativeOrMarketPrice13Choice {
    #[yaserde(rename = "IndctvPric")]
    #[cfg_attr(feature = "serde", serde(rename = "IndctvPric"))]
    pub indctv_pric: Option<PriceFormat77Choice>,
    #[yaserde(rename = "MktPric")]
    #[cfg_attr(feature = "serde", serde(rename = "MktPric"))]
    pub mkt_pric: Option<PriceFormat77Choice>,
}

impl Validate for IndicativeOrMarketPrice13Choice {}




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

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.033.001.14")]
pub struct InterestComputationMethodFormat4Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<InterestComputationMethod2Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification30>,
}

impl Validate for InterestComputationMethodFormat4Choice {}




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

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

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

impl Validate for MarketIdentification3Choice {}




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

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

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

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

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

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct 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 Max35Text (pub String);
crate::simple_type!(Max35Text);

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

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct 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.033.001.14")]
pub struct NameAndAddress5 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max350Text,

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

impl Validate for NameAndAddress5 {}


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

pub enum OptionFeatures12Code {
    #[yaserde(rename = "OPLF")]
    #[cfg_attr(feature = "serde", serde(rename = "OPLF"))]
    Oplf,
    __Unknown__(String),
}

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

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

impl Validate for OptionFeaturesFormat25Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.033.001.14")]
pub struct OptionNumber1Choice {
    #[yaserde(rename = "Nb")]
    #[cfg_attr(feature = "serde", serde(rename = "Nb"))]
    pub nb: Option<Exact3NumericText>,
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<OptionNumber1Code>,
}

impl Validate for OptionNumber1Choice {}




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

pub enum OptionNumber1Code {
    #[yaserde(rename = "UNSO")]
    #[cfg_attr(feature = "serde", serde(rename = "UNSO"))]
    Unso,
    __Unknown__(String),
}

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

impl Validate for OptionNumber1Code {}



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

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

impl Validate for OriginalAndCurrentQuantities1 {}


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

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

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

impl Validate for OriginalAndCurrentQuantities6 {}


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

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

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

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

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

impl Validate for PartyIdentification263Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.033.001.14")]
pub struct PartyIdentification340 {
    #[yaserde(rename = "OwnrId")]
    #[cfg_attr(feature = "serde", serde(rename = "OwnrId"))]
    pub ownr_id: PartyIdentification263Choice,

    #[yaserde(rename = "AltrnId")]
    #[cfg_attr(feature = "serde", serde(rename = "AltrnId"))]
    pub altrn_id: Vec<AlternatePartyIdentification12>,

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

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

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

    #[yaserde(rename = "CertfctnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CertfctnTp"))]
    pub certfctn_tp: Vec<BeneficiaryCertificationType10Choice>,

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

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

impl Validate for PartyIdentification340 {}


#[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.033.001.14")]
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.033.001.14")]
pub struct PostalAddress1 {
    #[yaserde(rename = "AdrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "AdrTp"))]
    pub adr_tp: AddressType2Code,

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

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

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

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

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

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

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

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

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

impl Validate for PriceFormat78Choice {}




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

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

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

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

impl Validate for PriceValueType9Code {}



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

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.033.001.14")]
pub struct ProcessingPosition7Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ProcessingPosition3Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification30>,
}

impl Validate for ProcessingPosition7Choice {}




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

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

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

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

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

impl Validate for ProprietaryQuantity7 {}


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

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

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

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

impl Validate for ProprietaryQuantity8 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.033.001.14")]
pub struct ProtectInstruction1 {
    #[yaserde(rename = "TxTp")]
    #[cfg_attr(feature = "serde", serde(rename = "TxTp"))]
    pub tx_tp: ProtectTransactionType2Code,

    #[yaserde(rename = "TxId")]
    #[cfg_attr(feature = "serde", serde(rename = "TxId"))]
    pub tx_id: Max15Text,

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

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

impl Validate for ProtectInstruction1 {}


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

pub enum ProtectTransactionType2Code {
    #[yaserde(rename = "PROT")]
    #[cfg_attr(feature = "serde", serde(rename = "PROT"))]
    Prot,
    #[yaserde(rename = "COVP")]
    #[cfg_attr(feature = "serde", serde(rename = "COVP"))]
    Covp,
    #[yaserde(rename = "COVR")]
    #[cfg_attr(feature = "serde", serde(rename = "COVR"))]
    Covr,
    __Unknown__(String),
}

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

impl Validate for ProtectTransactionType2Code {}



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

pub enum Quantity1Code {
    #[yaserde(rename = "QALL")]
    #[cfg_attr(feature = "serde", serde(rename = "QALL"))]
    Qall,
    __Unknown__(String),
}

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

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

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

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

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

impl Validate for Quantity52Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.033.001.14")]
pub struct RateAndAmountFormat55Choice {
    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: Option<Percentage14Rate>,
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<ActiveCurrencyAnd13DecimalAmount>,
    #[yaserde(rename = "RateTpAndRate")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTpAndRate"))]
    pub rate_tp_and_rate: Option<RateTypeAndPercentageRate12>,
}

impl Validate for RateAndAmountFormat55Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.033.001.14")]
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.033.001.14")]
pub struct RateAndAmountFormat59Choice {
    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: Option<Percentage14Rate>,
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<ActiveCurrencyAnd13DecimalAmount>,
}

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

impl Validate for RateType42Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.033.001.14")]
pub struct RateTypeAndPercentageRate12 {
    #[yaserde(rename = "RateTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTp"))]
    pub rate_tp: RateType42Choice,

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

impl Validate for RateTypeAndPercentageRate12 {}


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

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

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

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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.033.001.14")]
pub struct SafekeepingPlaceFormat42Choice {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Option<SafekeepingPlaceTypeAndText6>,
    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: Option<CountryCode>,
    #[yaserde(rename = "DgtlLdgrId")]
    #[cfg_attr(feature = "serde", serde(rename = "DgtlLdgrId"))]
    pub dgtl_ldgr_id: Option<Dti2024Identifier>,
    #[yaserde(rename = "TpAndId")]
    #[cfg_attr(feature = "serde", serde(rename = "TpAndId"))]
    pub tp_and_id: Option<SafekeepingPlaceTypeAndIdentification1>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification78>,
}

impl Validate for SafekeepingPlaceFormat42Choice {}




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

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

impl Validate for SafekeepingPlaceTypeAndText6 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.033.001.14")]
pub struct SecuritiesOption79 {
    #[yaserde(rename = "CondlQty")]
    #[cfg_attr(feature = "serde", serde(rename = "CondlQty"))]
    pub condl_qty: FinancialInstrumentQuantity33Choice,

    #[yaserde(rename = "InstdQty")]
    #[cfg_attr(feature = "serde", serde(rename = "InstdQty"))]
    pub instd_qty: Quantity52Choice,

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

impl Validate for SecuritiesOption79 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.033.001.14")]
pub struct SecuritiesQuantityOrAmount6Choice {
    #[yaserde(rename = "SctiesQty")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesQty"))]
    pub scties_qty: Option<SecuritiesOption79>,
    #[yaserde(rename = "InstdAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "InstdAmt"))]
    pub instd_amt: Option<ActiveCurrencyAndAmount>,
}

impl Validate for SecuritiesQuantityOrAmount6Choice {}




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

    #[yaserde(rename = "OthrId")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrId"))]
    pub othr_id: Vec<OtherIdentification1>,

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

impl Validate for SecurityIdentification19 {}


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

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.033.001.14")]
pub struct SignedQuantityFormat10 {
    #[yaserde(rename = "ShrtLngPos")]
    #[cfg_attr(feature = "serde", serde(rename = "ShrtLngPos"))]
    pub shrt_lng_pos: ShortLong1Code,

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

impl Validate for SignedQuantityFormat10 {}


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

    #[yaserde(rename = "QtyChc")]
    #[cfg_attr(feature = "serde", serde(rename = "QtyChc"))]
    pub qty_chc: Quantity48Choice,
}

impl Validate for SignedQuantityFormat11 {}


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

impl Validate for SupplementaryDataEnvelope1 {}


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

pub enum TypeOfIdentification1Code {
    #[yaserde(rename = "ARNU")]
    #[cfg_attr(feature = "serde", serde(rename = "ARNU"))]
    Arnu,
    #[yaserde(rename = "CCPT")]
    #[cfg_attr(feature = "serde", serde(rename = "CCPT"))]
    Ccpt,
    #[yaserde(rename = "CHTY")]
    #[cfg_attr(feature = "serde", serde(rename = "CHTY"))]
    Chty,
    #[yaserde(rename = "CORP")]
    #[cfg_attr(feature = "serde", serde(rename = "CORP"))]
    Corp,
    #[yaserde(rename = "DRLC")]
    #[cfg_attr(feature = "serde", serde(rename = "DRLC"))]
    Drlc,
    #[yaserde(rename = "FIIN")]
    #[cfg_attr(feature = "serde", serde(rename = "FIIN"))]
    Fiin,
    #[yaserde(rename = "TXID")]
    #[cfg_attr(feature = "serde", serde(rename = "TXID"))]
    Txid,
    __Unknown__(String),
}

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

impl Validate for TypeOfIdentification1Code {}



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

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 = "033";
    const VARIANT: &'static str = "001";
    const VERSION: &'static str = "14";
    const MESSAGE_NAME: &'static str = "seev.033.001.14";
    const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:seev.033.001.14";
}