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.025.001.13")]
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 ActiveOrHistoricCurrencyAnd13DecimalAmountSimpleType (pub String);
crate::simple_type!(ActiveOrHistoricCurrencyAnd13DecimalAmountSimpleType);

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

impl Validate for ActiveOrHistoricCurrencyAnd13DecimalAmount {}


#[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.025.001.13")]
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.025.001.13")]
pub struct AdditionalParameters29 {
    #[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: Max35Text,

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

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

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

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

impl Validate for AdditionalParameters29 {}


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

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

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

impl Validate for AddressType2Code {}



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

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

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

impl Validate for AlternatePartyIdentification7 {}


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

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

impl Validate for AmountAndDirection52 {}


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

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

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

impl Validate for AmountAndDirection94 {}


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

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.025.001.13")]
pub struct AutomaticBorrowing6Choice {
    #[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<GenericIdentification30>,
}

impl Validate for AutomaticBorrowing6Choice {}




#[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.025.001.13")]
pub struct BeneficialOwnership4Choice {
    #[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<GenericIdentification30>,
}

impl Validate for BeneficialOwnership4Choice {}




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

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

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

impl Validate for BlockChainAddressWallet3 {}


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

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.025.001.13")]
pub struct BlockTrade4Choice {
    #[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<GenericIdentification30>,
}

impl Validate for BlockTrade4Choice {}




#[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.025.001.13")]
pub struct CashAccountIdentification5Choice {
    #[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<Max34Text>,
}

impl Validate for CashAccountIdentification5Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.13")]
pub struct CashAccountIdentification9Choice {
    #[yaserde(rename = "IBAN")]
    #[cfg_attr(feature = "serde", serde(rename = "IBAN"))]
    pub iban: Option<Iban2007Identifier>,
    #[yaserde(rename = "BlckChainCshWllt")]
    #[cfg_attr(feature = "serde", serde(rename = "BlckChainCshWllt"))]
    pub blck_chain_csh_wllt: Option<BlockChainAddressWallet3>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max34Text>,
}

impl Validate for CashAccountIdentification9Choice {}




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

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

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

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

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

impl Validate for CashParties41 {}


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

pub enum CashSettlementSystem3Code {
    #[yaserde(rename = "DCSS")]
    #[cfg_attr(feature = "serde", serde(rename = "DCSS"))]
    Dcss,
    #[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 CashSettlementSystem3Code {
    fn default() -> CashSettlementSystem3Code {
        Self::__Unknown__("No valid variants".into())
    }
}

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

impl Validate for CashSettlementSystem6Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.13")]
pub struct CashSettlementSystemPlace1Choice {
    #[yaserde(rename = "DgtlLdgrId")]
    #[cfg_attr(feature = "serde", serde(rename = "DgtlLdgrId"))]
    pub dgtl_ldgr_id: Option<Dti2024Identifier>,
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_b_i_c: Option<AnyBICDec2014Identifier>,
    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Option<Leiidentifier>,
}

impl Validate for CashSettlementSystemPlace1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.13")]
pub struct CentralCounterPartyEligibility4Choice {
    #[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<GenericIdentification30>,
}

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

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

impl Validate for Counterparty15Choice {}




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

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

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

impl Validate for CreditDebitCode {}



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

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

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

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

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

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

    #[yaserde(rename = "CshSttlmSysPlc")]
    #[cfg_attr(feature = "serde", serde(rename = "CshSttlmSysPlc"))]
    pub csh_sttlm_sys_plc: CashSettlementSystemPlace1Choice,
}

impl Validate for DigitalPaymentSettlement1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.13")]
pub struct Document {
    #[yaserde(rename = "SctiesSttlmTxConf")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesSttlmTxConf"))]
    pub scties_sttlm_tx_conf: SecuritiesSettlementTransactionConfirmationV13,
}

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

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

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

