rust_iso20022 0.1.0

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

// pub type Document = Document;
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
pub struct AcknowledgedAcceptedStatus21Choice {
    #[yaserde(rename = "NoSpcfdRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "NoSpcfdRsn"))]
    pub no_spcfd_rsn: Option<NoReasonCode>,
    #[yaserde(rename = "Rsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
    pub rsn: Vec<AcknowledgementReason9>,
}

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

impl Validate for AcknowledgementReason12Choice {}




#[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:semt.018.001.15")]

pub enum AcknowledgementReason5Code {
    #[yaserde(rename = "ADEA")]
    #[cfg_attr(feature = "serde", serde(rename = "ADEA"))]
    Adea,
    #[yaserde(rename = "SMPG")]
    #[cfg_attr(feature = "serde", serde(rename = "SMPG"))]
    Smpg,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "CDCY")]
    #[cfg_attr(feature = "serde", serde(rename = "CDCY"))]
    Cdcy,
    #[yaserde(rename = "CDRG")]
    #[cfg_attr(feature = "serde", serde(rename = "CDRG"))]
    Cdrg,
    #[yaserde(rename = "CDRE")]
    #[cfg_attr(feature = "serde", serde(rename = "CDRE"))]
    Cdre,
    #[yaserde(rename = "NSTP")]
    #[cfg_attr(feature = "serde", serde(rename = "NSTP"))]
    Nstp,
    #[yaserde(rename = "RQWV")]
    #[cfg_attr(feature = "serde", serde(rename = "RQWV"))]
    Rqwv,
    #[yaserde(rename = "LATE")]
    #[cfg_attr(feature = "serde", serde(rename = "LATE"))]
    Late,
    __Unknown__(String),
}

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

impl Validate for AcknowledgementReason5Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
pub struct AcknowledgementReason9 {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: AcknowledgementReason12Choice,

    #[yaserde(rename = "AddtlRsnInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlRsnInf"))]
    pub addtl_rsn_inf: Max210Text,
}

impl Validate for AcknowledgementReason9 {}


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

impl Validate for ActiveCurrencyAndAmount {}


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

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

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

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

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:semt.018.001.15")]
pub struct AmountAndDirection51 {
    #[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,
}

impl Validate for AmountAndDirection51 {}


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

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

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:semt.018.001.15")]
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
pub struct CancellationReason22 {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: CancellationReason36Choice,

    #[yaserde(rename = "AddtlRsnInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlRsnInf"))]
    pub addtl_rsn_inf: Max210Text,
}

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

impl Validate for CancellationReason36Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
pub struct CancellationStatus24Choice {
    #[yaserde(rename = "NoSpcfdRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "NoSpcfdRsn"))]
    pub no_spcfd_rsn: Option<NoReasonCode>,
    #[yaserde(rename = "Rsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
    pub rsn: Vec<CancellationReason22>,
}

impl Validate for CancellationStatus24Choice {}




#[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:semt.018.001.15")]

pub enum CancelledStatusReason16Code {
    #[yaserde(rename = "SCEX")]
    #[cfg_attr(feature = "serde", serde(rename = "SCEX"))]
    Scex,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "CXLR")]
    #[cfg_attr(feature = "serde", serde(rename = "CXLR"))]
    Cxlr,
    #[yaserde(rename = "BYIY")]
    #[cfg_attr(feature = "serde", serde(rename = "BYIY"))]
    Byiy,
    #[yaserde(rename = "CTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "CTHP"))]
    Cthp,
    #[yaserde(rename = "CANZ")]
    #[cfg_attr(feature = "serde", serde(rename = "CANZ"))]
    Canz,
    #[yaserde(rename = "CANT")]
    #[cfg_attr(feature = "serde", serde(rename = "CANT"))]
    Cant,
    #[yaserde(rename = "CSUB")]
    #[cfg_attr(feature = "serde", serde(rename = "CSUB"))]
    Csub,
    #[yaserde(rename = "CANS")]
    #[cfg_attr(feature = "serde", serde(rename = "CANS"))]
    Cans,
    #[yaserde(rename = "CANI")]
    #[cfg_attr(feature = "serde", serde(rename = "CANI"))]
    Cani,
    #[yaserde(rename = "CORP")]
    #[cfg_attr(feature = "serde", serde(rename = "CORP"))]
    Corp,
    __Unknown__(String),
}

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

impl Validate for CancelledStatusReason16Code {}



#[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:semt.018.001.15")]

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

impl Validate for CorporateActionEventType110Choice {}




#[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:semt.018.001.15")]

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

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

impl Validate for CorporateActionEventType38Code {}



#[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:semt.018.001.15")]

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

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

impl Validate for CreditDebitCode {}



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

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

impl Validate for DateAndDateTime2Choice {}




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

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

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

impl Validate for DateType3Code {}



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

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

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

impl Validate for DateType4Code {}



#[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:semt.018.001.15")]

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

    #[yaserde(rename = "ElctrncMnyTknSttlmQty")]
    #[cfg_attr(feature = "serde", serde(rename = "ElctrncMnyTknSttlmQty"))]
    pub elctrnc_mny_tkn_sttlm_qty: Max30DecimalNumber,

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

impl Validate for DigitalPaymentSettlement2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
pub struct Document {
    #[yaserde(rename = "SctiesTxPdgRpt")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesTxPdgRpt"))]
    pub scties_tx_pdg_rpt: SecuritiesTransactionPendingReportV15,
}

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:semt.018.001.15")]

pub enum EventFrequency4Code {
    #[yaserde(rename = "YEAR")]
    #[cfg_attr(feature = "serde", serde(rename = "YEAR"))]
    Year,
    #[yaserde(rename = "ADHO")]
    #[cfg_attr(feature = "serde", serde(rename = "ADHO"))]
    Adho,
    #[yaserde(rename = "MNTH")]
    #[cfg_attr(feature = "serde", serde(rename = "MNTH"))]
    Mnth,
    #[yaserde(rename = "DAIL")]
    #[cfg_attr(feature = "serde", serde(rename = "DAIL"))]
    Dail,
    #[yaserde(rename = "INDA")]
    #[cfg_attr(feature = "serde", serde(rename = "INDA"))]
    Inda,
    #[yaserde(rename = "WEEK")]
    #[cfg_attr(feature = "serde", serde(rename = "WEEK"))]
    Week,
    __Unknown__(String),
}

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

impl Validate for EventFrequency4Code {}



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

impl Validate for Exact5NumericText {}
#[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:semt.018.001.15")]
pub struct FailingReason11 {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: FailingReason16Choice,

    #[yaserde(rename = "AddtlRsnInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlRsnInf"))]
    pub addtl_rsn_inf: Max210Text,
}

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

impl Validate for FailingReason16Choice {}




#[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:semt.018.001.15")]

