rust_iso20022 0.1.1

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

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

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

impl Validate for ActiveOrHistoricCurrencyAndAmount {}


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

impl Validate for ActiveOrHistoricCurrencyCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct AdditionalParameters26 {
    #[yaserde(rename = "PreConf")]
    #[cfg_attr(feature = "serde", serde(rename = "PreConf"))]
    pub pre_conf: PreConfirmation1Code,

    #[yaserde(rename = "PrtlSttlm")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtlSttlm"))]
    pub prtl_sttlm: PartialSettlement2Code,

    #[yaserde(rename = "PrvsPrtlConfId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvsPrtlConfId"))]
    pub prvs_prtl_conf_id: RestrictedFINXMax16Text,
}

impl Validate for AdditionalParameters26 {}


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

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

impl Validate for AlternatePartyIdentification9 {}


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

    #[yaserde(rename = "CdtDbt")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtDbt"))]
    pub cdt_dbt: CreditDebitCode,
}

impl Validate for AmountAndDirection19 {}


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

    #[yaserde(rename = "CdtDbtInd")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtDbtInd"))]
    pub cdt_dbt_ind: CreditDebitCode,

    #[yaserde(rename = "OrgnlCcyAndOrdrdAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlCcyAndOrdrdAmt"))]
    pub orgnl_ccy_and_ordrd_amt: ActiveOrHistoricCurrencyAndAmount,

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

impl Validate for AmountAndDirection44 {}


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

    #[yaserde(rename = "CdtDbtInd")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtDbtInd"))]
    pub cdt_dbt_ind: CreditDebitCode,

    #[yaserde(rename = "OrgnlCcyAndOrdrdAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlCcyAndOrdrdAmt"))]
    pub orgnl_ccy_and_ordrd_amt: RestrictedFINActiveOrHistoricCurrencyAndAmount,

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

impl Validate for AmountAndDirection58 {}


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

    #[yaserde(rename = "CdtDbtInd")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtDbtInd"))]
    pub cdt_dbt_ind: CreditDebitCode,
}

impl Validate for AmountAndDirection59 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct AmountAndDirection96 {
    #[yaserde(rename = "AcrdIntrstInd")]
    #[cfg_attr(feature = "serde", serde(rename = "AcrdIntrstInd"))]
    pub acrd_intrst_ind: YesNoIndicator,

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

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

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

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

    #[yaserde(rename = "CdtDbtInd")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtDbtInd"))]
    pub cdt_dbt_ind: CreditDebitCode,

    #[yaserde(rename = "OrgnlCcyAndOrdrdAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlCcyAndOrdrdAmt"))]
    pub orgnl_ccy_and_ordrd_amt: RestrictedFINActiveOrHistoricCurrencyAndAmount,

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

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

impl Validate for AmountAndDirection96 {}


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

pub enum AutoBorrowing1Code {
    #[yaserde(rename = "LAMI")]
    #[cfg_attr(feature = "serde", serde(rename = "LAMI"))]
    Lami,
    #[yaserde(rename = "NBOR")]
    #[cfg_attr(feature = "serde", serde(rename = "NBOR"))]
    Nbor,
    #[yaserde(rename = "YBOR")]
    #[cfg_attr(feature = "serde", serde(rename = "YBOR"))]
    Ybor,
    __Unknown__(String),
}

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

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

impl Validate for AutomaticBorrowing8Choice {}




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

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

impl Validate for BaseOneRate {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct BeneficialOwnership5Choice {
    #[yaserde(rename = "Ind")]
    #[cfg_attr(feature = "serde", serde(rename = "Ind"))]
    pub ind: Option<YesNoIndicator>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for BeneficialOwnership5Choice {}




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

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

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

impl Validate for BlockChainAddressWallet7 {}


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

pub enum BlockTrade1Code {
    #[yaserde(rename = "BLPA")]
    #[cfg_attr(feature = "serde", serde(rename = "BLPA"))]
    Blpa,
    #[yaserde(rename = "BLCH")]
    #[cfg_attr(feature = "serde", serde(rename = "BLCH"))]
    Blch,
    __Unknown__(String),
}

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

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

impl Validate for BlockTrade5Choice {}




#[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:sese.035.002.11")]
pub struct CashAccountIdentification6Choice {
    #[yaserde(rename = "IBAN")]
    #[cfg_attr(feature = "serde", serde(rename = "IBAN"))]
    pub iban: Option<Iban2007Identifier>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<RestrictedFINX2Max34Text>,
}

impl Validate for CashAccountIdentification6Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct CashParties38 {
    #[yaserde(rename = "Dbtr")]
    #[cfg_attr(feature = "serde", serde(rename = "Dbtr"))]
    pub dbtr: PartyIdentificationAndAccount177,

    #[yaserde(rename = "DbtrAgt")]
    #[cfg_attr(feature = "serde", serde(rename = "DbtrAgt"))]
    pub dbtr_agt: PartyIdentificationAndAccount178,

    #[yaserde(rename = "Cdtr")]
    #[cfg_attr(feature = "serde", serde(rename = "Cdtr"))]
    pub cdtr: PartyIdentificationAndAccount177,

    #[yaserde(rename = "CdtrAgt")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtrAgt"))]
    pub cdtr_agt: PartyIdentificationAndAccount178,

    #[yaserde(rename = "Intrmy")]
    #[cfg_attr(feature = "serde", serde(rename = "Intrmy"))]
    pub intrmy: PartyIdentificationAndAccount178,
}

impl Validate for CashParties38 {}


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

pub enum CashSettlementSystem2Code {
    #[yaserde(rename = "GROS")]
    #[cfg_attr(feature = "serde", serde(rename = "GROS"))]
    Gros,
    #[yaserde(rename = "NETS")]
    #[cfg_attr(feature = "serde", serde(rename = "NETS"))]
    Nets,
    __Unknown__(String),
}

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

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

impl Validate for CashSettlementSystem5Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct CentralCounterPartyEligibility5Choice {
    #[yaserde(rename = "Ind")]
    #[cfg_attr(feature = "serde", serde(rename = "Ind"))]
    pub ind: Option<YesNoIndicator>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

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

impl Validate for ClassificationType33Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct Counterparty16Choice {
    #[yaserde(rename = "Sellr")]
    #[cfg_attr(feature = "serde", serde(rename = "Sellr"))]
    pub sellr: Option<PartyIdentificationAndAccount206>,
    #[yaserde(rename = "Buyr")]
    #[cfg_attr(feature = "serde", serde(rename = "Buyr"))]
    pub buyr: Option<PartyIdentificationAndAccount206>,
}

impl Validate for Counterparty16Choice {}




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

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

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

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

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

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

impl Validate for DateCode32Choice {}




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

pub enum DateType3Code {
    #[yaserde(rename = "VARI")]
    #[cfg_attr(feature = "serde", serde(rename = "VARI"))]
    Vari,
    __Unknown__(String),
}

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

impl Validate for DateType3Code {}



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

pub enum DateType5Code {
    #[yaserde(rename = "OPEN")]
    #[cfg_attr(feature = "serde", serde(rename = "OPEN"))]
    Open,
    __Unknown__(String),
}

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

impl Validate for DateType5Code {}



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

pub enum DeliveryReceiptType2Code {
    #[yaserde(rename = "FREE")]
    #[cfg_attr(feature = "serde", serde(rename = "FREE"))]
    Free,
    #[yaserde(rename = "APMT")]
    #[cfg_attr(feature = "serde", serde(rename = "APMT"))]
    Apmt,
    __Unknown__(String),
}

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

impl Validate for DeliveryReceiptType2Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct Document {
    #[yaserde(rename = "SctiesFincgConf")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesFincgConf"))]
    pub scties_fincg_conf: SecuritiesFinancingConfirmation002V11,
}

impl Validate for Document {}


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

pub enum Eligibility1Code {
    #[yaserde(rename = "ELIG")]
    #[cfg_attr(feature = "serde", serde(rename = "ELIG"))]
    Elig,
    #[yaserde(rename = "RETL")]
    #[cfg_attr(feature = "serde", serde(rename = "RETL"))]
    Retl,
    #[yaserde(rename = "PROF")]
    #[cfg_attr(feature = "serde", serde(rename = "PROF"))]
    Prof,
    __Unknown__(String),
}

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

impl Validate for Eligibility1Code {}



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

pub enum EventFrequency3Code {
    #[yaserde(rename = "YEAR")]
    #[cfg_attr(feature = "serde", serde(rename = "YEAR"))]
    Year,
    #[yaserde(rename = "MNTH")]
    #[cfg_attr(feature = "serde", serde(rename = "MNTH"))]
    Mnth,
    #[yaserde(rename = "QUTR")]
    #[cfg_attr(feature = "serde", serde(rename = "QUTR"))]
    Qutr,
    #[yaserde(rename = "SEMI")]
    #[cfg_attr(feature = "serde", serde(rename = "SEMI"))]
    Semi,
    #[yaserde(rename = "WEEK")]
    #[cfg_attr(feature = "serde", serde(rename = "WEEK"))]
    Week,
    __Unknown__(String),
}

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

impl Validate for EventFrequency3Code {}



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

impl Validate for Exact4NumericText {}
#[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:sese.035.002.11")]
pub struct FinancialInstrumentAttributes122 {
    #[yaserde(rename = "PlcOfListg")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcOfListg"))]
    pub plc_of_listg: MarketIdentification4Choice,

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