pub enum ExposureType15Code {
    #[yaserde(rename = "BFWD")]
    #[cfg_attr(feature = "serde", serde(rename = "BFWD"))]
    Bfwd,
    #[yaserde(rename = "PAYM")]
    #[cfg_attr(feature = "serde", serde(rename = "PAYM"))]
    Paym,
    #[yaserde(rename = "CCPC")]
    #[cfg_attr(feature = "serde", serde(rename = "CCPC"))]
    Ccpc,
    #[yaserde(rename = "COMM")]
    #[cfg_attr(feature = "serde", serde(rename = "COMM"))]
    Comm,
    #[yaserde(rename = "CRDS")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDS"))]
    Crds,
    #[yaserde(rename = "CRTL")]
    #[cfg_attr(feature = "serde", serde(rename = "CRTL"))]
    Crtl,
    #[yaserde(rename = "CRSP")]
    #[cfg_attr(feature = "serde", serde(rename = "CRSP"))]
    Crsp,
    #[yaserde(rename = "CCIR")]
    #[cfg_attr(feature = "serde", serde(rename = "CCIR"))]
    Ccir,
    #[yaserde(rename = "CRPR")]
    #[cfg_attr(feature = "serde", serde(rename = "CRPR"))]
    Crpr,
    #[yaserde(rename = "EQPT")]
    #[cfg_attr(feature = "serde", serde(rename = "EQPT"))]
    Eqpt,
    #[yaserde(rename = "EXTD")]
    #[cfg_attr(feature = "serde", serde(rename = "EXTD"))]
    Extd,
    #[yaserde(rename = "EQUS")]
    #[cfg_attr(feature = "serde", serde(rename = "EQUS"))]
    Equs,
    #[yaserde(rename = "EXPT")]
    #[cfg_attr(feature = "serde", serde(rename = "EXPT"))]
    Expt,
    #[yaserde(rename = "FIXI")]
    #[cfg_attr(feature = "serde", serde(rename = "FIXI"))]
    Fixi,
    #[yaserde(rename = "FORX")]
    #[cfg_attr(feature = "serde", serde(rename = "FORX"))]
    Forx,
    #[yaserde(rename = "FORW")]
    #[cfg_attr(feature = "serde", serde(rename = "FORW"))]
    Forw,
    #[yaserde(rename = "FUTR")]
    #[cfg_attr(feature = "serde", serde(rename = "FUTR"))]
    Futr,
    #[yaserde(rename = "OPTN")]
    #[cfg_attr(feature = "serde", serde(rename = "OPTN"))]
    Optn,
    #[yaserde(rename = "LIQU")]
    #[cfg_attr(feature = "serde", serde(rename = "LIQU"))]
    Liqu,
    #[yaserde(rename = "OTCD")]
    #[cfg_attr(feature = "serde", serde(rename = "OTCD"))]
    Otcd,
    #[yaserde(rename = "REPO")]
    #[cfg_attr(feature = "serde", serde(rename = "REPO"))]
    Repo,
    #[yaserde(rename = "RVPO")]
    #[cfg_attr(feature = "serde", serde(rename = "RVPO"))]
    Rvpo,
    #[yaserde(rename = "SLOA")]
    #[cfg_attr(feature = "serde", serde(rename = "SLOA"))]
    Sloa,
    #[yaserde(rename = "SBSC")]
    #[cfg_attr(feature = "serde", serde(rename = "SBSC"))]
    Sbsc,
    #[yaserde(rename = "SCRP")]
    #[cfg_attr(feature = "serde", serde(rename = "SCRP"))]
    Scrp,
    #[yaserde(rename = "SLEB")]
    #[cfg_attr(feature = "serde", serde(rename = "SLEB"))]
    Sleb,
    #[yaserde(rename = "SHSL")]
    #[cfg_attr(feature = "serde", serde(rename = "SHSL"))]
    Shsl,
    #[yaserde(rename = "SCIR")]
    #[cfg_attr(feature = "serde", serde(rename = "SCIR"))]
    Scir,
    #[yaserde(rename = "SCIE")]
    #[cfg_attr(feature = "serde", serde(rename = "SCIE"))]
    Scie,
    #[yaserde(rename = "SWPT")]
    #[cfg_attr(feature = "serde", serde(rename = "SWPT"))]
    Swpt,
    #[yaserde(rename = "TBAS")]
    #[cfg_attr(feature = "serde", serde(rename = "TBAS"))]
    Tbas,
    #[yaserde(rename = "UDMS")]
    #[cfg_attr(feature = "serde", serde(rename = "UDMS"))]
    Udms,
    #[yaserde(rename = "TRCP")]
    #[cfg_attr(feature = "serde", serde(rename = "TRCP"))]
    Trcp,
    #[yaserde(rename = "CBCO")]
    #[cfg_attr(feature = "serde", serde(rename = "CBCO"))]
    Cbco,
    __Unknown__(String),
}

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

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

impl Validate for ExposureType25Choice {}