pub enum FailingReason4Code {
    #[yaserde(rename = "AWMO")]
    #[cfg_attr(feature = "serde", serde(rename = "AWMO"))]
    Awmo,
    #[yaserde(rename = "BYIY")]
    #[cfg_attr(feature = "serde", serde(rename = "BYIY"))]
    Byiy,
    #[yaserde(rename = "CLAT")]
    #[cfg_attr(feature = "serde", serde(rename = "CLAT"))]
    Clat,
    #[yaserde(rename = "ADEA")]
    #[cfg_attr(feature = "serde", serde(rename = "ADEA"))]
    Adea,
    #[yaserde(rename = "CANR")]
    #[cfg_attr(feature = "serde", serde(rename = "CANR"))]
    Canr,
    #[yaserde(rename = "CAIS")]
    #[cfg_attr(feature = "serde", serde(rename = "CAIS"))]
    Cais,
    #[yaserde(rename = "OBJT")]
    #[cfg_attr(feature = "serde", serde(rename = "OBJT"))]
    Objt,
    #[yaserde(rename = "AWSH")]
    #[cfg_attr(feature = "serde", serde(rename = "AWSH"))]
    Awsh,
    #[yaserde(rename = "PHSE")]
    #[cfg_attr(feature = "serde", serde(rename = "PHSE"))]
    Phse,
    #[yaserde(rename = "STCD")]
    #[cfg_attr(feature = "serde", serde(rename = "STCD"))]
    Stcd,
    #[yaserde(rename = "DOCY")]
    #[cfg_attr(feature = "serde", serde(rename = "DOCY"))]
    Docy,
    #[yaserde(rename = "MLAT")]
    #[cfg_attr(feature = "serde", serde(rename = "MLAT"))]
    Mlat,
    #[yaserde(rename = "DOCC")]
    #[cfg_attr(feature = "serde", serde(rename = "DOCC"))]
    Docc,
    #[yaserde(rename = "BLOC")]
    #[cfg_attr(feature = "serde", serde(rename = "BLOC"))]
    Bloc,
    #[yaserde(rename = "CHAS")]
    #[cfg_attr(feature = "serde", serde(rename = "CHAS"))]
    Chas,
    #[yaserde(rename = "NEWI")]
    #[cfg_attr(feature = "serde", serde(rename = "NEWI"))]
    Newi,
    #[yaserde(rename = "CLAC")]
    #[cfg_attr(feature = "serde", serde(rename = "CLAC"))]
    Clac,
    #[yaserde(rename = "MUNO")]
    #[cfg_attr(feature = "serde", serde(rename = "MUNO"))]
    Muno,
    #[yaserde(rename = "GLOB")]
    #[cfg_attr(feature = "serde", serde(rename = "GLOB"))]
    Glob,
    #[yaserde(rename = "PREA")]
    #[cfg_attr(feature = "serde", serde(rename = "PREA"))]
    Prea,
    #[yaserde(rename = "PART")]
    #[cfg_attr(feature = "serde", serde(rename = "PART"))]
    Part,
    #[yaserde(rename = "NOFX")]
    #[cfg_attr(feature = "serde", serde(rename = "NOFX"))]
    Nofx,
    #[yaserde(rename = "CMON")]
    #[cfg_attr(feature = "serde", serde(rename = "CMON"))]
    Cmon,
    #[yaserde(rename = "YCOL")]
    #[cfg_attr(feature = "serde", serde(rename = "YCOL"))]
    Ycol,
    #[yaserde(rename = "COLL")]
    #[cfg_attr(feature = "serde", serde(rename = "COLL"))]
    Coll,
    #[yaserde(rename = "DEPO")]
    #[cfg_attr(feature = "serde", serde(rename = "DEPO"))]
    Depo,
    #[yaserde(rename = "FLIM")]
    #[cfg_attr(feature = "serde", serde(rename = "FLIM"))]
    Flim,
    #[yaserde(rename = "INCA")]
    #[cfg_attr(feature = "serde", serde(rename = "INCA"))]
    Inca,
    #[yaserde(rename = "LINK")]
    #[cfg_attr(feature = "serde", serde(rename = "LINK"))]
    Link,
    #[yaserde(rename = "LACK")]
    #[cfg_attr(feature = "serde", serde(rename = "LACK"))]
    Lack,
    #[yaserde(rename = "LALO")]
    #[cfg_attr(feature = "serde", serde(rename = "LALO"))]
    Lalo,
    #[yaserde(rename = "MONY")]
    #[cfg_attr(feature = "serde", serde(rename = "MONY"))]
    Mony,
    #[yaserde(rename = "NCON")]
    #[cfg_attr(feature = "serde", serde(rename = "NCON"))]
    Ncon,
    #[yaserde(rename = "REFS")]
    #[cfg_attr(feature = "serde", serde(rename = "REFS"))]
    Refs,
    #[yaserde(rename = "SDUT")]
    #[cfg_attr(feature = "serde", serde(rename = "SDUT"))]
    Sdut,
    #[yaserde(rename = "BATC")]
    #[cfg_attr(feature = "serde", serde(rename = "BATC"))]
    Batc,
    #[yaserde(rename = "CYCL")]
    #[cfg_attr(feature = "serde", serde(rename = "CYCL"))]
    Cycl,
    #[yaserde(rename = "SBLO")]
    #[cfg_attr(feature = "serde", serde(rename = "SBLO"))]
    Sblo,
    #[yaserde(rename = "CPEC")]
    #[cfg_attr(feature = "serde", serde(rename = "CPEC"))]
    Cpec,
    #[yaserde(rename = "MINO")]
    #[cfg_attr(feature = "serde", serde(rename = "MINO"))]
    Mino,
    #[yaserde(rename = "IAAD")]
    #[cfg_attr(feature = "serde", serde(rename = "IAAD"))]
    Iaad,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "PHCK")]
    #[cfg_attr(feature = "serde", serde(rename = "PHCK"))]
    Phck,
    #[yaserde(rename = "BENO")]
    #[cfg_attr(feature = "serde", serde(rename = "BENO"))]
    Beno,
    #[yaserde(rename = "BOTH")]
    #[cfg_attr(feature = "serde", serde(rename = "BOTH"))]
    Both,
    #[yaserde(rename = "CLHT")]
    #[cfg_attr(feature = "serde", serde(rename = "CLHT"))]
    Clht,
    #[yaserde(rename = "DENO")]
    #[cfg_attr(feature = "serde", serde(rename = "DENO"))]
    Deno,
    #[yaserde(rename = "DISA")]
    #[cfg_attr(feature = "serde", serde(rename = "DISA"))]
    Disa,
    #[yaserde(rename = "DKNY")]
    #[cfg_attr(feature = "serde", serde(rename = "DKNY"))]
    Dkny,
    #[yaserde(rename = "FROZ")]
    #[cfg_attr(feature = "serde", serde(rename = "FROZ"))]
    Froz,
    #[yaserde(rename = "LAAW")]
    #[cfg_attr(feature = "serde", serde(rename = "LAAW"))]
    Laaw,
    #[yaserde(rename = "LATE")]
    #[cfg_attr(feature = "serde", serde(rename = "LATE"))]
    Late,
    #[yaserde(rename = "LIQU")]
    #[cfg_attr(feature = "serde", serde(rename = "LIQU"))]
    Liqu,
    #[yaserde(rename = "PRCY")]
    #[cfg_attr(feature = "serde", serde(rename = "PRCY"))]
    Prcy,
    #[yaserde(rename = "REGT")]
    #[cfg_attr(feature = "serde", serde(rename = "REGT"))]
    Regt,
    #[yaserde(rename = "SETS")]
    #[cfg_attr(feature = "serde", serde(rename = "SETS"))]
    Sets,
    #[yaserde(rename = "CERT")]
    #[cfg_attr(feature = "serde", serde(rename = "CERT"))]
    Cert,
    #[yaserde(rename = "PRSY")]
    #[cfg_attr(feature = "serde", serde(rename = "PRSY"))]
    Prsy,
    #[yaserde(rename = "CDLR")]
    #[cfg_attr(feature = "serde", serde(rename = "CDLR"))]
    Cdlr,
    #[yaserde(rename = "CSDH")]
    #[cfg_attr(feature = "serde", serde(rename = "CSDH"))]
    Csdh,
    #[yaserde(rename = "CVAL")]
    #[cfg_attr(feature = "serde", serde(rename = "CVAL"))]
    Cval,
    #[yaserde(rename = "INBC")]
    #[cfg_attr(feature = "serde", serde(rename = "INBC"))]
    Inbc,
    #[yaserde(rename = "PREL")]
    #[cfg_attr(feature = "serde", serde(rename = "PREL"))]
    Prel,
    #[yaserde(rename = "PATD")]
    #[cfg_attr(feature = "serde", serde(rename = "PATD"))]
    Patd,
    __Unknown__(String),
}

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

impl Validate for FailingReason4Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
pub struct FailingStatus13Choice {
    #[yaserde(rename = "NoSpcfdRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "NoSpcfdRsn"))]
    pub no_spcfd_rsn: Option<NoReasonCode>,
    #[yaserde(rename = "Rsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
    pub rsn: Vec<FailingReason11>,
}