    #[yaserde(rename = "RegnForm")]
    #[cfg_attr(feature = "serde", serde(rename = "RegnForm"))]
    pub regn_form: FormOfSecurity7Choice,

    #[yaserde(rename = "PmtFrqcy")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtFrqcy"))]
    pub pmt_frqcy: Frequency27Choice,

    #[yaserde(rename = "PmtSts")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtSts"))]
    pub pmt_sts: SecuritiesPaymentStatus6Choice,

    #[yaserde(rename = "VarblRateChngFrqcy")]
    #[cfg_attr(feature = "serde", serde(rename = "VarblRateChngFrqcy"))]
    pub varbl_rate_chng_frqcy: Frequency27Choice,

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

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

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

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

    #[yaserde(rename = "CpnDt")]
    #[cfg_attr(feature = "serde", serde(rename = "CpnDt"))]
    pub 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 = "FrstPmtDt")]
    #[cfg_attr(feature = "serde", serde(rename = "FrstPmtDt"))]
    pub frst_pmt_dt: Isodate,

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

    #[yaserde(rename = "CurFctr")]
    #[cfg_attr(feature = "serde", serde(rename = "CurFctr"))]
    pub cur_fctr: BaseOneRate,

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

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

    #[yaserde(rename = "YldToMtrtyRate")]
    #[cfg_attr(feature = "serde", serde(rename = "YldToMtrtyRate"))]
    pub yld_to_mtrty_rate: PercentageRate,

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

    #[yaserde(rename = "IndxRateBsis")]
    #[cfg_attr(feature = "serde", serde(rename = "IndxRateBsis"))]
    pub indx_rate_bsis: PercentageRate,

    #[yaserde(rename = "CpnAttchdNb")]
    #[cfg_attr(feature = "serde", serde(rename = "CpnAttchdNb"))]
    pub cpn_attchd_nb: Number23Choice,

    #[yaserde(rename = "PoolNb")]
    #[cfg_attr(feature = "serde", serde(rename = "PoolNb"))]
    pub pool_nb: GenericIdentification39,

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

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

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

    #[yaserde(rename = "MktOrIndctvPric")]
    #[cfg_attr(feature = "serde", serde(rename = "MktOrIndctvPric"))]
    pub mkt_or_indctv_pric: PriceType5Choice,

    #[yaserde(rename = "ExrcPric")]
    #[cfg_attr(feature = "serde", serde(rename = "ExrcPric"))]
    pub exrc_pric: Price3,

    #[yaserde(rename = "SbcptPric")]
    #[cfg_attr(feature = "serde", serde(rename = "SbcptPric"))]
    pub sbcpt_pric: Price3,

    #[yaserde(rename = "ConvsPric")]
    #[cfg_attr(feature = "serde", serde(rename = "ConvsPric"))]
    pub convs_pric: Price3,

    #[yaserde(rename = "StrkPric")]
    #[cfg_attr(feature = "serde", serde(rename = "StrkPric"))]
    pub strk_pric: Price3,

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

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

    #[yaserde(rename = "UndrlygFinInstrmId")]
    #[cfg_attr(feature = "serde", serde(rename = "UndrlygFinInstrmId"))]
    pub undrlyg_fin_instrm_id: Vec<SecurityIdentification20>,

    #[yaserde(rename = "FinInstrmAttrAddtlDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrmAttrAddtlDtls"))]
    pub fin_instrm_attr_addtl_dtls: RestrictedFINXMax350Text,
}

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

impl Validate for FinancialInstrumentQuantity36Choice {}




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

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

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

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

impl Validate for ForeignExchangeTerms23 {}


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

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

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

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

impl Validate for ForeignExchangeTerms27 {}


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

pub enum FormOfSecurity1Code {
    #[yaserde(rename = "BEAR")]
    #[cfg_attr(feature = "serde", serde(rename = "BEAR"))]
    Bear,
    #[yaserde(rename = "REGD")]
    #[cfg_attr(feature = "serde", serde(rename = "REGD"))]
    Regd,
    __Unknown__(String),
}

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

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

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

impl Validate for Frequency27Choice {}




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

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

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

impl Validate for GenericIdentification18 {}


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

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

impl Validate for GenericIdentification39 {}


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

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

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

impl Validate for GenericIdentification47 {}


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

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

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

impl Validate for GenericIdentification84 {}


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

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

impl Validate for GenericIdentification85 {}


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

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

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

impl Validate for GenericIdentification86 {}


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

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

impl Validate for Isinoct2015Identifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct 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:sese.035.002.11")]
pub struct IdentificationSource4Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ExternalFinancialInstrumentIdentificationType1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<RestrictedFINExact2Text>,
}

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

impl Validate for IdentificationType44Choice {}




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

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

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

impl Validate for InvestorCapacity5Choice {}




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

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

pub enum LegalFramework1Code {
    #[yaserde(rename = "FRAN")]
    #[cfg_attr(feature = "serde", serde(rename = "FRAN"))]
    Fran,
    __Unknown__(String),
}

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

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

impl Validate for LegalFramework4Choice {}




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

pub enum MarketClientSide1Code {
    #[yaserde(rename = "CLNT")]
    #[cfg_attr(feature = "serde", serde(rename = "CLNT"))]
    Clnt,
    #[yaserde(rename = "MAKT")]
    #[cfg_attr(feature = "serde", serde(rename = "MAKT"))]
    Makt,
    __Unknown__(String),
}

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

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

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

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

impl Validate for MarketIdentification4Choice {}




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

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

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

impl Validate for MarketType16Choice {}




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

pub enum MarketType2Code {
    #[yaserde(rename = "PRIM")]
    #[cfg_attr(feature = "serde", serde(rename = "PRIM"))]
    Prim,
    #[yaserde(rename = "SECM")]
    #[cfg_attr(feature = "serde", serde(rename = "SECM"))]
    Secm,
    #[yaserde(rename = "OTCO")]
    #[cfg_attr(feature = "serde", serde(rename = "OTCO"))]
    Otco,
    #[yaserde(rename = "VARI")]
    #[cfg_attr(feature = "serde", serde(rename = "VARI"))]
    Vari,
    #[yaserde(rename = "EXCH")]
    #[cfg_attr(feature = "serde", serde(rename = "EXCH"))]
    Exch,
    __Unknown__(String),
}

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

impl Validate for MarketType2Code {}



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

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

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

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

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

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

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

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

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

impl Validate for NameAndAddress12 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct NettingEligibility5Choice {
    #[yaserde(rename = "Ind")]
    #[cfg_attr(feature = "serde", serde(rename = "Ind"))]
    pub ind: Option<YesNoIndicator>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for NettingEligibility5Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct Number23Choice {
    #[yaserde(rename = "Shrt")]
    #[cfg_attr(feature = "serde", serde(rename = "Shrt"))]
    pub shrt: Option<Exact3NumericText>,
    #[yaserde(rename = "Lng")]
    #[cfg_attr(feature = "serde", serde(rename = "Lng"))]
    pub lng: Option<GenericIdentification18>,
}

impl Validate for Number23Choice {}




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

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

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

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

impl Validate for OptionStyle9Choice {}




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

pub enum OptionType1Code {
    #[yaserde(rename = "CALL")]
    #[cfg_attr(feature = "serde", serde(rename = "CALL"))]
    Call,
    #[yaserde(rename = "PUTO")]
    #[cfg_attr(feature = "serde", serde(rename = "PUTO"))]
    Puto,
    __Unknown__(String),
}

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

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

impl Validate for OptionType7Choice {}




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

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

impl Validate for OriginalAndCurrentQuantities4 {}


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

pub enum OriginatorRole2Code {
    #[yaserde(rename = "SINT")]
    #[cfg_attr(feature = "serde", serde(rename = "SINT"))]
    Sint,
    #[yaserde(rename = "MLTF")]
    #[cfg_attr(feature = "serde", serde(rename = "MLTF"))]
    Mltf,
    #[yaserde(rename = "RMKT")]
    #[cfg_attr(feature = "serde", serde(rename = "RMKT"))]
    Rmkt,
    #[yaserde(rename = "MKTM")]
    #[cfg_attr(feature = "serde", serde(rename = "MKTM"))]
    Mktm,
    #[yaserde(rename = "INVE")]
    #[cfg_attr(feature = "serde", serde(rename = "INVE"))]
    Inve,
    #[yaserde(rename = "TAGT")]
    #[cfg_attr(feature = "serde", serde(rename = "TAGT"))]
    Tagt,
    __Unknown__(String),
}

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

impl Validate for OriginatorRole2Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct OtherAmounts42 {
    #[yaserde(rename = "AcrdIntrstAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "AcrdIntrstAmt"))]
    pub acrd_intrst_amt: AmountAndDirection58,

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