#[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.025.001.13")]
pub struct FinancialInstrumentAttributes111 {
    #[yaserde(rename = "PlcOfListg")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcOfListg"))]
    pub plc_of_listg: MarketIdentification3Choice,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Validate for FinancialInstrumentQuantity33Choice {}




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

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.025.001.13")]
pub struct FormOfSecurity6Choice {
    #[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<GenericIdentification30>,
}

impl Validate for FormOfSecurity6Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.13")]
pub struct Frequency23Choice {
    #[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<GenericIdentification30>,
}

impl Validate for Frequency23Choice {}




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

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

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

impl Validate for GenericIdentification1 {}


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

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

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

impl Validate for GenericIdentification30 {}


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

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

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

impl Validate for GenericIdentification36 {}


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

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

impl Validate for GenericIdentification37 {}


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

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

impl Validate for GenericIdentification78 {}


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

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

impl Validate for IdentificationType42Choice {}




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

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

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

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

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

impl Validate for InvestorCapacity4Choice {}




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

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

impl Validate for LetterOfGuarantee4Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.13")]
pub struct Linkages41 {
    #[yaserde(rename = "PrcgPos")]
    #[cfg_attr(feature = "serde", serde(rename = "PrcgPos"))]
    pub prcg_pos: ProcessingPosition9Choice,

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

impl Validate for Linkages41 {}


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

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.025.001.13")]
pub struct MarketClientSide6Choice {
    #[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<GenericIdentification30>,
}

impl Validate for MarketClientSide6Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.13")]
pub struct MarketIdentification1Choice {
    #[yaserde(rename = "MktIdrCd")]
    #[cfg_attr(feature = "serde", serde(rename = "MktIdrCd"))]
    pub mkt_idr_cd: Option<Micidentifier>,
    #[yaserde(rename = "Desc")]
    #[cfg_attr(feature = "serde", serde(rename = "Desc"))]
    pub desc: Option<Max35Text>,
}

impl Validate for MarketIdentification1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.13")]
pub struct MarketIdentification3Choice {
    #[yaserde(rename = "MktIdrCd")]
    #[cfg_attr(feature = "serde", serde(rename = "MktIdrCd"))]
    pub mkt_idr_cd: Option<Micidentifier>,
    #[yaserde(rename = "Desc")]
    #[cfg_attr(feature = "serde", serde(rename = "Desc"))]
    pub desc: Option<Max35Text>,
}

impl Validate for MarketIdentification3Choice {}




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

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

impl Validate for MarketIdentification84 {}


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

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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.025.001.13")]
pub struct MarketType8Choice {
    #[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<GenericIdentification30>,
}

impl Validate for MarketType8Choice {}




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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Validate for NettingEligibility4Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.13")]
pub struct Number22Choice {
    #[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<GenericIdentification1>,
}

impl Validate for Number22Choice {}




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

pub enum OpeningClosing1Code {
    #[yaserde(rename = "CLOP")]
    #[cfg_attr(feature = "serde", serde(rename = "CLOP"))]
    Clop,
    #[yaserde(rename = "OPEP")]
    #[cfg_attr(feature = "serde", serde(rename = "OPEP"))]
    Opep,
    __Unknown__(String),
}

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

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

impl Validate for OpeningClosing3Choice {}




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

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

impl Validate for OptionStyle8Choice {}




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

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.025.001.13")]
pub struct OptionType6Choice {
    #[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<GenericIdentification30>,
}

impl Validate for OptionType6Choice {}




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

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

impl Validate for OriginalAndCurrentQuantities1 {}


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

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.025.001.13")]
pub struct OtherAmounts46 {
    #[yaserde(rename = "AcrdIntrstAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "AcrdIntrstAmt"))]
    pub acrd_intrst_amt: AmountAndDirection44,

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

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

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

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

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

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

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