impl Validate for FailingStatus13Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
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:semt.018.001.15")]
pub struct Frequency25Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<EventFrequency4Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification30>,
}

impl Validate for Frequency25Choice {}




#[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:semt.018.001.15")]

pub enum GeneratedReason3Code {
    #[yaserde(rename = "COLL")]
    #[cfg_attr(feature = "serde", serde(rename = "COLL"))]
    Coll,
    #[yaserde(rename = "CLAI")]
    #[cfg_attr(feature = "serde", serde(rename = "CLAI"))]
    Clai,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "RODE")]
    #[cfg_attr(feature = "serde", serde(rename = "RODE"))]
    Rode,
    #[yaserde(rename = "SPLI")]
    #[cfg_attr(feature = "serde", serde(rename = "SPLI"))]
    Spli,
    #[yaserde(rename = "THRD")]
    #[cfg_attr(feature = "serde", serde(rename = "THRD"))]
    Thrd,
    #[yaserde(rename = "TRAN")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAN"))]
    Tran,
    __Unknown__(String),
}

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

impl Validate for GeneratedReason3Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
pub struct GeneratedReason5 {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: GeneratedReasons5Choice,

    #[yaserde(rename = "AddtlRsnInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlRsnInf"))]
    pub addtl_rsn_inf: Max210Text,
}

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

impl Validate for GeneratedReasons5Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
pub struct GeneratedStatus7Choice {
    #[yaserde(rename = "NoSpcfdRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "NoSpcfdRsn"))]
    pub no_spcfd_rsn: Option<NoReasonCode>,
    #[yaserde(rename = "Rsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
    pub rsn: Vec<GeneratedReason5>,
}

impl Validate for GeneratedStatus7Choice {}




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

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

impl Validate for GenericIdentification78 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
pub struct HoldIndicator6 {
    #[yaserde(rename = "Ind")]
    #[cfg_attr(feature = "serde", serde(rename = "Ind"))]
    pub ind: YesNoIndicator,

    #[yaserde(rename = "Rsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
    pub rsn: Vec<RegistrationReason5>,
}

impl Validate for HoldIndicator6 {}


#[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:semt.018.001.15")]
pub struct IdentificationSource3Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ExternalFinancialInstrumentIdentificationType1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max35Text>,
}

impl Validate for IdentificationSource3Choice {}




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

impl Validate for ImpliedCurrencyAndAmount {
    fn validate(&self) -> Result<(), String> { 
        if self.0 < "0".parse::<String>().unwrap() {
            return Err(format!("MinInclusive validation error: invalid value of 0! \nExpected: 0 >= 0.\nActual: 0 == {}", self.0));
        }
        Ok(())
    }
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
pub struct InstructionProcessingStatus61Choice {
    #[yaserde(rename = "PdgPrcg")]
    #[cfg_attr(feature = "serde", serde(rename = "PdgPrcg"))]
    pub pdg_prcg: Option<PendingProcessingStatus20Choice>,
    #[yaserde(rename = "CxlReqd")]
    #[cfg_attr(feature = "serde", serde(rename = "CxlReqd"))]
    pub cxl_reqd: Option<ProprietaryReason4>,
    #[yaserde(rename = "AckdAccptd")]
    #[cfg_attr(feature = "serde", serde(rename = "AckdAccptd"))]
    pub ackd_accptd: Option<AcknowledgedAcceptedStatus21Choice>,
    #[yaserde(rename = "Canc")]
    #[cfg_attr(feature = "serde", serde(rename = "Canc"))]
    pub canc: Option<CancellationStatus24Choice>,
    #[yaserde(rename = "Gnrtd")]
    #[cfg_attr(feature = "serde", serde(rename = "Gnrtd"))]
    pub gnrtd: Option<GeneratedStatus7Choice>,
    #[yaserde(rename = "Rpr")]
    #[cfg_attr(feature = "serde", serde(rename = "Rpr"))]
    pub rpr: Option<RepairStatus12Choice>,
    #[yaserde(rename = "PdgCxl")]
    #[cfg_attr(feature = "serde", serde(rename = "PdgCxl"))]
    pub pdg_cxl: Option<PendingStatus81Choice>,
    #[yaserde(rename = "ModReqd")]
    #[cfg_attr(feature = "serde", serde(rename = "ModReqd"))]
    pub mod_reqd: Option<ProprietaryReason4>,
}

impl Validate for InstructionProcessingStatus61Choice {}




#[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:semt.018.001.15")]
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)]
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:semt.018.001.15")]

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:semt.018.001.15")]
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:semt.018.001.15")]
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:semt.018.001.15")]
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:semt.018.001.15")]

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:semt.018.001.15")]
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
pub struct MatchingStatus24Choice {
    #[yaserde(rename = "Mtchd")]
    #[cfg_attr(feature = "serde", serde(rename = "Mtchd"))]
    pub mtchd: Option<ProprietaryReason4>,
    #[yaserde(rename = "Umtchd")]
    #[cfg_attr(feature = "serde", serde(rename = "Umtchd"))]
    pub umtchd: Option<UnmatchedStatus16Choice>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<ProprietaryStatusAndReason6>,
}

impl Validate for MatchingStatus24Choice {}




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

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

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

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

pub enum NoReasonCode {
    #[yaserde(rename = "NORE")]
    #[cfg_attr(feature = "serde", serde(rename = "NORE"))]
    Nore,
    __Unknown__(String),
}

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

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

impl Validate for Number3Choice {}




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

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

impl Validate for OriginalAndCurrentQuantities1 {}


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

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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
pub struct Pagination1 {
    #[yaserde(rename = "PgNb")]
    #[cfg_attr(feature = "serde", serde(rename = "PgNb"))]
    pub pg_nb: Max5NumericText,

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

impl Validate for Pagination1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
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:semt.018.001.15")]
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:semt.018.001.15")]
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:semt.018.001.15")]
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:semt.018.001.15")]
pub struct PartyIdentification314 {
    #[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 = "PrcgId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrcgId"))]
    pub prcg_id: Max35Text,
}

impl Validate for PartyIdentification314 {}


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

impl Validate for PartyIdentificationAndAccount195 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
pub struct PendingProcessingReason17 {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: PendingProcessingReason19Choice,