    #[yaserde(rename = "CtryNtlFdrlTax")]
    #[cfg_attr(feature = "serde", serde(rename = "CtryNtlFdrlTax"))]
    pub ctry_ntl_fdrl_tax: AmountAndDirection58,

    #[yaserde(rename = "TradAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "TradAmt"))]
    pub trad_amt: AmountAndDirection58,

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

    #[yaserde(rename = "IsseDscntAllwnc")]
    #[cfg_attr(feature = "serde", serde(rename = "IsseDscntAllwnc"))]
    pub isse_dscnt_allwnc: AmountAndDirection58,

    #[yaserde(rename = "PmtLevyTax")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtLevyTax"))]
    pub pmt_levy_tax: AmountAndDirection58,

    #[yaserde(rename = "LclTax")]
    #[cfg_attr(feature = "serde", serde(rename = "LclTax"))]
    pub lcl_tax: AmountAndDirection58,

    #[yaserde(rename = "LclBrkrComssn")]
    #[cfg_attr(feature = "serde", serde(rename = "LclBrkrComssn"))]
    pub lcl_brkr_comssn: AmountAndDirection58,

    #[yaserde(rename = "Mrgn")]
    #[cfg_attr(feature = "serde", serde(rename = "Mrgn"))]
    pub mrgn: AmountAndDirection58,

    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: AmountAndDirection58,

    #[yaserde(rename = "RgltryAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "RgltryAmt"))]
    pub rgltry_amt: AmountAndDirection58,

    #[yaserde(rename = "ShppgAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "ShppgAmt"))]
    pub shppg_amt: AmountAndDirection58,

    #[yaserde(rename = "SpclCncssn")]
    #[cfg_attr(feature = "serde", serde(rename = "SpclCncssn"))]
    pub spcl_cncssn: AmountAndDirection58,

    #[yaserde(rename = "StmpDty")]
    #[cfg_attr(feature = "serde", serde(rename = "StmpDty"))]
    pub stmp_dty: AmountAndDirection58,

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

    #[yaserde(rename = "TrfTax")]
    #[cfg_attr(feature = "serde", serde(rename = "TrfTax"))]
    pub trf_tax: AmountAndDirection58,

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

    #[yaserde(rename = "ValAddedTax")]
    #[cfg_attr(feature = "serde", serde(rename = "ValAddedTax"))]
    pub val_added_tax: AmountAndDirection58,

    #[yaserde(rename = "WhldgTax")]
    #[cfg_attr(feature = "serde", serde(rename = "WhldgTax"))]
    pub whldg_tax: AmountAndDirection58,

    #[yaserde(rename = "NetGnLoss")]
    #[cfg_attr(feature = "serde", serde(rename = "NetGnLoss"))]
    pub net_gn_loss: AmountAndDirection58,

    #[yaserde(rename = "CsmptnTax")]
    #[cfg_attr(feature = "serde", serde(rename = "CsmptnTax"))]
    pub csmptn_tax: AmountAndDirection58,

    #[yaserde(rename = "AcrdCptlstnAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "AcrdCptlstnAmt"))]
    pub acrd_cptlstn_amt: AmountAndDirection58,

    #[yaserde(rename = "BookVal")]
    #[cfg_attr(feature = "serde", serde(rename = "BookVal"))]
    pub book_val: AmountAndDirection58,

    #[yaserde(rename = "RsrchFee")]
    #[cfg_attr(feature = "serde", serde(rename = "RsrchFee"))]
    pub rsrch_fee: AmountAndDirection44,
}

impl Validate for OtherAmounts42 {}


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

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

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

impl Validate for OtherIdentification2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct OtherParties44 {
    #[yaserde(rename = "Invstr")]
    #[cfg_attr(feature = "serde", serde(rename = "Invstr"))]
    pub invstr: Vec<PartyIdentificationAndAccount208>,

    #[yaserde(rename = "QlfdFrgnIntrmy")]
    #[cfg_attr(feature = "serde", serde(rename = "QlfdFrgnIntrmy"))]
    pub qlfd_frgn_intrmy: PartyIdentificationAndAccount209,

    #[yaserde(rename = "StockXchg")]
    #[cfg_attr(feature = "serde", serde(rename = "StockXchg"))]
    pub stock_xchg: PartyIdentificationAndAccount181,

    #[yaserde(rename = "TradRgltr")]
    #[cfg_attr(feature = "serde", serde(rename = "TradRgltr"))]
    pub trad_rgltr: PartyIdentificationAndAccount181,

    #[yaserde(rename = "TrptyAgt")]
    #[cfg_attr(feature = "serde", serde(rename = "TrptyAgt"))]
    pub trpty_agt: PartyIdentificationAndAccount209,