    #[yaserde(rename = "LclTaxCtrySpcfc")]
    #[cfg_attr(feature = "serde", serde(rename = "LclTaxCtrySpcfc"))]
    pub lcl_tax_ctry_spcfc: AmountAndDirection44,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    #[yaserde(rename = "CollMntrAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "CollMntrAmt"))]
    pub coll_mntr_amt: AmountAndDirection44,

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

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

impl Validate for OtherAmounts46 {}


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

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

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

impl Validate for OtherIdentification1 {}


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

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

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

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

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

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

impl Validate for OtherParties43 {}


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

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

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.025.001.13")]
pub struct PartyIdentification120Choice {
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_b_i_c: Option<AnyBICDec2014Identifier>,
    #[yaserde(rename = "PrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
    pub prtry_id: Option<GenericIdentification36>,
    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: Option<NameAndAddress5>,
}

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

impl Validate for PartyIdentification127Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.025.001.13")]
pub struct PartyIdentification133Choice {
    #[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<NameAndAddress5>,
    #[yaserde(rename = "PrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
    pub prtry_id: Option<GenericIdentification36>,
}

impl Validate for PartyIdentification133Choice {}




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

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

impl Validate for PartyIdentification136 {}


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

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

impl Validate for PartyIdentification144 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.13")]
pub struct PartyIdentification257Choice {
    #[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<NameAndAddress5>,
    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: Option<CountryCode>,
    #[yaserde(rename = "DgtlLdgrId")]
    #[cfg_attr(feature = "serde", serde(rename = "DgtlLdgrId"))]
    pub dgtl_ldgr_id: Option<Dti2024Identifier>,
}

impl Validate for PartyIdentification257Choice {}




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

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

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

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

impl Validate for PartyIdentification315 {}


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

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

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

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

impl Validate for PartyIdentificationAndAccount165 {}


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

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

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

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

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

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

impl Validate for PartyIdentificationAndAccount196 {}


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

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

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

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

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

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

impl Validate for PartyIdentificationAndAccount197 {}


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

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

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

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

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

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

impl Validate for PartyIdentificationAndAccount198 {}


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

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

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

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

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

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

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

impl Validate for PartyIdentificationAndAccount223 {}


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

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

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

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

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

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

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

impl Validate for PartyIdentificationAndAccount224 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.13")]
pub struct PartyTextInformation1 {
    #[yaserde(rename = "DclrtnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "DclrtnDtls"))]
    pub dclrtn_dtls: Max350Text,

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

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

impl Validate for PartyTextInformation1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.13")]
pub struct PartyTextInformation2 {
    #[yaserde(rename = "DclrtnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "DclrtnDtls"))]
    pub dclrtn_dtls: Max350Text,

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

impl Validate for PartyTextInformation2 {}


#[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.025.001.13")]
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.025.001.13")]
pub struct PlaceOfTradeIdentification1 {
    #[yaserde(rename = "MktTpAndId")]
    #[cfg_attr(feature = "serde", serde(rename = "MktTpAndId"))]
    pub mkt_tp_and_id: MarketIdentification84,

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

impl Validate for PlaceOfTradeIdentification1 {}


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

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

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

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

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

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

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

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

impl Validate for PostalAddress1 {}


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

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.025.001.13")]
pub struct Price10 {
    #[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: PriceRateOrAmount3Choice,
}

impl Validate for Price10 {}


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

impl Validate for Price7 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.13")]
pub struct PriceRateOrAmount3Choice {
    #[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<ActiveOrHistoricCurrencyAnd13DecimalAmount>,
}

impl Validate for PriceRateOrAmount3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.13")]
pub struct PriceType4Choice {
    #[yaserde(rename = "Mkt")]
    #[cfg_attr(feature = "serde", serde(rename = "Mkt"))]
    pub mkt: Option<Price7>,
    #[yaserde(rename = "Indctv")]
    #[cfg_attr(feature = "serde", serde(rename = "Indctv"))]
    pub indctv: Option<Price7>,
}

impl Validate for PriceType4Choice {}




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

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

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.025.001.13")]
pub struct PriorityNumeric4Choice {
    #[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<GenericIdentification30>,
}

impl Validate for PriorityNumeric4Choice {}




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

pub enum ProcessingPosition5Code {
    #[yaserde(rename = "INFO")]
    #[cfg_attr(feature = "serde", serde(rename = "INFO"))]
    Info,
    __Unknown__(String),
}

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

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

impl Validate for ProcessingPosition9Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.13")]
pub struct Quantity51Choice {
    #[yaserde(rename = "Qty")]
    #[cfg_attr(feature = "serde", serde(rename = "Qty"))]
    pub qty: Option<FinancialInstrumentQuantity33Choice>,
    #[yaserde(rename = "OrgnlAndCurFace")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlAndCurFace"))]
    pub orgnl_and_cur_face: Option<OriginalAndCurrentQuantities1>,
}

impl Validate for Quantity51Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.025.001.13")]
pub struct Quantity83Choice {
    #[yaserde(rename = "ElctrncMnyTknSttlmQty")]
    #[cfg_attr(feature = "serde", serde(rename = "ElctrncMnyTknSttlmQty"))]
    pub elctrnc_mny_tkn_sttlm_qty: Option<Max30DecimalNumber>,
    #[yaserde(rename = "NtwkFeeQty")]
    #[cfg_attr(feature = "serde", serde(rename = "NtwkFeeQty"))]
    pub ntwk_fee_qty: Option<Max30DecimalNumber>,
}

impl Validate for Quantity83Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.13")]
pub struct QuantityAndAccount115 {
    #[yaserde(rename = "SttldQty")]
    #[cfg_attr(feature = "serde", serde(rename = "SttldQty"))]
    pub sttld_qty: Quantity51Choice,

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

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

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

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

    #[yaserde(rename = "DnmtnChc")]
    #[cfg_attr(feature = "serde", serde(rename = "DnmtnChc"))]
    pub dnmtn_chc: Max210Text,

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

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

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

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

    #[yaserde(rename = "QtyBrkdwn")]
    #[cfg_attr(feature = "serde", serde(rename = "QtyBrkdwn"))]
    pub qty_brkdwn: Vec<QuantityBreakdown63>,

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

impl Validate for QuantityAndAccount115 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.13")]
pub struct QuantityBreakdown63 {
    #[yaserde(rename = "LotNb")]
    #[cfg_attr(feature = "serde", serde(rename = "LotNb"))]
    pub lot_nb: GenericIdentification37,

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

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

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

    #[yaserde(rename = "LotPric")]
    #[cfg_attr(feature = "serde", serde(rename = "LotPric"))]
    pub lot_pric: Price7,

    #[yaserde(rename = "TpOfPric")]
    #[cfg_attr(feature = "serde", serde(rename = "TpOfPric"))]
    pub tp_of_pric: TypeOfPrice29Choice,
}

impl Validate for QuantityBreakdown63 {}


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

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

pub enum Registration1Code {
    #[yaserde(rename = "NREG")]
    #[cfg_attr(feature = "serde", serde(rename = "NREG"))]
    Nreg,
    #[yaserde(rename = "YREG")]
    #[cfg_attr(feature = "serde", serde(rename = "YREG"))]
    Yreg,
    __Unknown__(String),
}

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

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

impl Validate for Registration9Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.13")]
pub struct RegistrationParameters6 {
    #[yaserde(rename = "CertfctnId")]
    #[cfg_attr(feature = "serde", serde(rename = "CertfctnId"))]
    pub certfctn_id: Max35Text,

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

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