    #[yaserde(rename = "AddtlRsnInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlRsnInf"))]
    pub addtl_rsn_inf: Max210Text,
}

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

impl Validate for PendingProcessingReason19Choice {}




#[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:semt.018.001.15")]

pub enum PendingProcessingReason5Code {
    #[yaserde(rename = "ADEA")]
    #[cfg_attr(feature = "serde", serde(rename = "ADEA"))]
    Adea,
    #[yaserde(rename = "CAIS")]
    #[cfg_attr(feature = "serde", serde(rename = "CAIS"))]
    Cais,
    #[yaserde(rename = "DOCY")]
    #[cfg_attr(feature = "serde", serde(rename = "DOCY"))]
    Docy,
    #[yaserde(rename = "BLOC")]
    #[cfg_attr(feature = "serde", serde(rename = "BLOC"))]
    Bloc,
    #[yaserde(rename = "MUNO")]
    #[cfg_attr(feature = "serde", serde(rename = "MUNO"))]
    Muno,
    #[yaserde(rename = "GLOB")]
    #[cfg_attr(feature = "serde", serde(rename = "GLOB"))]
    Glob,
    #[yaserde(rename = "PREA")]
    #[cfg_attr(feature = "serde", serde(rename = "PREA"))]
    Prea,
    #[yaserde(rename = "YCOL")]
    #[cfg_attr(feature = "serde", serde(rename = "YCOL"))]
    Ycol,
    #[yaserde(rename = "COLL")]
    #[cfg_attr(feature = "serde", serde(rename = "COLL"))]
    Coll,
    #[yaserde(rename = "FLIM")]
    #[cfg_attr(feature = "serde", serde(rename = "FLIM"))]
    Flim,
    #[yaserde(rename = "NOFX")]
    #[cfg_attr(feature = "serde", serde(rename = "NOFX"))]
    Nofx,
    #[yaserde(rename = "LACK")]
    #[cfg_attr(feature = "serde", serde(rename = "LACK"))]
    Lack,
    #[yaserde(rename = "LALO")]
    #[cfg_attr(feature = "serde", serde(rename = "LALO"))]
    Lalo,
    #[yaserde(rename = "MONY")]
    #[cfg_attr(feature = "serde", serde(rename = "MONY"))]
    Mony,
    #[yaserde(rename = "MINO")]
    #[cfg_attr(feature = "serde", serde(rename = "MINO"))]
    Mino,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "DENO")]
    #[cfg_attr(feature = "serde", serde(rename = "DENO"))]
    Deno,
    #[yaserde(rename = "LIQU")]
    #[cfg_attr(feature = "serde", serde(rename = "LIQU"))]
    Liqu,
    #[yaserde(rename = "CERT")]
    #[cfg_attr(feature = "serde", serde(rename = "CERT"))]
    Cert,
    #[yaserde(rename = "NEXT")]
    #[cfg_attr(feature = "serde", serde(rename = "NEXT"))]
    Next,
    #[yaserde(rename = "PRSY")]
    #[cfg_attr(feature = "serde", serde(rename = "PRSY"))]
    Prsy,
    #[yaserde(rename = "CSDH")]
    #[cfg_attr(feature = "serde", serde(rename = "CSDH"))]
    Csdh,
    #[yaserde(rename = "CDEL")]
    #[cfg_attr(feature = "serde", serde(rename = "CDEL"))]
    Cdel,
    #[yaserde(rename = "CVAL")]
    #[cfg_attr(feature = "serde", serde(rename = "CVAL"))]
    Cval,
    #[yaserde(rename = "CDLR")]
    #[cfg_attr(feature = "serde", serde(rename = "CDLR"))]
    Cdlr,
    #[yaserde(rename = "INBC")]
    #[cfg_attr(feature = "serde", serde(rename = "INBC"))]
    Inbc,
    #[yaserde(rename = "CDAC")]
    #[cfg_attr(feature = "serde", serde(rename = "CDAC"))]
    Cdac,
    __Unknown__(String),
}

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

impl Validate for PendingProcessingReason5Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
pub struct PendingProcessingStatus20Choice {
    #[yaserde(rename = "NoSpcfdRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "NoSpcfdRsn"))]
    pub no_spcfd_rsn: Option<NoReasonCode>,
    #[yaserde(rename = "Rsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
    pub rsn: Vec<PendingProcessingReason17>,
}

impl Validate for PendingProcessingStatus20Choice {}




#[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:semt.018.001.15")]

pub enum PendingReason24Code {
    #[yaserde(rename = "AWMO")]
    #[cfg_attr(feature = "serde", serde(rename = "AWMO"))]
    Awmo,
    #[yaserde(rename = "ADEA")]
    #[cfg_attr(feature = "serde", serde(rename = "ADEA"))]
    Adea,
    #[yaserde(rename = "CAIS")]
    #[cfg_attr(feature = "serde", serde(rename = "CAIS"))]
    Cais,
    #[yaserde(rename = "REFU")]
    #[cfg_attr(feature = "serde", serde(rename = "REFU"))]
    Refu,
    #[yaserde(rename = "AWSH")]
    #[cfg_attr(feature = "serde", serde(rename = "AWSH"))]
    Awsh,
    #[yaserde(rename = "PHSE")]
    #[cfg_attr(feature = "serde", serde(rename = "PHSE"))]
    Phse,
    #[yaserde(rename = "TAMM")]
    #[cfg_attr(feature = "serde", serde(rename = "TAMM"))]
    Tamm,
    #[yaserde(rename = "DOCY")]
    #[cfg_attr(feature = "serde", serde(rename = "DOCY"))]
    Docy,
    #[yaserde(rename = "DOCC")]
    #[cfg_attr(feature = "serde", serde(rename = "DOCC"))]
    Docc,
    #[yaserde(rename = "BLOC")]
    #[cfg_attr(feature = "serde", serde(rename = "BLOC"))]
    Bloc,
    #[yaserde(rename = "CHAS")]
    #[cfg_attr(feature = "serde", serde(rename = "CHAS"))]
    Chas,
    #[yaserde(rename = "NEWI")]
    #[cfg_attr(feature = "serde", serde(rename = "NEWI"))]
    Newi,
    #[yaserde(rename = "CLAC")]
    #[cfg_attr(feature = "serde", serde(rename = "CLAC"))]
    Clac,
    #[yaserde(rename = "MUNO")]
    #[cfg_attr(feature = "serde", serde(rename = "MUNO"))]
    Muno,
    #[yaserde(rename = "GLOB")]
    #[cfg_attr(feature = "serde", serde(rename = "GLOB"))]
    Glob,
    #[yaserde(rename = "PREA")]
    #[cfg_attr(feature = "serde", serde(rename = "PREA"))]
    Prea,
    #[yaserde(rename = "PART")]
    #[cfg_attr(feature = "serde", serde(rename = "PART"))]
    Part,
    #[yaserde(rename = "NMAS")]
    #[cfg_attr(feature = "serde", serde(rename = "NMAS"))]
    Nmas,
    #[yaserde(rename = "NOFX")]
    #[cfg_attr(feature = "serde", serde(rename = "NOFX"))]
    Nofx,
    #[yaserde(rename = "CMON")]
    #[cfg_attr(feature = "serde", serde(rename = "CMON"))]
    Cmon,
    #[yaserde(rename = "YCOL")]
    #[cfg_attr(feature = "serde", serde(rename = "YCOL"))]
    Ycol,
    #[yaserde(rename = "COLL")]
    #[cfg_attr(feature = "serde", serde(rename = "COLL"))]
    Coll,
    #[yaserde(rename = "DEPO")]
    #[cfg_attr(feature = "serde", serde(rename = "DEPO"))]
    Depo,
    #[yaserde(rename = "FLIM")]
    #[cfg_attr(feature = "serde", serde(rename = "FLIM"))]
    Flim,
    #[yaserde(rename = "INCA")]
    #[cfg_attr(feature = "serde", serde(rename = "INCA"))]
    Inca,
    #[yaserde(rename = "LINK")]
    #[cfg_attr(feature = "serde", serde(rename = "LINK"))]
    Link,
    #[yaserde(rename = "FUTU")]
    #[cfg_attr(feature = "serde", serde(rename = "FUTU"))]
    Futu,
    #[yaserde(rename = "LACK")]
    #[cfg_attr(feature = "serde", serde(rename = "LACK"))]
    Lack,
    #[yaserde(rename = "LALO")]
    #[cfg_attr(feature = "serde", serde(rename = "LALO"))]
    Lalo,
    #[yaserde(rename = "MONY")]
    #[cfg_attr(feature = "serde", serde(rename = "MONY"))]
    Mony,
    #[yaserde(rename = "NCON")]
    #[cfg_attr(feature = "serde", serde(rename = "NCON"))]
    Ncon,
    #[yaserde(rename = "REFS")]
    #[cfg_attr(feature = "serde", serde(rename = "REFS"))]
    Refs,
    #[yaserde(rename = "SDUT")]
    #[cfg_attr(feature = "serde", serde(rename = "SDUT"))]
    Sdut,
    #[yaserde(rename = "BATC")]
    #[cfg_attr(feature = "serde", serde(rename = "BATC"))]
    Batc,
    #[yaserde(rename = "SBLO")]
    #[cfg_attr(feature = "serde", serde(rename = "SBLO"))]
    Sblo,
    #[yaserde(rename = "CPEC")]
    #[cfg_attr(feature = "serde", serde(rename = "CPEC"))]
    Cpec,
    #[yaserde(rename = "MINO")]
    #[cfg_attr(feature = "serde", serde(rename = "MINO"))]
    Mino,
    #[yaserde(rename = "IAAD")]
    #[cfg_attr(feature = "serde", serde(rename = "IAAD"))]
    Iaad,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "PHCK")]
    #[cfg_attr(feature = "serde", serde(rename = "PHCK"))]
    Phck,
    #[yaserde(rename = "BENO")]
    #[cfg_attr(feature = "serde", serde(rename = "BENO"))]
    Beno,
    #[yaserde(rename = "BOTH")]
    #[cfg_attr(feature = "serde", serde(rename = "BOTH"))]
    Both,
    #[yaserde(rename = "CLHT")]
    #[cfg_attr(feature = "serde", serde(rename = "CLHT"))]
    Clht,
    #[yaserde(rename = "DENO")]
    #[cfg_attr(feature = "serde", serde(rename = "DENO"))]
    Deno,
    #[yaserde(rename = "DISA")]
    #[cfg_attr(feature = "serde", serde(rename = "DISA"))]
    Disa,
    #[yaserde(rename = "DKNY")]
    #[cfg_attr(feature = "serde", serde(rename = "DKNY"))]
    Dkny,
    #[yaserde(rename = "FROZ")]
    #[cfg_attr(feature = "serde", serde(rename = "FROZ"))]
    Froz,
    #[yaserde(rename = "LAAW")]
    #[cfg_attr(feature = "serde", serde(rename = "LAAW"))]
    Laaw,
    #[yaserde(rename = "LATE")]
    #[cfg_attr(feature = "serde", serde(rename = "LATE"))]
    Late,
    #[yaserde(rename = "LIQU")]
    #[cfg_attr(feature = "serde", serde(rename = "LIQU"))]
    Liqu,
    #[yaserde(rename = "PRCY")]
    #[cfg_attr(feature = "serde", serde(rename = "PRCY"))]
    Prcy,
    #[yaserde(rename = "REGT")]
    #[cfg_attr(feature = "serde", serde(rename = "REGT"))]
    Regt,
    #[yaserde(rename = "SETS")]
    #[cfg_attr(feature = "serde", serde(rename = "SETS"))]
    Sets,
    #[yaserde(rename = "CERT")]
    #[cfg_attr(feature = "serde", serde(rename = "CERT"))]
    Cert,
    #[yaserde(rename = "PRSY")]
    #[cfg_attr(feature = "serde", serde(rename = "PRSY"))]
    Prsy,
    #[yaserde(rename = "CSDH")]
    #[cfg_attr(feature = "serde", serde(rename = "CSDH"))]
    Csdh,
    #[yaserde(rename = "CVAL")]
    #[cfg_attr(feature = "serde", serde(rename = "CVAL"))]
    Cval,
    #[yaserde(rename = "CDLR")]
    #[cfg_attr(feature = "serde", serde(rename = "CDLR"))]
    Cdlr,
    #[yaserde(rename = "INBC")]
    #[cfg_attr(feature = "serde", serde(rename = "INBC"))]
    Inbc,
    #[yaserde(rename = "PREL")]
    #[cfg_attr(feature = "serde", serde(rename = "PREL"))]
    Prel,
    #[yaserde(rename = "PATD")]
    #[cfg_attr(feature = "serde", serde(rename = "PATD"))]
    Patd,
    __Unknown__(String),
}

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