    #[yaserde(rename = "Brkr")]
    #[cfg_attr(feature = "serde", serde(rename = "Brkr"))]
    pub brkr: PartyIdentificationAndAccount209,
}

impl Validate for OtherParties44 {}


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

pub enum OwnershipLegalRestrictions1Code {
    A144,
    #[yaserde(rename = "NRST")]
    #[cfg_attr(feature = "serde", serde(rename = "NRST"))]
    Nrst,
    #[yaserde(rename = "RSTR")]
    #[cfg_attr(feature = "serde", serde(rename = "RSTR"))]
    Rstr,
    __Unknown__(String),
}

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

impl Validate for OwnershipLegalRestrictions1Code {}



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

pub enum PartialSettlement2Code {
    #[yaserde(rename = "PAIN")]
    #[cfg_attr(feature = "serde", serde(rename = "PAIN"))]
    Pain,
    #[yaserde(rename = "PARC")]
    #[cfg_attr(feature = "serde", serde(rename = "PARC"))]
    Parc,
    __Unknown__(String),
}

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

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

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

impl Validate for PartyIdentification137Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct PartyIdentification145Choice {
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_b_i_c: Option<AnyBICDec2014Identifier>,
    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: Option<NameAndAddress12>,
    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: Option<CountryCode>,
}

impl Validate for PartyIdentification145Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct PartyIdentification147Choice {
    #[yaserde(rename = "BICFI")]
    #[cfg_attr(feature = "serde", serde(rename = "BICFI"))]
    pub bicfi: Option<Bicfidec2014Identifier>,
    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: Option<NameAndAddress12>,
    #[yaserde(rename = "PrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
    pub prtry_id: Option<GenericIdentification84>,
}

impl Validate for PartyIdentification147Choice {}




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

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

impl Validate for PartyIdentification156 {}


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

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

impl Validate for PartyIdentification157 {}


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

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

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

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

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

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

impl Validate for PartyIdentification162 {}


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

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

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

    #[yaserde(rename = "CshAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "CshAcct"))]
    pub csh_acct: CashAccountIdentification6Choice,

    #[yaserde(rename = "ChrgsAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "ChrgsAcct"))]
    pub chrgs_acct: CashAccountIdentification6Choice,

    #[yaserde(rename = "ComssnAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "ComssnAcct"))]
    pub comssn_acct: CashAccountIdentification6Choice,

    #[yaserde(rename = "TaxAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxAcct"))]
    pub tax_acct: CashAccountIdentification6Choice,

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

impl Validate for PartyIdentificationAndAccount177 {}


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

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

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

    #[yaserde(rename = "CshAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "CshAcct"))]
    pub csh_acct: CashAccountIdentification6Choice,

    #[yaserde(rename = "ChrgsAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "ChrgsAcct"))]
    pub chrgs_acct: CashAccountIdentification6Choice,

    #[yaserde(rename = "ComssnAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "ComssnAcct"))]
    pub comssn_acct: CashAccountIdentification6Choice,

    #[yaserde(rename = "TaxAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxAcct"))]
    pub tax_acct: CashAccountIdentification6Choice,

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

impl Validate for PartyIdentificationAndAccount178 {}


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

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

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

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

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

impl Validate for PartyIdentificationAndAccount181 {}


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

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

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

    #[yaserde(rename = "SfkpgAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgAcct"))]
    pub sfkpg_acct: SecuritiesAccount30,

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

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

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

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

impl Validate for PartyIdentificationAndAccount206 {}


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

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

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

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

    #[yaserde(rename = "SfkpgAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgAcct"))]
    pub sfkpg_acct: RestrictedFINXMax35Text,

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

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

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

impl Validate for PartyIdentificationAndAccount208 {}


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

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

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

    #[yaserde(rename = "SfkpgAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgAcct"))]
    pub sfkpg_acct: RestrictedFINXMax35Text,

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

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

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

impl Validate for PartyIdentificationAndAccount209 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct PartyTextInformation3 {
    #[yaserde(rename = "DclrtnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "DclrtnDtls"))]
    pub dclrtn_dtls: RestrictedFINXMax350Text,

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

    #[yaserde(rename = "RegnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "RegnDtls"))]
    pub regn_dtls: RestrictedFINXMax350Text,
}

impl Validate for PartyTextInformation3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct PartyTextInformation4 {
    #[yaserde(rename = "DclrtnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "DclrtnDtls"))]
    pub dclrtn_dtls: RestrictedFINXMax350Text,

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

impl Validate for PartyTextInformation4 {}


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

impl Validate for PercentageRate {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct PlaceOfClearingIdentification2 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: AnyBICDec2014Identifier,

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

impl Validate for PlaceOfClearingIdentification2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct PlaceOfTradeIdentification2 {
    #[yaserde(rename = "MktTpAndId")]
    #[cfg_attr(feature = "serde", serde(rename = "MktTpAndId"))]
    pub mkt_tp_and_id: MarketIdentification90,

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

impl Validate for PlaceOfTradeIdentification2 {}


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

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

pub enum PreConfirmation1Code {
    #[yaserde(rename = "PRCA")]
    #[cfg_attr(feature = "serde", serde(rename = "PRCA"))]
    Prca,
    #[yaserde(rename = "PRSE")]
    #[cfg_attr(feature = "serde", serde(rename = "PRSE"))]
    Prse,
    __Unknown__(String),
}

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

impl Validate for PreConfirmation1Code {}



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

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

impl Validate for Price11 {}


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

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

impl Validate for Price3 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct PriceRateOrAmount1Choice {
    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: Option<PercentageRate>,
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<RestrictedFINActiveOrHistoricCurrencyAnd13DecimalAmount>,
}

impl Validate for PriceRateOrAmount1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct PriceType5Choice {
    #[yaserde(rename = "Mkt")]
    #[cfg_attr(feature = "serde", serde(rename = "Mkt"))]
    pub mkt: Option<Price3>,
    #[yaserde(rename = "Indctv")]
    #[cfg_attr(feature = "serde", serde(rename = "Indctv"))]
    pub indctv: Option<Price3>,
}

impl Validate for PriceType5Choice {}




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

pub enum PriceValueType12Code {
    #[yaserde(rename = "DISC")]
    #[cfg_attr(feature = "serde", serde(rename = "DISC"))]
    Disc,
    #[yaserde(rename = "PARV")]
    #[cfg_attr(feature = "serde", serde(rename = "PARV"))]
    Parv,
    #[yaserde(rename = "PREM")]
    #[cfg_attr(feature = "serde", serde(rename = "PREM"))]
    Prem,
    #[yaserde(rename = "NEGA")]
    #[cfg_attr(feature = "serde", serde(rename = "NEGA"))]
    Nega,
    __Unknown__(String),
}

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

impl Validate for PriceValueType12Code {}



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

pub enum PriceValueType1Code {
    #[yaserde(rename = "DISC")]
    #[cfg_attr(feature = "serde", serde(rename = "DISC"))]
    Disc,
    #[yaserde(rename = "PREM")]
    #[cfg_attr(feature = "serde", serde(rename = "PREM"))]
    Prem,
    #[yaserde(rename = "PARV")]
    #[cfg_attr(feature = "serde", serde(rename = "PARV"))]
    Parv,
    __Unknown__(String),
}

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

impl Validate for PriceValueType1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct PriorityNumeric5Choice {
    #[yaserde(rename = "Nmrc")]
    #[cfg_attr(feature = "serde", serde(rename = "Nmrc"))]
    pub nmrc: Option<Exact4NumericText>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

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

impl Validate for Quantity54Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct QuantityAndAccount103 {
    #[yaserde(rename = "SttldQty")]
    #[cfg_attr(feature = "serde", serde(rename = "SttldQty"))]
    pub sttld_qty: Quantity54Choice,

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

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

    #[yaserde(rename = "PrevslySttldAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "PrevslySttldAmt"))]
    pub prevsly_sttld_amt: AmountAndDirection19,

    #[yaserde(rename = "RmngToBeSttldAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "RmngToBeSttldAmt"))]
    pub rmng_to_be_sttld_amt: AmountAndDirection19,

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