    #[yaserde(rename = "CertNb")]
    #[cfg_attr(feature = "serde", serde(rename = "CertNb"))]
    pub cert_nb: Vec<SecuritiesCertificate4>,
}

impl Validate for RegistrationParameters6 {}


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

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.025.001.13")]
pub struct Reporting6Choice {
    #[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<GenericIdentification30>,
}

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

impl Validate for RepurchaseType22Choice {}




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

pub enum RepurchaseType9Code {
    #[yaserde(rename = "PAIR")]
    #[cfg_attr(feature = "serde", serde(rename = "PAIR"))]
    Pair,
    #[yaserde(rename = "PADJ")]
    #[cfg_attr(feature = "serde", serde(rename = "PADJ"))]
    Padj,
    #[yaserde(rename = "RATE")]
    #[cfg_attr(feature = "serde", serde(rename = "RATE"))]
    Rate,
    #[yaserde(rename = "CALL")]
    #[cfg_attr(feature = "serde", serde(rename = "CALL"))]
    Call,
    #[yaserde(rename = "ROLP")]
    #[cfg_attr(feature = "serde", serde(rename = "ROLP"))]
    Rolp,
    #[yaserde(rename = "CADJ")]
    #[cfg_attr(feature = "serde", serde(rename = "CADJ"))]
    Cadj,
    #[yaserde(rename = "TOPU")]
    #[cfg_attr(feature = "serde", serde(rename = "TOPU"))]
    Topu,
    #[yaserde(rename = "WTHD")]
    #[cfg_attr(feature = "serde", serde(rename = "WTHD"))]
    Wthd,
    __Unknown__(String),
}

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

impl Validate for RepurchaseType9Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.13")]
pub struct Restriction5Choice {
    #[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<GenericIdentification30>,
}

impl Validate for Restriction5Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.13")]
pub struct SafeKeepingPlace5 {
    #[yaserde(rename = "SfkpgPlcFrmt")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgPlcFrmt"))]
    pub sfkpg_plc_frmt: SafekeepingPlaceFormat41Choice,

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

impl Validate for SafeKeepingPlace5 {}


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

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

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.025.001.13")]
pub struct SafekeepingPlaceFormat41Choice {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Option<SafekeepingPlaceTypeAndText8>,
    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: Option<CountryCode>,
    #[yaserde(rename = "DgtlLdgrId")]
    #[cfg_attr(feature = "serde", serde(rename = "DgtlLdgrId"))]
    pub dgtl_ldgr_id: Option<Dti2024Identifier>,
    #[yaserde(rename = "TpAndId")]
    #[cfg_attr(feature = "serde", serde(rename = "TpAndId"))]
    pub tp_and_id: Option<SafekeepingPlaceTypeAndIdentification1>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification78>,
}

impl Validate for SafekeepingPlaceFormat41Choice {}




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

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

impl Validate for SafekeepingPlaceTypeAndText8 {}


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

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

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

impl Validate for SecuritiesAccount19 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.13")]
pub struct SecuritiesCertificate4 {
    #[yaserde(rename = "Nb")]
    #[cfg_attr(feature = "serde", serde(rename = "Nb"))]
    pub nb: Max35Text,

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

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

impl Validate for SecuritiesCertificate4 {}


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

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.025.001.13")]
pub struct SecuritiesPaymentStatus5Choice {
    #[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<GenericIdentification30>,
}

impl Validate for SecuritiesPaymentStatus5Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.13")]
pub struct SecuritiesRTGS4Choice {
    #[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<GenericIdentification30>,
}

impl Validate for SecuritiesRTGS4Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.13")]
pub struct SecuritiesSettlementTransactionConfirmationV13 {
    #[yaserde(rename = "TxIdDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "TxIdDtls"))]
    pub tx_id_dtls: SettlementTypeAndIdentification29,

    #[yaserde(rename = "Lnkgs")]
    #[cfg_attr(feature = "serde", serde(rename = "Lnkgs"))]
    pub lnkgs: Linkages41,

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

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

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

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

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

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

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

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

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

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

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

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

    #[yaserde(rename = "DgtlPmtSttlm")]
    #[cfg_attr(feature = "serde", serde(rename = "DgtlPmtSttlm"))]
    pub dgtl_pmt_sttlm: Vec<DigitalPaymentSettlement1>,

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

    #[yaserde(rename = "AddtlPhysOrRegnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlPhysOrRegnDtls"))]
    pub addtl_phys_or_regn_dtls: RegistrationParameters6,

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

impl Validate for SecuritiesSettlementTransactionConfirmationV13 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.13")]
pub struct SecuritiesTradeDetails150 {
    #[yaserde(rename = "TradId")]
    #[cfg_attr(feature = "serde", serde(rename = "TradId"))]
    pub trad_id: Vec<Max35Text>,