impl Validate for PendingReason24Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
pub struct PendingReason30 {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: PendingReason63Choice,

    #[yaserde(rename = "AddtlRsnInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlRsnInf"))]
    pub addtl_rsn_inf: Max210Text,
}

impl Validate for PendingReason30 {}


#[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:semt.018.001.15")]

pub enum PendingReason32Code {
    #[yaserde(rename = "ADEA")]
    #[cfg_attr(feature = "serde", serde(rename = "ADEA"))]
    Adea,
    #[yaserde(rename = "CONF")]
    #[cfg_attr(feature = "serde", serde(rename = "CONF"))]
    Conf,
    #[yaserde(rename = "CDCY")]
    #[cfg_attr(feature = "serde", serde(rename = "CDCY"))]
    Cdcy,
    #[yaserde(rename = "CDRE")]
    #[cfg_attr(feature = "serde", serde(rename = "CDRE"))]
    Cdre,
    #[yaserde(rename = "CDRG")]
    #[cfg_attr(feature = "serde", serde(rename = "CDRG"))]
    Cdrg,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    __Unknown__(String),
}

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

impl Validate for PendingReason32Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
pub struct PendingReason35 {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: PendingReason77Choice,

    #[yaserde(rename = "AddtlRsnInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlRsnInf"))]
    pub addtl_rsn_inf: Max210Text,
}

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

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

impl Validate for PendingReason77Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
pub struct PendingStatus67Choice {
    #[yaserde(rename = "NoSpcfdRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "NoSpcfdRsn"))]
    pub no_spcfd_rsn: Option<NoReasonCode>,
    #[yaserde(rename = "Rsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
    pub rsn: Vec<PendingReason30>,
}

impl Validate for PendingStatus67Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
pub struct PendingStatus81Choice {
    #[yaserde(rename = "NoSpcfdRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "NoSpcfdRsn"))]
    pub no_spcfd_rsn: Option<NoReasonCode>,
    #[yaserde(rename = "Rsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
    pub rsn: Vec<PendingReason35>,
}

impl Validate for PendingStatus81Choice {}




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

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

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

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

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

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

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

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

impl Validate for PostalAddress1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
pub struct ProprietaryReason4 {
    #[yaserde(rename = "Rsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
    pub rsn: GenericIdentification30,

    #[yaserde(rename = "AddtlRsnInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlRsnInf"))]
    pub addtl_rsn_inf: Max210Text,
}

impl Validate for ProprietaryReason4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
pub struct ProprietaryStatusAndReason6 {
    #[yaserde(rename = "PrtrySts")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtrySts"))]
    pub prtry_sts: GenericIdentification30,

    #[yaserde(rename = "PrtryRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryRsn"))]
    pub prtry_rsn: Vec<ProprietaryReason4>,
}

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

impl Validate for Quantity51Choice {}




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

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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
pub struct Registration10Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<Registration2Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification30>,
}

impl Validate for Registration10Choice {}




#[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:semt.018.001.15")]

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

pub enum Registration2Code {
    #[yaserde(rename = "PTYH")]
    #[cfg_attr(feature = "serde", serde(rename = "PTYH"))]
    Ptyh,
    #[yaserde(rename = "CSDH")]
    #[cfg_attr(feature = "serde", serde(rename = "CSDH"))]
    Csdh,
    #[yaserde(rename = "CDEL")]
    #[cfg_attr(feature = "serde", serde(rename = "CDEL"))]
    Cdel,
    #[yaserde(rename = "CVAL")]
    #[cfg_attr(feature = "serde", serde(rename = "CVAL"))]
    Cval,
    __Unknown__(String),
}

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