    #[yaserde(rename = "SfkpgAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgAcct"))]
    pub sfkpg_acct: SecuritiesAccount30,

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

    #[yaserde(rename = "CshAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "CshAcct"))]
    pub csh_acct: CashAccountIdentification6Choice,

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

impl Validate for QuantityAndAccount103 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct Rate2 {
    #[yaserde(rename = "Sgn")]
    #[cfg_attr(feature = "serde", serde(rename = "Sgn"))]
    pub sgn: PlusOrMinusIndicator,

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

impl Validate for Rate2 {}


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

    #[yaserde(rename = "RateNm")]
    #[cfg_attr(feature = "serde", serde(rename = "RateNm"))]
    pub rate_nm: RestrictedFINXMax24Text,
}

impl Validate for RateName2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct RateOrName2Choice {
    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: Option<Rate2>,
    #[yaserde(rename = "RateNm")]
    #[cfg_attr(feature = "serde", serde(rename = "RateNm"))]
    pub rate_nm: Option<RateName2>,
}

impl Validate for RateOrName2Choice {}




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

pub enum RateType1Code {
    #[yaserde(rename = "FIXE")]
    #[cfg_attr(feature = "serde", serde(rename = "FIXE"))]
    Fixe,
    #[yaserde(rename = "FORF")]
    #[cfg_attr(feature = "serde", serde(rename = "FORF"))]
    Forf,
    #[yaserde(rename = "VARI")]
    #[cfg_attr(feature = "serde", serde(rename = "VARI"))]
    Vari,
    __Unknown__(String),
}

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

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

impl Validate for RateType67Choice {}




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

pub enum ReceiveDelivery1Code {
    #[yaserde(rename = "DELI")]
    #[cfg_attr(feature = "serde", serde(rename = "DELI"))]
    Deli,
    #[yaserde(rename = "RECE")]
    #[cfg_attr(feature = "serde", serde(rename = "RECE"))]
    Rece,
    __Unknown__(String),
}

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

impl Validate for ReceiveDelivery1Code {}



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

pub enum Reporting2Code {
    #[yaserde(rename = "STEX")]
    #[cfg_attr(feature = "serde", serde(rename = "STEX"))]
    Stex,
    #[yaserde(rename = "REGU")]
    #[cfg_attr(feature = "serde", serde(rename = "REGU"))]
    Regu,
    #[yaserde(rename = "DEFR")]
    #[cfg_attr(feature = "serde", serde(rename = "DEFR"))]
    Defr,
    __Unknown__(String),
}

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

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

impl Validate for Reporting9Choice {}




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

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

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

impl Validate for RestrictedFINActiveCurrencyAndAmount {}


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

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

impl Validate for RestrictedFINActiveOrHistoricCurrencyAnd13DecimalAmount {}


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

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

impl Validate for RestrictedFINActiveOrHistoricCurrencyAndAmount {}


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Validate for RestrictedFINXMax8Text {
    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() > 8 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 8 \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:sese.035.002.11")]
pub struct Restriction6Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<OwnershipLegalRestrictions1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for Restriction6Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct RevaluationIndicator4Choice {
    #[yaserde(rename = "Ind")]
    #[cfg_attr(feature = "serde", serde(rename = "Ind"))]
    pub ind: Option<YesNoIndicator>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for RevaluationIndicator4Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct SafeKeepingPlace4 {
    #[yaserde(rename = "SfkpgPlcFrmt")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgPlcFrmt"))]
    pub sfkpg_plc_frmt: SafekeepingPlaceFormat39Choice,

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

impl Validate for SafeKeepingPlace4 {}


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

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:sese.035.002.11")]

pub enum SafekeepingPlace3Code {
    #[yaserde(rename = "SHHE")]
    #[cfg_attr(feature = "serde", serde(rename = "SHHE"))]
    Shhe,
    __Unknown__(String),
}

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

impl Validate for SafekeepingPlace3Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct SafekeepingPlaceFormat39Choice {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Option<SafekeepingPlaceTypeAndText15>,
    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: Option<CountryCode>,
    #[yaserde(rename = "TpAndId")]
    #[cfg_attr(feature = "serde", serde(rename = "TpAndId"))]
    pub tp_and_id: Option<SafekeepingPlaceTypeAndIdentification1>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification85>,
}

impl Validate for SafekeepingPlaceFormat39Choice {}




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

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

impl Validate for SafekeepingPlaceTypeAndText15 {}


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

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

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

impl Validate for SecuritiesAccount30 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct SecuritiesFinancingConfirmation002V11 {
    #[yaserde(rename = "TxIdDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "TxIdDtls"))]
    pub tx_id_dtls: TransactionTypeAndAdditionalParameters19,

    #[yaserde(rename = "AddtlParams")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlParams"))]
    pub addtl_params: AdditionalParameters26,

    #[yaserde(rename = "TradDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "TradDtls"))]
    pub trad_dtls: SecuritiesTradeDetails124,

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

    #[yaserde(rename = "FinInstrmAttrbts")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrmAttrbts"))]
    pub fin_instrm_attrbts: FinancialInstrumentAttributes122,

    #[yaserde(rename = "QtyAndAcctDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "QtyAndAcctDtls"))]
    pub qty_and_acct_dtls: QuantityAndAccount103,

    #[yaserde(rename = "SctiesFincgDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesFincgDtls"))]
    pub scties_fincg_dtls: SecuritiesFinancingTransactionDetails46,

    #[yaserde(rename = "StgSttlmInstrDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "StgSttlmInstrDtls"))]
    pub stg_sttlm_instr_dtls: StandingSettlementInstruction19,

    #[yaserde(rename = "SttlmParams")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmParams"))]
    pub sttlm_params: SettlementDetails151,

    #[yaserde(rename = "DlvrgSttlmPties")]
    #[cfg_attr(feature = "serde", serde(rename = "DlvrgSttlmPties"))]
    pub dlvrg_sttlm_pties: SettlementParties105,

    #[yaserde(rename = "RcvgSttlmPties")]
    #[cfg_attr(feature = "serde", serde(rename = "RcvgSttlmPties"))]
    pub rcvg_sttlm_pties: SettlementParties105,

    #[yaserde(rename = "CshPties")]
    #[cfg_attr(feature = "serde", serde(rename = "CshPties"))]
    pub csh_pties: CashParties38,

    #[yaserde(rename = "SttldAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "SttldAmt"))]
    pub sttld_amt: AmountAndDirection96,

    #[yaserde(rename = "OthrAmts")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrAmts"))]
    pub othr_amts: OtherAmounts42,

    #[yaserde(rename = "OthrBizPties")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrBizPties"))]
    pub othr_biz_pties: OtherParties44,

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

impl Validate for SecuritiesFinancingConfirmation002V11 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct SecuritiesFinancingTransactionDetails46 {
    #[yaserde(rename = "SctiesFincgTradId")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesFincgTradId"))]
    pub scties_fincg_trad_id: RestrictedFINXMax52Text,

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

    #[yaserde(rename = "TermntnDt")]
    #[cfg_attr(feature = "serde", serde(rename = "TermntnDt"))]
    pub termntn_dt: TerminationDate7Choice,

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

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

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

    #[yaserde(rename = "RateTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTp"))]
    pub rate_tp: RateType67Choice,

    #[yaserde(rename = "Rvaltn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rvaltn"))]
    pub rvaltn: RevaluationIndicator4Choice,

    #[yaserde(rename = "LglFrmwk")]
    #[cfg_attr(feature = "serde", serde(rename = "LglFrmwk"))]
    pub lgl_frmwk: LegalFramework4Choice,

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

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

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

    #[yaserde(rename = "VarblRateSpprt")]
    #[cfg_attr(feature = "serde", serde(rename = "VarblRateSpprt"))]
    pub varbl_rate_spprt: RateName2,

    #[yaserde(rename = "RpRate")]
    #[cfg_attr(feature = "serde", serde(rename = "RpRate"))]
    pub rp_rate: Rate2,

    #[yaserde(rename = "StockLnMrgn")]
    #[cfg_attr(feature = "serde", serde(rename = "StockLnMrgn"))]
    pub stock_ln_mrgn: Rate2,

    #[yaserde(rename = "SctiesHrcut")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesHrcut"))]
    pub scties_hrcut: Rate2,

    #[yaserde(rename = "ChrgsRate")]
    #[cfg_attr(feature = "serde", serde(rename = "ChrgsRate"))]
    pub chrgs_rate: Rate2,

    #[yaserde(rename = "PricgRate")]
    #[cfg_attr(feature = "serde", serde(rename = "PricgRate"))]
    pub pricg_rate: RateOrName2Choice,

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

    #[yaserde(rename = "TxCallDely")]
    #[cfg_attr(feature = "serde", serde(rename = "TxCallDely"))]
    pub tx_call_dely: Exact3NumericText,

    #[yaserde(rename = "TtlNbOfCollInstrs")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlNbOfCollInstrs"))]
    pub ttl_nb_of_coll_instrs: Exact3NumericText,

    #[yaserde(rename = "DealAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "DealAmt"))]
    pub deal_amt: AmountAndDirection59,

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

    #[yaserde(rename = "FrftAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "FrftAmt"))]
    pub frft_amt: AmountAndDirection59,

    #[yaserde(rename = "PrmAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "PrmAmt"))]
    pub prm_amt: AmountAndDirection59,

    #[yaserde(rename = "TermntnAmtPerPcOfColl")]
    #[cfg_attr(feature = "serde", serde(rename = "TermntnAmtPerPcOfColl"))]
    pub termntn_amt_per_pc_of_coll: AmountAndDirection59,

    #[yaserde(rename = "TermntnTxAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "TermntnTxAmt"))]
    pub termntn_tx_amt: AmountAndDirection59,

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

impl Validate for SecuritiesFinancingTransactionDetails46 {}


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

pub enum SecuritiesFinancingTransactionType2Code {
    #[yaserde(rename = "REPU")]
    #[cfg_attr(feature = "serde", serde(rename = "REPU"))]
    Repu,
    #[yaserde(rename = "RVPO")]
    #[cfg_attr(feature = "serde", serde(rename = "RVPO"))]
    Rvpo,
    #[yaserde(rename = "SECB")]
    #[cfg_attr(feature = "serde", serde(rename = "SECB"))]
    Secb,
    #[yaserde(rename = "SECL")]
    #[cfg_attr(feature = "serde", serde(rename = "SECL"))]
    Secl,
    #[yaserde(rename = "BSBK")]
    #[cfg_attr(feature = "serde", serde(rename = "BSBK"))]
    Bsbk,
    #[yaserde(rename = "SBBK")]
    #[cfg_attr(feature = "serde", serde(rename = "SBBK"))]
    Sbbk,
    __Unknown__(String),
}

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

impl Validate for SecuritiesFinancingTransactionType2Code {}



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

pub enum SecuritiesPaymentStatus1Code {
    #[yaserde(rename = "FULL")]
    #[cfg_attr(feature = "serde", serde(rename = "FULL"))]
    Full,
    #[yaserde(rename = "NILL")]
    #[cfg_attr(feature = "serde", serde(rename = "NILL"))]
    Nill,
    #[yaserde(rename = "PART")]
    #[cfg_attr(feature = "serde", serde(rename = "PART"))]
    Part,
    __Unknown__(String),
}

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

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

impl Validate for SecuritiesPaymentStatus6Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct SecuritiesRTGS5Choice {
    #[yaserde(rename = "Ind")]
    #[cfg_attr(feature = "serde", serde(rename = "Ind"))]
    pub ind: Option<YesNoIndicator>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for SecuritiesRTGS5Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct SecuritiesTradeDetails124 {
    #[yaserde(rename = "PlcOfTrad")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcOfTrad"))]
    pub plc_of_trad: PlaceOfTradeIdentification2,

    #[yaserde(rename = "PlcOfClr")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcOfClr"))]
    pub plc_of_clr: PlaceOfClearingIdentification2,

    #[yaserde(rename = "TradDt")]
    #[cfg_attr(feature = "serde", serde(rename = "TradDt"))]
    pub trad_dt: TradeDate9Choice,

    #[yaserde(rename = "SttlmDt")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmDt"))]
    pub sttlm_dt: SettlementDate20Choice,

    #[yaserde(rename = "FctvSttlmDt")]
    #[cfg_attr(feature = "serde", serde(rename = "FctvSttlmDt"))]
    pub fctv_sttlm_dt: SettlementDate22Choice,

    #[yaserde(rename = "DealPric")]
    #[cfg_attr(feature = "serde", serde(rename = "DealPric"))]
    pub deal_pric: Price11,

    #[yaserde(rename = "Rptg")]
    #[cfg_attr(feature = "serde", serde(rename = "Rptg"))]
    pub rptg: Vec<Reporting9Choice>,

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

    #[yaserde(rename = "TradTxCond")]
    #[cfg_attr(feature = "serde", serde(rename = "TradTxCond"))]
    pub trad_tx_cond: Vec<TradeTransactionCondition6Choice>,

    #[yaserde(rename = "InvstrCpcty")]
    #[cfg_attr(feature = "serde", serde(rename = "InvstrCpcty"))]
    pub invstr_cpcty: InvestorCapacity5Choice,

    #[yaserde(rename = "TradOrgtrRole")]
    #[cfg_attr(feature = "serde", serde(rename = "TradOrgtrRole"))]
    pub trad_orgtr_role: TradeOriginator4Choice,

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

    #[yaserde(rename = "FxAddtlDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "FxAddtlDtls"))]
    pub fx_addtl_dtls: RestrictedFINXMax350Text,
}

impl Validate for SecuritiesTradeDetails124 {}


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

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

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

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

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

impl Validate for SettlementDate22Choice {}




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

pub enum SettlementDate4Code {
    #[yaserde(rename = "WISS")]
    #[cfg_attr(feature = "serde", serde(rename = "WISS"))]
    Wiss,
    __Unknown__(String),
}

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

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

impl Validate for SettlementDateCode9Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct SettlementDetails151 {
    #[yaserde(rename = "Prty")]
    #[cfg_attr(feature = "serde", serde(rename = "Prty"))]
    pub prty: PriorityNumeric5Choice,

    #[yaserde(rename = "SttlmTxCond")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmTxCond"))]
    pub sttlm_tx_cond: Vec<SettlementTransactionCondition22Choice>,

    #[yaserde(rename = "SttlgCpcty")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlgCpcty"))]
    pub sttlg_cpcty: SettlingCapacity8Choice,

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

    #[yaserde(rename = "SctiesRTGS")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesRTGS"))]
    pub scties_rtgs: SecuritiesRTGS5Choice,

    #[yaserde(rename = "BnfclOwnrsh")]
    #[cfg_attr(feature = "serde", serde(rename = "BnfclOwnrsh"))]
    pub bnfcl_ownrsh: BeneficialOwnership5Choice,

    #[yaserde(rename = "CshClrSys")]
    #[cfg_attr(feature = "serde", serde(rename = "CshClrSys"))]
    pub csh_clr_sys: CashSettlementSystem5Choice,

    #[yaserde(rename = "TaxCpcty")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxCpcty"))]
    pub tax_cpcty: TaxCapacityParty5Choice,

    #[yaserde(rename = "MktClntSd")]
    #[cfg_attr(feature = "serde", serde(rename = "MktClntSd"))]
    pub mkt_clnt_sd: MarketClientSide7Choice,

    #[yaserde(rename = "BlckTrad")]
    #[cfg_attr(feature = "serde", serde(rename = "BlckTrad"))]
    pub blck_trad: BlockTrade5Choice,

    #[yaserde(rename = "LglRstrctns")]
    #[cfg_attr(feature = "serde", serde(rename = "LglRstrctns"))]
    pub lgl_rstrctns: Restriction6Choice,

    #[yaserde(rename = "SttlmSysMtd")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmSysMtd"))]
    pub sttlm_sys_mtd: SettlementSystemMethod5Choice,

    #[yaserde(rename = "NetgElgblty")]
    #[cfg_attr(feature = "serde", serde(rename = "NetgElgblty"))]
    pub netg_elgblty: NettingEligibility5Choice,

    #[yaserde(rename = "CCPElgblty")]
    #[cfg_attr(feature = "serde", serde(rename = "CCPElgblty"))]
    pub ccp_elgblty: CentralCounterPartyEligibility5Choice,

    #[yaserde(rename = "AutomtcBrrwg")]
    #[cfg_attr(feature = "serde", serde(rename = "AutomtcBrrwg"))]
    pub automtc_brrwg: AutomaticBorrowing8Choice,

    #[yaserde(rename = "PrtlSttlmInd")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtlSttlmInd"))]
    pub prtl_sttlm_ind: SettlementTransactionCondition5Code,

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

impl Validate for SettlementDetails151 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct SettlementParties105 {
    #[yaserde(rename = "Dpstry")]
    #[cfg_attr(feature = "serde", serde(rename = "Dpstry"))]
    pub dpstry: PartyIdentification162,

    #[yaserde(rename = "Pty1")]
    #[cfg_attr(feature = "serde", serde(rename = "Pty1"))]
    pub pty_1: PartyIdentificationAndAccount206,

    #[yaserde(rename = "Pty2")]
    #[cfg_attr(feature = "serde", serde(rename = "Pty2"))]
    pub pty_2: PartyIdentificationAndAccount206,

    #[yaserde(rename = "Pty3")]
    #[cfg_attr(feature = "serde", serde(rename = "Pty3"))]
    pub pty_3: PartyIdentificationAndAccount206,

    #[yaserde(rename = "Pty4")]
    #[cfg_attr(feature = "serde", serde(rename = "Pty4"))]
    pub pty_4: PartyIdentificationAndAccount206,

    #[yaserde(rename = "Pty5")]
    #[cfg_attr(feature = "serde", serde(rename = "Pty5"))]
    pub pty_5: PartyIdentificationAndAccount206,
}

impl Validate for SettlementParties105 {}


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

pub enum SettlementStandingInstructionDatabase1Code {
    #[yaserde(rename = "INTE")]
    #[cfg_attr(feature = "serde", serde(rename = "INTE"))]
    Inte,
    #[yaserde(rename = "BRKR")]
    #[cfg_attr(feature = "serde", serde(rename = "BRKR"))]
    Brkr,
    #[yaserde(rename = "VEND")]
    #[cfg_attr(feature = "serde", serde(rename = "VEND"))]
    Vend,
    __Unknown__(String),
}

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

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

impl Validate for SettlementStandingInstructionDatabase5Choice {}




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

pub enum SettlementSystemMethod1Code {
    #[yaserde(rename = "NSET")]
    #[cfg_attr(feature = "serde", serde(rename = "NSET"))]
    Nset,
    #[yaserde(rename = "YSET")]
    #[cfg_attr(feature = "serde", serde(rename = "YSET"))]
    Yset,
    __Unknown__(String),
}

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

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

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

impl Validate for SettlementTransactionCondition22Choice {}




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

pub enum SettlementTransactionCondition5Code {
    #[yaserde(rename = "PART")]
    #[cfg_attr(feature = "serde", serde(rename = "PART"))]
    Part,
    #[yaserde(rename = "NPAR")]
    #[cfg_attr(feature = "serde", serde(rename = "NPAR"))]
    Npar,
    #[yaserde(rename = "PARC")]
    #[cfg_attr(feature = "serde", serde(rename = "PARC"))]
    Parc,
    #[yaserde(rename = "PARQ")]
    #[cfg_attr(feature = "serde", serde(rename = "PARQ"))]
    Parq,
    __Unknown__(String),
}

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

impl Validate for SettlementTransactionCondition5Code {}



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

pub enum SettlementTransactionCondition6Code {
    #[yaserde(rename = "ASGN")]
    #[cfg_attr(feature = "serde", serde(rename = "ASGN"))]
    Asgn,
    #[yaserde(rename = "BUTC")]
    #[cfg_attr(feature = "serde", serde(rename = "BUTC"))]
    Butc,
    #[yaserde(rename = "CLEN")]
    #[cfg_attr(feature = "serde", serde(rename = "CLEN"))]
    Clen,
    #[yaserde(rename = "DIRT")]
    #[cfg_attr(feature = "serde", serde(rename = "DIRT"))]
    Dirt,
    #[yaserde(rename = "DLWM")]
    #[cfg_attr(feature = "serde", serde(rename = "DLWM"))]
    Dlwm,
    #[yaserde(rename = "DRAW")]
    #[cfg_attr(feature = "serde", serde(rename = "DRAW"))]
    Draw,
    #[yaserde(rename = "EXER")]
    #[cfg_attr(feature = "serde", serde(rename = "EXER"))]
    Exer,
    #[yaserde(rename = "FRCL")]
    #[cfg_attr(feature = "serde", serde(rename = "FRCL"))]
    Frcl,
    #[yaserde(rename = "KNOC")]
    #[cfg_attr(feature = "serde", serde(rename = "KNOC"))]
    Knoc,
    #[yaserde(rename = "PHYS")]
    #[cfg_attr(feature = "serde", serde(rename = "PHYS"))]
    Phys,
    #[yaserde(rename = "RESI")]
    #[cfg_attr(feature = "serde", serde(rename = "RESI"))]
    Resi,
    #[yaserde(rename = "SHOR")]
    #[cfg_attr(feature = "serde", serde(rename = "SHOR"))]
    Shor,
    #[yaserde(rename = "SPDL")]
    #[cfg_attr(feature = "serde", serde(rename = "SPDL"))]
    Spdl,
    #[yaserde(rename = "SPST")]
    #[cfg_attr(feature = "serde", serde(rename = "SPST"))]
    Spst,
    #[yaserde(rename = "EXPI")]
    #[cfg_attr(feature = "serde", serde(rename = "EXPI"))]
    Expi,
    #[yaserde(rename = "PENS")]
    #[cfg_attr(feature = "serde", serde(rename = "PENS"))]
    Pens,
    #[yaserde(rename = "UNEX")]
    #[cfg_attr(feature = "serde", serde(rename = "UNEX"))]
    Unex,
    #[yaserde(rename = "TRIP")]
    #[cfg_attr(feature = "serde", serde(rename = "TRIP"))]
    Trip,
    #[yaserde(rename = "NOMC")]
    #[cfg_attr(feature = "serde", serde(rename = "NOMC"))]
    Nomc,
    #[yaserde(rename = "TRAN")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAN"))]
    Tran,
    #[yaserde(rename = "RHYP")]
    #[cfg_attr(feature = "serde", serde(rename = "RHYP"))]
    Rhyp,
    #[yaserde(rename = "ADEA")]
    #[cfg_attr(feature = "serde", serde(rename = "ADEA"))]
    Adea,
    __Unknown__(String),
}

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

impl Validate for SettlementTransactionCondition6Code {}



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

pub enum SettlingCapacity2Code {
    #[yaserde(rename = "SAGE")]
    #[cfg_attr(feature = "serde", serde(rename = "SAGE"))]
    Sage,
    #[yaserde(rename = "CUST")]
    #[cfg_attr(feature = "serde", serde(rename = "CUST"))]
    Cust,
    #[yaserde(rename = "SPRI")]
    #[cfg_attr(feature = "serde", serde(rename = "SPRI"))]
    Spri,
    #[yaserde(rename = "RISP")]
    #[cfg_attr(feature = "serde", serde(rename = "RISP"))]
    Risp,
    __Unknown__(String),
}

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

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

impl Validate for SettlingCapacity8Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct StandingSettlementInstruction19 {
    #[yaserde(rename = "SttlmStgInstrDB")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmStgInstrDB"))]
    pub sttlm_stg_instr_db: SettlementStandingInstructionDatabase5Choice,

    #[yaserde(rename = "CtrPty")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrPty"))]
    pub ctr_pty: Counterparty16Choice,

    #[yaserde(rename = "Vndr")]
    #[cfg_attr(feature = "serde", serde(rename = "Vndr"))]
    pub vndr: PartyIdentification157,

    #[yaserde(rename = "OthrDlvrgSttlmPties")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrDlvrgSttlmPties"))]
    pub othr_dlvrg_sttlm_pties: SettlementParties105,

    #[yaserde(rename = "OthrRcvgSttlmPties")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrRcvgSttlmPties"))]
    pub othr_rcvg_sttlm_pties: SettlementParties105,
}

impl Validate for StandingSettlementInstruction19 {}


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

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

impl Validate for TaxCapacityParty5Choice {}




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

pub enum TaxLiability1Code {
    #[yaserde(rename = "PRIN")]
    #[cfg_attr(feature = "serde", serde(rename = "PRIN"))]
    Prin,
    #[yaserde(rename = "AGEN")]
    #[cfg_attr(feature = "serde", serde(rename = "AGEN"))]
    Agen,
    __Unknown__(String),
}

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

impl Validate for TaxLiability1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct TerminationDate7Choice {
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Option<DateAndDateTime2Choice>,
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<DateCode32Choice>,
}

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

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

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

impl Validate for TradeOriginator4Choice {}




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

pub enum TradeTransactionCondition4Code {
    #[yaserde(rename = "CBNS")]
    #[cfg_attr(feature = "serde", serde(rename = "CBNS"))]
    Cbns,
    #[yaserde(rename = "XBNS")]
    #[cfg_attr(feature = "serde", serde(rename = "XBNS"))]
    Xbns,
    #[yaserde(rename = "CCPN")]
    #[cfg_attr(feature = "serde", serde(rename = "CCPN"))]
    Ccpn,
    #[yaserde(rename = "XCPN")]
    #[cfg_attr(feature = "serde", serde(rename = "XCPN"))]
    Xcpn,
    #[yaserde(rename = "CDIV")]
    #[cfg_attr(feature = "serde", serde(rename = "CDIV"))]
    Cdiv,
    #[yaserde(rename = "XDIV")]
    #[cfg_attr(feature = "serde", serde(rename = "XDIV"))]
    Xdiv,
    #[yaserde(rename = "CRTS")]
    #[cfg_attr(feature = "serde", serde(rename = "CRTS"))]
    Crts,
    #[yaserde(rename = "XRTS")]
    #[cfg_attr(feature = "serde", serde(rename = "XRTS"))]
    Xrts,
    #[yaserde(rename = "CWAR")]
    #[cfg_attr(feature = "serde", serde(rename = "CWAR"))]
    Cwar,
    #[yaserde(rename = "XWAR")]
    #[cfg_attr(feature = "serde", serde(rename = "XWAR"))]
    Xwar,
    #[yaserde(rename = "SPCU")]
    #[cfg_attr(feature = "serde", serde(rename = "SPCU"))]
    Spcu,
    #[yaserde(rename = "SPEX")]
    #[cfg_attr(feature = "serde", serde(rename = "SPEX"))]
    Spex,
    #[yaserde(rename = "GTDL")]
    #[cfg_attr(feature = "serde", serde(rename = "GTDL"))]
    Gtdl,
    #[yaserde(rename = "BCRO")]
    #[cfg_attr(feature = "serde", serde(rename = "BCRO"))]
    Bcro,
    #[yaserde(rename = "BCRP")]
    #[cfg_attr(feature = "serde", serde(rename = "BCRP"))]
    Bcrp,
    #[yaserde(rename = "BCFD")]
    #[cfg_attr(feature = "serde", serde(rename = "BCFD"))]
    Bcfd,
    #[yaserde(rename = "BCBL")]
    #[cfg_attr(feature = "serde", serde(rename = "BCBL"))]
    Bcbl,
    #[yaserde(rename = "BCBN")]
    #[cfg_attr(feature = "serde", serde(rename = "BCBN"))]
    Bcbn,
    #[yaserde(rename = "MAPR")]
    #[cfg_attr(feature = "serde", serde(rename = "MAPR"))]
    Mapr,
    #[yaserde(rename = "NEGO")]
    #[cfg_attr(feature = "serde", serde(rename = "NEGO"))]
    Nego,
    #[yaserde(rename = "NMPR")]
    #[cfg_attr(feature = "serde", serde(rename = "NMPR"))]
    Nmpr,
    #[yaserde(rename = "BCPD")]
    #[cfg_attr(feature = "serde", serde(rename = "BCPD"))]
    Bcpd,
    __Unknown__(String),
}

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

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

impl Validate for TradeTransactionCondition6Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct TransactionTypeAndAdditionalParameters19 {
    #[yaserde(rename = "AcctOwnrTxId")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctOwnrTxId"))]
    pub acct_ownr_tx_id: RestrictedFINXMax16Text,

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

    #[yaserde(rename = "SctiesFincgTxTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesFincgTxTp"))]
    pub scties_fincg_tx_tp: SecuritiesFinancingTransactionType2Code,

    #[yaserde(rename = "SctiesMvmntTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesMvmntTp"))]
    pub scties_mvmnt_tp: ReceiveDelivery1Code,

    #[yaserde(rename = "Pmt")]
    #[cfg_attr(feature = "serde", serde(rename = "Pmt"))]
    pub pmt: DeliveryReceiptType2Code,

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

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

    #[yaserde(rename = "CorpActnEvtId")]
    #[cfg_attr(feature = "serde", serde(rename = "CorpActnEvtId"))]
    pub corp_actn_evt_id: RestrictedFINXMax16Text,
}

impl Validate for TransactionTypeAndAdditionalParameters19 {}


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

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

impl Validate for YesNoIndicator {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct YieldedOrValueType1Choice {
    #[yaserde(rename = "Yldd")]
    #[cfg_attr(feature = "serde", serde(rename = "Yldd"))]
    pub yldd: Option<YesNoIndicator>,
    #[yaserde(rename = "ValTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ValTp"))]
    pub val_tp: Option<PriceValueType1Code>,
}

impl Validate for YieldedOrValueType1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.035.002.11")]
pub struct YieldedOrValueType2Choice {
    #[yaserde(rename = "Yldd")]
    #[cfg_attr(feature = "serde", serde(rename = "Yldd"))]
    pub yldd: Option<YesNoIndicator>,
    #[yaserde(rename = "ValTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ValTp"))]
    pub val_tp: Option<PriceValueType12Code>,
}

impl Validate for YieldedOrValueType2Choice {}

impl crate::MxMessage for Document {
    const BUSINESS_AREA: crate::BusinessArea = crate::BusinessArea::sese;
    const FUNCTIONALITY: &'static str = "035";
    const VARIANT: &'static str = "002";
    const VERSION: &'static str = "11";
    const MESSAGE_NAME: &'static str = "sese.035.002.11";
    const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:sese.035.002.11";
}