    #[yaserde(rename = "UnqTxIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "UnqTxIdr"))]
    pub unq_tx_idr: Utiidentifier,

    #[yaserde(rename = "CollTxId")]
    #[cfg_attr(feature = "serde", serde(rename = "CollTxId"))]
    pub coll_tx_id: Vec<Max35Text>,

    #[yaserde(rename = "PlcOfTrad")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcOfTrad"))]
    pub plc_of_trad: PlaceOfTradeIdentification1,

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

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

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

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

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

    #[yaserde(rename = "OpngClsg")]
    #[cfg_attr(feature = "serde", serde(rename = "OpngClsg"))]
    pub opng_clsg: OpeningClosing3Choice,

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

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

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

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

    #[yaserde(rename = "TpOfPric")]
    #[cfg_attr(feature = "serde", serde(rename = "TpOfPric"))]
    pub tp_of_pric: TypeOfPrice29Choice,

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

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

impl Validate for SecuritiesTradeDetails150 {}


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

pub enum SecuritiesTransactionType25Code {
    #[yaserde(rename = "BSBK")]
    #[cfg_attr(feature = "serde", serde(rename = "BSBK"))]
    Bsbk,
    #[yaserde(rename = "BYIY")]
    #[cfg_attr(feature = "serde", serde(rename = "BYIY"))]
    Byiy,
    #[yaserde(rename = "CNCB")]
    #[cfg_attr(feature = "serde", serde(rename = "CNCB"))]
    Cncb,
    #[yaserde(rename = "COLI")]
    #[cfg_attr(feature = "serde", serde(rename = "COLI"))]
    Coli,
    #[yaserde(rename = "COLO")]
    #[cfg_attr(feature = "serde", serde(rename = "COLO"))]
    Colo,
    #[yaserde(rename = "CONV")]
    #[cfg_attr(feature = "serde", serde(rename = "CONV"))]
    Conv,
    #[yaserde(rename = "FCTA")]
    #[cfg_attr(feature = "serde", serde(rename = "FCTA"))]
    Fcta,
    #[yaserde(rename = "INSP")]
    #[cfg_attr(feature = "serde", serde(rename = "INSP"))]
    Insp,
    #[yaserde(rename = "ISSU")]
    #[cfg_attr(feature = "serde", serde(rename = "ISSU"))]
    Issu,
    #[yaserde(rename = "MKDW")]
    #[cfg_attr(feature = "serde", serde(rename = "MKDW"))]
    Mkdw,
    #[yaserde(rename = "MKUP")]
    #[cfg_attr(feature = "serde", serde(rename = "MKUP"))]
    Mkup,
    #[yaserde(rename = "NETT")]
    #[cfg_attr(feature = "serde", serde(rename = "NETT"))]
    Nett,
    #[yaserde(rename = "NSYN")]
    #[cfg_attr(feature = "serde", serde(rename = "NSYN"))]
    Nsyn,
    #[yaserde(rename = "OWNE")]
    #[cfg_attr(feature = "serde", serde(rename = "OWNE"))]
    Owne,
    #[yaserde(rename = "OWNI")]
    #[cfg_attr(feature = "serde", serde(rename = "OWNI"))]
    Owni,
    #[yaserde(rename = "PAIR")]
    #[cfg_attr(feature = "serde", serde(rename = "PAIR"))]
    Pair,
    #[yaserde(rename = "PLAC")]
    #[cfg_attr(feature = "serde", serde(rename = "PLAC"))]
    Plac,
    #[yaserde(rename = "PORT")]
    #[cfg_attr(feature = "serde", serde(rename = "PORT"))]
    Port,
    #[yaserde(rename = "REAL")]
    #[cfg_attr(feature = "serde", serde(rename = "REAL"))]
    Real,
    #[yaserde(rename = "REDI")]
    #[cfg_attr(feature = "serde", serde(rename = "REDI"))]
    Redi,
    #[yaserde(rename = "REDM")]
    #[cfg_attr(feature = "serde", serde(rename = "REDM"))]
    Redm,
    #[yaserde(rename = "RELE")]
    #[cfg_attr(feature = "serde", serde(rename = "RELE"))]
    Rele,
    #[yaserde(rename = "REPU")]
    #[cfg_attr(feature = "serde", serde(rename = "REPU"))]
    Repu,
    #[yaserde(rename = "RODE")]
    #[cfg_attr(feature = "serde", serde(rename = "RODE"))]
    Rode,
    #[yaserde(rename = "RVPO")]
    #[cfg_attr(feature = "serde", serde(rename = "RVPO"))]
    Rvpo,
    #[yaserde(rename = "SBBK")]
    #[cfg_attr(feature = "serde", serde(rename = "SBBK"))]
    Sbbk,
    #[yaserde(rename = "SBRE")]
    #[cfg_attr(feature = "serde", serde(rename = "SBRE"))]
    Sbre,
    #[yaserde(rename = "SECB")]
    #[cfg_attr(feature = "serde", serde(rename = "SECB"))]
    Secb,
    #[yaserde(rename = "SECL")]
    #[cfg_attr(feature = "serde", serde(rename = "SECL"))]
    Secl,
    #[yaserde(rename = "SLRE")]
    #[cfg_attr(feature = "serde", serde(rename = "SLRE"))]
    Slre,
    #[yaserde(rename = "SUBS")]
    #[cfg_attr(feature = "serde", serde(rename = "SUBS"))]
    Subs,
    #[yaserde(rename = "SYND")]
    #[cfg_attr(feature = "serde", serde(rename = "SYND"))]
    Synd,
    #[yaserde(rename = "TBAC")]
    #[cfg_attr(feature = "serde", serde(rename = "TBAC"))]
    Tbac,
    #[yaserde(rename = "TRAD")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAD"))]
    Trad,
    #[yaserde(rename = "TRPO")]
    #[cfg_attr(feature = "serde", serde(rename = "TRPO"))]
    Trpo,
    #[yaserde(rename = "TRVO")]
    #[cfg_attr(feature = "serde", serde(rename = "TRVO"))]
    Trvo,
    #[yaserde(rename = "TURN")]
    #[cfg_attr(feature = "serde", serde(rename = "TURN"))]
    Turn,
    #[yaserde(rename = "CLAI")]
    #[cfg_attr(feature = "serde", serde(rename = "CLAI"))]
    Clai,
    #[yaserde(rename = "CORP")]
    #[cfg_attr(feature = "serde", serde(rename = "CORP"))]
    Corp,
    #[yaserde(rename = "AUTO")]
    #[cfg_attr(feature = "serde", serde(rename = "AUTO"))]
    Auto,
    #[yaserde(rename = "SWIF")]
    #[cfg_attr(feature = "serde", serde(rename = "SWIF"))]
    Swif,
    #[yaserde(rename = "SWIT")]
    #[cfg_attr(feature = "serde", serde(rename = "SWIT"))]
    Swit,
    #[yaserde(rename = "ETFT")]
    #[cfg_attr(feature = "serde", serde(rename = "ETFT"))]
    Etft,
    #[yaserde(rename = "REBL")]
    #[cfg_attr(feature = "serde", serde(rename = "REBL"))]
    Rebl,
    __Unknown__(String),
}

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

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

impl Validate for SecuritiesTransactionType43Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.13")]
pub struct SecurityIdentification19 {
    #[yaserde(rename = "ISIN")]
    #[cfg_attr(feature = "serde", serde(rename = "ISIN"))]
    pub isin: Isinoct2015Identifier,

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

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

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

impl Validate for SettlementDate17Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.13")]
pub struct SettlementDate18Choice {
    #[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<GenericIdentification30>,
}

impl Validate for SettlementDate18Choice {}




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

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.025.001.13")]
pub struct SettlementDateCode7Choice {
    #[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<GenericIdentification30>,
}

impl Validate for SettlementDateCode7Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.13")]
pub struct SettlementDetails221 {
    #[yaserde(rename = "Prty")]
    #[cfg_attr(feature = "serde", serde(rename = "Prty"))]
    pub prty: PriorityNumeric4Choice,