impl Validate for Registration2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
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:semt.018.001.15")]
pub struct RegistrationReason5 {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Registration10Choice,

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

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

impl Validate for RepairReason10Choice {}




#[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:semt.018.001.15")]

pub enum RepairReason4Code {
    #[yaserde(rename = "BATC")]
    #[cfg_attr(feature = "serde", serde(rename = "BATC"))]
    Batc,
    #[yaserde(rename = "CAEV")]
    #[cfg_attr(feature = "serde", serde(rename = "CAEV"))]
    Caev,
    #[yaserde(rename = "CASH")]
    #[cfg_attr(feature = "serde", serde(rename = "CASH"))]
    Cash,
    #[yaserde(rename = "CASY")]
    #[cfg_attr(feature = "serde", serde(rename = "CASY"))]
    Casy,
    #[yaserde(rename = "DDAT")]
    #[cfg_attr(feature = "serde", serde(rename = "DDAT"))]
    Ddat,
    #[yaserde(rename = "DDEA")]
    #[cfg_attr(feature = "serde", serde(rename = "DDEA"))]
    Ddea,
    #[yaserde(rename = "DMON")]
    #[cfg_attr(feature = "serde", serde(rename = "DMON"))]
    Dmon,
    #[yaserde(rename = "DQUA")]
    #[cfg_attr(feature = "serde", serde(rename = "DQUA"))]
    Dqua,
    #[yaserde(rename = "DSEC")]
    #[cfg_attr(feature = "serde", serde(rename = "DSEC"))]
    Dsec,
    #[yaserde(rename = "DTRD")]
    #[cfg_attr(feature = "serde", serde(rename = "DTRD"))]
    Dtrd,
    #[yaserde(rename = "IIND")]
    #[cfg_attr(feature = "serde", serde(rename = "IIND"))]
    Iind,
    #[yaserde(rename = "MINO")]
    #[cfg_attr(feature = "serde", serde(rename = "MINO"))]
    Mino,
    #[yaserde(rename = "MUNO")]
    #[cfg_attr(feature = "serde", serde(rename = "MUNO"))]
    Muno,
    #[yaserde(rename = "NCRR")]
    #[cfg_attr(feature = "serde", serde(rename = "NCRR"))]
    Ncrr,
    #[yaserde(rename = "PHYS")]
    #[cfg_attr(feature = "serde", serde(rename = "PHYS"))]
    Phys,
    #[yaserde(rename = "PLCE")]
    #[cfg_attr(feature = "serde", serde(rename = "PLCE"))]
    Plce,
    #[yaserde(rename = "REFE")]
    #[cfg_attr(feature = "serde", serde(rename = "REFE"))]
    Refe,
    #[yaserde(rename = "RTGS")]
    #[cfg_attr(feature = "serde", serde(rename = "RTGS"))]
    Rtgs,
    #[yaserde(rename = "SAFE")]
    #[cfg_attr(feature = "serde", serde(rename = "SAFE"))]
    Safe,
    #[yaserde(rename = "SETR")]
    #[cfg_attr(feature = "serde", serde(rename = "SETR"))]
    Setr,
    #[yaserde(rename = "SETS")]
    #[cfg_attr(feature = "serde", serde(rename = "SETS"))]
    Sets,
    #[yaserde(rename = "TXST")]
    #[cfg_attr(feature = "serde", serde(rename = "TXST"))]
    Txst,
    #[yaserde(rename = "INPS")]
    #[cfg_attr(feature = "serde", serde(rename = "INPS"))]
    Inps,
    #[yaserde(rename = "SDUT")]
    #[cfg_attr(feature = "serde", serde(rename = "SDUT"))]
    Sdut,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "IEXE")]
    #[cfg_attr(feature = "serde", serde(rename = "IEXE"))]
    Iexe,
    #[yaserde(rename = "ICAG")]
    #[cfg_attr(feature = "serde", serde(rename = "ICAG"))]
    Icag,
    #[yaserde(rename = "DEPT")]
    #[cfg_attr(feature = "serde", serde(rename = "DEPT"))]
    Dept,
    #[yaserde(rename = "ICUS")]
    #[cfg_attr(feature = "serde", serde(rename = "ICUS"))]
    Icus,
    __Unknown__(String),
}

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

impl Validate for RepairReason4Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
pub struct RepairReason8 {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: RepairReason10Choice,

    #[yaserde(rename = "AddtlRsnInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlRsnInf"))]
    pub addtl_rsn_inf: Max210Text,
}

impl Validate for RepairReason8 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
pub struct RepairStatus12Choice {
    #[yaserde(rename = "NoSpcfdRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "NoSpcfdRsn"))]
    pub no_spcfd_rsn: Option<NoReasonCode>,
    #[yaserde(rename = "Rsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
    pub rsn: Vec<RepairReason8>,
}

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

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:semt.018.001.15")]
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:semt.018.001.15")]
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:semt.018.001.15")]

pub enum SafekeepingPlace1Code {
    #[yaserde(rename = "CUST")]
    #[cfg_attr(feature = "serde", serde(rename = "CUST"))]
    Cust,
    #[yaserde(rename = "ICSD")]
    #[cfg_attr(feature = "serde", serde(rename = "ICSD"))]
    Icsd,
    #[yaserde(rename = "NCSD")]
    #[cfg_attr(feature = "serde", serde(rename = "NCSD"))]
    Ncsd,
    #[yaserde(rename = "SHHE")]
    #[cfg_attr(feature = "serde", serde(rename = "SHHE"))]
    Shhe,
    __Unknown__(String),
}

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

impl Validate for SafekeepingPlace1Code {}



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

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

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

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

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

impl Validate for SafekeepingPlaceTypeAndIdentification1 {}


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

    #[yaserde(rename = "StmtGnlDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "StmtGnlDtls"))]
    pub stmt_gnl_dtls: Statement64,

    #[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 = "Sts")]
    #[cfg_attr(feature = "serde", serde(rename = "Sts"))]
    pub sts: Vec<StatusAndReason49>,

    #[yaserde(rename = "Txs")]
    #[cfg_attr(feature = "serde", serde(rename = "Txs"))]
    pub txs: Vec<Transaction164>,
}

impl Validate for SecuritiesTransactionPendingReportV15 {}


#[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:semt.018.001.15")]

pub enum SecuritiesTransactionType26Code {
    #[yaserde(rename = "BSBK")]
    #[cfg_attr(feature = "serde", serde(rename = "BSBK"))]
    Bsbk,
    #[yaserde(rename = "COLI")]
    #[cfg_attr(feature = "serde", serde(rename = "COLI"))]
    Coli,
    #[yaserde(rename = "COLO")]
    #[cfg_attr(feature = "serde", serde(rename = "COLO"))]
    Colo,
    #[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 = "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 = "REDM")]
    #[cfg_attr(feature = "serde", serde(rename = "REDM"))]
    Redm,
    #[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 = "SECB")]
    #[cfg_attr(feature = "serde", serde(rename = "SECB"))]
    Secb,
    #[yaserde(rename = "SECL")]
    #[cfg_attr(feature = "serde", serde(rename = "SECL"))]
    Secl,
    #[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 = "BYIY")]
    #[cfg_attr(feature = "serde", serde(rename = "BYIY"))]
    Byiy,
    #[yaserde(rename = "CNCB")]
    #[cfg_attr(feature = "serde", serde(rename = "CNCB"))]
    Cncb,
    #[yaserde(rename = "OWNE")]
    #[cfg_attr(feature = "serde", serde(rename = "OWNE"))]
    Owne,
    #[yaserde(rename = "FCTA")]
    #[cfg_attr(feature = "serde", serde(rename = "FCTA"))]
    Fcta,
    #[yaserde(rename = "OWNI")]
    #[cfg_attr(feature = "serde", serde(rename = "OWNI"))]
    Owni,
    #[yaserde(rename = "RELE")]
    #[cfg_attr(feature = "serde", serde(rename = "RELE"))]
    Rele,
    #[yaserde(rename = "SBRE")]
    #[cfg_attr(feature = "serde", serde(rename = "SBRE"))]
    Sbre,
    #[yaserde(rename = "CORP")]
    #[cfg_attr(feature = "serde", serde(rename = "CORP"))]
    Corp,
    #[yaserde(rename = "CLAI")]
    #[cfg_attr(feature = "serde", serde(rename = "CLAI"))]
    Clai,
    #[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 = "CONV")]
    #[cfg_attr(feature = "serde", serde(rename = "CONV"))]
    Conv,
    #[yaserde(rename = "ETFT")]
    #[cfg_attr(feature = "serde", serde(rename = "ETFT"))]
    Etft,
    #[yaserde(rename = "ISSU")]
    #[cfg_attr(feature = "serde", serde(rename = "ISSU"))]
    Issu,
    #[yaserde(rename = "SLRE")]
    #[cfg_attr(feature = "serde", serde(rename = "SLRE"))]
    Slre,
    #[yaserde(rename = "INSP")]
    #[cfg_attr(feature = "serde", serde(rename = "INSP"))]
    Insp,
    #[yaserde(rename = "SBBK")]
    #[cfg_attr(feature = "serde", serde(rename = "SBBK"))]
    Sbbk,
    #[yaserde(rename = "REDI")]
    #[cfg_attr(feature = "serde", serde(rename = "REDI"))]
    Redi,
    #[yaserde(rename = "REBL")]
    #[cfg_attr(feature = "serde", serde(rename = "REBL"))]
    Rebl,
    __Unknown__(String),
}

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

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

impl Validate for SecuritiesTransactionType44Choice {}




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

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

impl Validate for SettlementDateCode8Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
pub struct SettlementDetails232 {
    #[yaserde(rename = "HldInd")]
    #[cfg_attr(feature = "serde", serde(rename = "HldInd"))]
    pub hld_ind: HoldIndicator6,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Validate for SettlementDetails232 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
pub struct SettlementOrCorporateActionEvent34Choice {
    #[yaserde(rename = "SctiesTxTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesTxTp"))]
    pub scties_tx_tp: Option<SecuritiesTransactionType44Choice>,
    #[yaserde(rename = "CorpActnEvtTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CorpActnEvtTp"))]
    pub corp_actn_evt_tp: Option<CorporateActionEventType110Choice>,
}

impl Validate for SettlementOrCorporateActionEvent34Choice {}




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

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

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

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

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

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

impl Validate for SettlementParties125 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
pub struct SettlementStatus30Choice {
    #[yaserde(rename = "Pdg")]
    #[cfg_attr(feature = "serde", serde(rename = "Pdg"))]
    pub pdg: Option<PendingStatus67Choice>,
    #[yaserde(rename = "Flng")]
    #[cfg_attr(feature = "serde", serde(rename = "Flng"))]
    pub flng: Option<FailingStatus13Choice>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<ProprietaryStatusAndReason6>,
}

impl Validate for SettlementStatus30Choice {}




#[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:semt.018.001.15")]

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:semt.018.001.15")]
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:semt.018.001.15")]

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:semt.018.001.15")]
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:semt.018.001.15")]

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

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

impl Validate for SettlementTransactionCondition5Code {}



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

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:semt.018.001.15")]
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:semt.018.001.15")]
pub struct Statement64 {
    #[yaserde(rename = "RptNb")]
    #[cfg_attr(feature = "serde", serde(rename = "RptNb"))]
    pub rpt_nb: Number3Choice,

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

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

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

    #[yaserde(rename = "Frqcy")]
    #[cfg_attr(feature = "serde", serde(rename = "Frqcy"))]
    pub frqcy: Frequency25Choice,

    #[yaserde(rename = "UpdTp")]
    #[cfg_attr(feature = "serde", serde(rename = "UpdTp"))]
    pub upd_tp: UpdateType15Choice,

    #[yaserde(rename = "StmtStr")]
    #[cfg_attr(feature = "serde", serde(rename = "StmtStr"))]
    pub stmt_str: StatementStructure1Code,

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

impl Validate for Statement64 {}


#[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:semt.018.001.15")]

pub enum StatementStructure1Code {
    #[yaserde(rename = "STAT")]
    #[cfg_attr(feature = "serde", serde(rename = "STAT"))]
    Stat,
    #[yaserde(rename = "TRAN")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAN"))]
    Tran,
    __Unknown__(String),
}

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

impl Validate for StatementStructure1Code {}



#[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:semt.018.001.15")]

pub enum StatementUpdateType1Code {
    #[yaserde(rename = "COMP")]
    #[cfg_attr(feature = "serde", serde(rename = "COMP"))]
    Comp,
    #[yaserde(rename = "DELT")]
    #[cfg_attr(feature = "serde", serde(rename = "DELT"))]
    Delt,
    __Unknown__(String),
}

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

impl Validate for StatementUpdateType1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
pub struct Status43Choice {
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<ProprietaryStatusAndReason6>,
    #[yaserde(rename = "MtchgSts")]
    #[cfg_attr(feature = "serde", serde(rename = "MtchgSts"))]
    pub mtchg_sts: Option<MatchingStatus24Choice>,
    #[yaserde(rename = "IfrrdMtchgSts")]
    #[cfg_attr(feature = "serde", serde(rename = "IfrrdMtchgSts"))]
    pub ifrrd_mtchg_sts: Option<MatchingStatus24Choice>,
    #[yaserde(rename = "SttlmSts")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmSts"))]
    pub sttlm_sts: Option<SettlementStatus30Choice>,
    #[yaserde(rename = "InstrPrcgSts")]
    #[cfg_attr(feature = "serde", serde(rename = "InstrPrcgSts"))]
    pub instr_prcg_sts: Option<InstructionProcessingStatus61Choice>,
}

impl Validate for Status43Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
pub struct StatusAndReason49 {
    #[yaserde(rename = "StsAndRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "StsAndRsn"))]
    pub sts_and_rsn: Status43Choice,

    #[yaserde(rename = "Tx")]
    #[cfg_attr(feature = "serde", serde(rename = "Tx"))]
    pub tx: Vec<Transaction166>,
}

impl Validate for StatusAndReason49 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
pub struct SupplementaryData1 {
    #[yaserde(rename = "PlcAndNm")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcAndNm"))]
    pub plc_and_nm: Max350Text,

    #[yaserde(rename = "Envlp")]
    #[cfg_attr(feature = "serde", serde(rename = "Envlp"))]
    pub envlp: SupplementaryDataEnvelope1,
}

impl Validate for SupplementaryData1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
pub struct SupplementaryDataEnvelope1 {}

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

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:semt.018.001.15")]
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:semt.018.001.15")]
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:semt.018.001.15")]
pub struct Transaction164 {
    #[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 = "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 = "PoolId")]
    #[cfg_attr(feature = "serde", serde(rename = "PoolId"))]
    pub pool_id: Max35Text,

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

    #[yaserde(rename = "CorpActnEvtId")]
    #[cfg_attr(feature = "serde", serde(rename = "CorpActnEvtId"))]
    pub corp_actn_evt_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,

    #[yaserde(rename = "TxDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "TxDtls"))]
    pub tx_dtls: TransactionDetails185,

    #[yaserde(rename = "StsAndRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "StsAndRsn"))]
    pub sts_and_rsn: Vec<Status43Choice>,
}

impl Validate for Transaction164 {}


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

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

    #[yaserde(rename = "CorpActnEvtId")]
    #[cfg_attr(feature = "serde", serde(rename = "CorpActnEvtId"))]
    pub corp_actn_evt_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,

    #[yaserde(rename = "TxDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "TxDtls"))]
    pub tx_dtls: TransactionDetails185,
}

impl Validate for Transaction166 {}


#[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:semt.018.001.15")]

pub enum TransactionActivity1Code {
    #[yaserde(rename = "BOLE")]
    #[cfg_attr(feature = "serde", serde(rename = "BOLE"))]
    Bole,
    #[yaserde(rename = "CLAI")]
    #[cfg_attr(feature = "serde", serde(rename = "CLAI"))]
    Clai,
    #[yaserde(rename = "COLL")]
    #[cfg_attr(feature = "serde", serde(rename = "COLL"))]
    Coll,
    #[yaserde(rename = "CORP")]
    #[cfg_attr(feature = "serde", serde(rename = "CORP"))]
    Corp,
    #[yaserde(rename = "SETT")]
    #[cfg_attr(feature = "serde", serde(rename = "SETT"))]
    Sett,
    __Unknown__(String),
}

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

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

impl Validate for TransactionActivity3Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
pub struct TransactionDetails185 {
    #[yaserde(rename = "TxActvty")]
    #[cfg_attr(feature = "serde", serde(rename = "TxActvty"))]
    pub tx_actvty: TransactionActivity3Choice,

    #[yaserde(rename = "SttlmTxOrCorpActnEvtTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmTxOrCorpActnEvtTp"))]
    pub sttlm_tx_or_corp_actn_evt_tp: SettlementOrCorporateActionEvent34Choice,

    #[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 = "SttlmParams")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmParams"))]
    pub sttlm_params: SettlementDetails232,

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

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

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

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