    #[yaserde(rename = "SctiesTxTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesTxTp"))]
    pub scties_tx_tp: SecuritiesTransactionType43Choice,

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

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

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

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

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

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

    #[yaserde(rename = "XpsrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "XpsrTp"))]
    pub xpsr_tp: ExposureType25Choice,

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

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

    #[yaserde(rename = "Regn")]
    #[cfg_attr(feature = "serde", serde(rename = "Regn"))]
    pub regn: Registration9Choice,

    #[yaserde(rename = "RpTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RpTp"))]
    pub rp_tp: RepurchaseType22Choice,

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

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

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

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

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

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

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

    #[yaserde(rename = "LttrOfGrnt")]
    #[cfg_attr(feature = "serde", serde(rename = "LttrOfGrnt"))]
    pub lttr_of_grnt: LetterOfGuarantee4Choice,

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

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

    #[yaserde(rename = "CshSubBalTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CshSubBalTp"))]
    pub csh_sub_bal_tp: GenericIdentification30,
}

impl Validate for SettlementDetails221 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.13")]
pub struct SettlementParties126 {
    #[yaserde(rename = "Dpstry")]
    #[cfg_attr(feature = "serde", serde(rename = "Dpstry"))]
    pub dpstry: PartyIdentification315,

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

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

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

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

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

impl Validate for SettlementParties126 {}


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

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.025.001.13")]
pub struct SettlementStandingInstructionDatabase4Choice {
    #[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<GenericIdentification30>,
}

impl Validate for SettlementStandingInstructionDatabase4Choice {}




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

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.025.001.13")]
pub struct SettlementSystemMethod4Choice {
    #[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<GenericIdentification30>,
}

impl Validate for SettlementSystemMethod4Choice {}




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

pub enum SettlementTransactionCondition16Code {
    #[yaserde(rename = "ADEA")]
    #[cfg_attr(feature = "serde", serde(rename = "ADEA"))]
    Adea,
    #[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 = "DLWM")]
    #[cfg_attr(feature = "serde", serde(rename = "DLWM"))]
    Dlwm,
    #[yaserde(rename = "DIRT")]
    #[cfg_attr(feature = "serde", serde(rename = "DIRT"))]
    Dirt,
    #[yaserde(rename = "DRAW")]
    #[cfg_attr(feature = "serde", serde(rename = "DRAW"))]
    Draw,
    #[yaserde(rename = "EXER")]
    #[cfg_attr(feature = "serde", serde(rename = "EXER"))]
    Exer,
    #[yaserde(rename = "EXPI")]
    #[cfg_attr(feature = "serde", serde(rename = "EXPI"))]
    Expi,
    #[yaserde(rename = "FRCL")]
    #[cfg_attr(feature = "serde", serde(rename = "FRCL"))]
    Frcl,
    #[yaserde(rename = "GATE")]
    #[cfg_attr(feature = "serde", serde(rename = "GATE"))]
    Gate,
    #[yaserde(rename = "INTS")]
    #[cfg_attr(feature = "serde", serde(rename = "INTS"))]
    Ints,
    #[yaserde(rename = "KNOC")]
    #[cfg_attr(feature = "serde", serde(rename = "KNOC"))]
    Knoc,
    #[yaserde(rename = "NOMC")]
    #[cfg_attr(feature = "serde", serde(rename = "NOMC"))]
    Nomc,
    #[yaserde(rename = "NACT")]
    #[cfg_attr(feature = "serde", serde(rename = "NACT"))]
    Nact,
    #[yaserde(rename = "BPSS")]
    #[cfg_attr(feature = "serde", serde(rename = "BPSS"))]
    Bpss,
    #[yaserde(rename = "PENS")]
    #[cfg_attr(feature = "serde", serde(rename = "PENS"))]
    Pens,
    #[yaserde(rename = "PHYS")]
    #[cfg_attr(feature = "serde", serde(rename = "PHYS"))]
    Phys,
    #[yaserde(rename = "RHYP")]
    #[cfg_attr(feature = "serde", serde(rename = "RHYP"))]
    Rhyp,
    #[yaserde(rename = "RPTO")]
    #[cfg_attr(feature = "serde", serde(rename = "RPTO"))]
    Rpto,
    #[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 = "TRAN")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAN"))]
    Tran,
    #[yaserde(rename = "TRIP")]
    #[cfg_attr(feature = "serde", serde(rename = "TRIP"))]
    Trip,
    #[yaserde(rename = "UNEX")]
    #[cfg_attr(feature = "serde", serde(rename = "UNEX"))]
    Unex,
    __Unknown__(String),
}

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

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

impl Validate for SettlementTransactionCondition41Choice {}




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

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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.025.001.13")]
pub struct SettlementTypeAndIdentification29 {
    #[yaserde(rename = "AcctOwnrTxId")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctOwnrTxId"))]
    pub acct_ownr_tx_id: Max35Text,

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

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

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

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

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

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

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

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

impl Validate for SettlementTypeAndIdentification29 {}


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

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.025.001.13")]
pub struct SettlingCapacity7Choice {
    #[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<GenericIdentification30>,
}

impl Validate for SettlingCapacity7Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.13")]
pub struct StandingSettlementInstruction20 {
    #[yaserde(rename = "SttlmStgInstrDB")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmStgInstrDB"))]
    pub sttlm_stg_instr_db: SettlementStandingInstructionDatabase4Choice,

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

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

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

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

impl Validate for StandingSettlementInstruction20 {}


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

impl Validate for TaxCapacityParty4Choice {}




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

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.025.001.13")]
pub struct TradeDate8Choice {
    #[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<TradeDateCode3Choice>,
}

impl Validate for TradeDate8Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.13")]
pub struct TradeDateCode3Choice {
    #[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<GenericIdentification30>,
}

impl Validate for TradeDateCode3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.13")]
pub struct TradeOriginator3Choice {
    #[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<GenericIdentification30>,
}

impl Validate for TradeOriginator3Choice {}




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

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.025.001.13")]
pub struct TradeTransactionCondition5Choice {
    #[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<GenericIdentification30>,
}

impl Validate for TradeTransactionCondition5Choice {}




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

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

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

impl Validate for TypeOfIdentification1Code {}



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

pub enum TypeOfPrice14Code {
    #[yaserde(rename = "AVER")]
    #[cfg_attr(feature = "serde", serde(rename = "AVER"))]
    Aver,
    __Unknown__(String),
}

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

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

impl Validate for TypeOfPrice29Choice {}




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

impl Validate for Utiidentifier {}
#[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.025.001.13")]
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.025.001.13")]
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 = "025";
    const VARIANT: &'static str = "001";
    const VERSION: &'static str = "13";
    const MESSAGE_NAME: &'static str = "sese.025.001.13";
    const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:sese.025.001.13";
}