    #[yaserde(rename = "PstngQty")]
    #[cfg_attr(feature = "serde", serde(rename = "PstngQty"))]
    pub pstng_qty: Quantity51Choice,

    #[yaserde(rename = "PrtlyRlsdQty")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtlyRlsdQty"))]
    pub prtly_rlsd_qty: Quantity51Choice,

    #[yaserde(rename = "PstngAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "PstngAmt"))]
    pub pstng_amt: AmountAndDirection51,

    #[yaserde(rename = "DgtlPmtSttlm")]
    #[cfg_attr(feature = "serde", serde(rename = "DgtlPmtSttlm"))]
    pub dgtl_pmt_sttlm: DigitalPaymentSettlement2,

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

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

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

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

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

    #[yaserde(rename = "AckdStsTmStmp")]
    #[cfg_attr(feature = "serde", serde(rename = "AckdStsTmStmp"))]
    pub ackd_sts_tm_stmp: IsodateTime,

    #[yaserde(rename = "MtchdStsTmStmp")]
    #[cfg_attr(feature = "serde", serde(rename = "MtchdStsTmStmp"))]
    pub mtchd_sts_tm_stmp: IsodateTime,

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

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

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

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

impl Validate for TransactionDetails185 {}


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

pub enum UnmatchedReason11Code {
    #[yaserde(rename = "ADEA")]
    #[cfg_attr(feature = "serde", serde(rename = "ADEA"))]
    Adea,
    #[yaserde(rename = "ACRU")]
    #[cfg_attr(feature = "serde", serde(rename = "ACRU"))]
    Acru,
    #[yaserde(rename = "IIND")]
    #[cfg_attr(feature = "serde", serde(rename = "IIND"))]
    Iind,
    #[yaserde(rename = "CPCA")]
    #[cfg_attr(feature = "serde", serde(rename = "CPCA"))]
    Cpca,
    #[yaserde(rename = "CLAT")]
    #[cfg_attr(feature = "serde", serde(rename = "CLAT"))]
    Clat,
    #[yaserde(rename = "NCRR")]
    #[cfg_attr(feature = "serde", serde(rename = "NCRR"))]
    Ncrr,
    #[yaserde(rename = "DDEA")]
    #[cfg_attr(feature = "serde", serde(rename = "DDEA"))]
    Ddea,
    #[yaserde(rename = "DMCT")]
    #[cfg_attr(feature = "serde", serde(rename = "DMCT"))]
    Dmct,
    #[yaserde(rename = "DCMX")]
    #[cfg_attr(feature = "serde", serde(rename = "DCMX"))]
    Dcmx,
    #[yaserde(rename = "DSEC")]
    #[cfg_attr(feature = "serde", serde(rename = "DSEC"))]
    Dsec,
    #[yaserde(rename = "DQUA")]
    #[cfg_attr(feature = "serde", serde(rename = "DQUA"))]
    Dqua,
    #[yaserde(rename = "INVE")]
    #[cfg_attr(feature = "serde", serde(rename = "INVE"))]
    Inve,
    #[yaserde(rename = "LEOG")]
    #[cfg_attr(feature = "serde", serde(rename = "LEOG"))]
    Leog,
    #[yaserde(rename = "LATE")]
    #[cfg_attr(feature = "serde", serde(rename = "LATE"))]
    Late,
    #[yaserde(rename = "MIME")]
    #[cfg_attr(feature = "serde", serde(rename = "MIME"))]
    Mime,
    #[yaserde(rename = "CMIS")]
    #[cfg_attr(feature = "serde", serde(rename = "CMIS"))]
    Cmis,
    #[yaserde(rename = "NMAS")]
    #[cfg_attr(feature = "serde", serde(rename = "NMAS"))]
    Nmas,
    #[yaserde(rename = "DTRA")]
    #[cfg_attr(feature = "serde", serde(rename = "DTRA"))]
    Dtra,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "FRAP")]
    #[cfg_attr(feature = "serde", serde(rename = "FRAP"))]
    Frap,
    #[yaserde(rename = "PHYS")]
    #[cfg_attr(feature = "serde", serde(rename = "PHYS"))]
    Phys,
    #[yaserde(rename = "PLIS")]
    #[cfg_attr(feature = "serde", serde(rename = "PLIS"))]
    Plis,
    #[yaserde(rename = "INPS")]
    #[cfg_attr(feature = "serde", serde(rename = "INPS"))]
    Inps,
    #[yaserde(rename = "PLCE")]
    #[cfg_attr(feature = "serde", serde(rename = "PLCE"))]
    Plce,
    #[yaserde(rename = "PODU")]
    #[cfg_attr(feature = "serde", serde(rename = "PODU"))]
    Podu,
    #[yaserde(rename = "DEPT")]
    #[cfg_attr(feature = "serde", serde(rename = "DEPT"))]
    Dept,
    #[yaserde(rename = "ICAG")]
    #[cfg_attr(feature = "serde", serde(rename = "ICAG"))]
    Icag,
    #[yaserde(rename = "ICUS")]
    #[cfg_attr(feature = "serde", serde(rename = "ICUS"))]
    Icus,
    #[yaserde(rename = "IEXE")]
    #[cfg_attr(feature = "serde", serde(rename = "IEXE"))]
    Iexe,
    #[yaserde(rename = "REGD")]
    #[cfg_attr(feature = "serde", serde(rename = "REGD"))]
    Regd,
    #[yaserde(rename = "RTGS")]
    #[cfg_attr(feature = "serde", serde(rename = "RTGS"))]
    Rtgs,
    #[yaserde(rename = "SAFE")]
    #[cfg_attr(feature = "serde", serde(rename = "SAFE"))]
    Safe,
    #[yaserde(rename = "DMON")]
    #[cfg_attr(feature = "serde", serde(rename = "DMON"))]
    Dmon,
    #[yaserde(rename = "DDAT")]
    #[cfg_attr(feature = "serde", serde(rename = "DDAT"))]
    Ddat,
    #[yaserde(rename = "SETS")]
    #[cfg_attr(feature = "serde", serde(rename = "SETS"))]
    Sets,
    #[yaserde(rename = "SETR")]
    #[cfg_attr(feature = "serde", serde(rename = "SETR"))]
    Setr,
    #[yaserde(rename = "TXST")]
    #[cfg_attr(feature = "serde", serde(rename = "TXST"))]
    Txst,
    #[yaserde(rename = "DTRD")]
    #[cfg_attr(feature = "serde", serde(rename = "DTRD"))]
    Dtrd,
    #[yaserde(rename = "DELN")]
    #[cfg_attr(feature = "serde", serde(rename = "DELN"))]
    Deln,
    #[yaserde(rename = "UNBR")]
    #[cfg_attr(feature = "serde", serde(rename = "UNBR"))]
    Unbr,
    __Unknown__(String),
}

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

impl Validate for UnmatchedReason11Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
pub struct UnmatchedReason15 {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: UnmatchedReason21Choice,

    #[yaserde(rename = "AddtlRsnInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlRsnInf"))]
    pub addtl_rsn_inf: Max210Text,
}

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

impl Validate for UnmatchedReason21Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.018.001.15")]
pub struct UnmatchedStatus16Choice {
    #[yaserde(rename = "NoSpcfdRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "NoSpcfdRsn"))]
    pub no_spcfd_rsn: Option<NoReasonCode>,
    #[yaserde(rename = "Rsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
    pub rsn: Vec<UnmatchedReason15>,
}

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

impl Validate for UpdateType15Choice {}




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

impl Validate for YesNoIndicator {}

impl crate::MxMessage for Document {
    const BUSINESS_AREA: crate::BusinessArea = crate::BusinessArea::semt;
    const FUNCTIONALITY: &'static str = "018";
    const VARIANT: &'static str = "001";
    const VERSION: &'static str = "15";
    const MESSAGE_NAME: &'static str = "semt.018.001.15";
    const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:semt.018.001.15";
}