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:setr.027.001.05")]
pub struct AccountIdentification55Choice {
    #[yaserde(rename = "IBAN")]
    #[cfg_attr(feature = "serde", serde(rename = "IBAN"))]
    pub iban: Option<Iban2007Identifier>,
    #[yaserde(rename = "BBAN")]
    #[cfg_attr(feature = "serde", serde(rename = "BBAN"))]
    pub bban: Option<Bbanidentifier>,
    #[yaserde(rename = "UPIC")]
    #[cfg_attr(feature = "serde", serde(rename = "UPIC"))]
    pub upic: Option<Upicidentifier>,
    #[yaserde(rename = "PrtryAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryAcct"))]
    pub prtry_acct: Option<SimpleIdentificationInformation2>,
}

impl Validate for AccountIdentification55Choice {}




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

impl Validate for ActiveCurrencyAndAmount {}


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

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

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

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

impl Validate for ActiveOrHistoricCurrencyAnd13DecimalAmount {}


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

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

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

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:setr.027.001.05")]
pub struct Agreement5 {
    #[yaserde(rename = "Desc")]
    #[cfg_attr(feature = "serde", serde(rename = "Desc"))]
    pub desc: Max350Text,

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

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

    #[yaserde(rename = "ClsgTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ClsgTp"))]
    pub clsg_tp: ClosingType1Code,

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

    #[yaserde(rename = "DlvryTp")]
    #[cfg_attr(feature = "serde", serde(rename = "DlvryTp"))]
    pub dlvry_tp: DeliveryType2Code,

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

impl Validate for Agreement5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct AlternatePartyIdentification10 {
    #[yaserde(rename = "TpOfId")]
    #[cfg_attr(feature = "serde", serde(rename = "TpOfId"))]
    pub tp_of_id: IdentificationType42Choice,

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

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

impl Validate for AlternatePartyIdentification10 {}


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

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

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

impl Validate for AlternatePartyIdentification8 {}


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

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

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

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

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

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

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

impl Validate for AmountAndDirection28 {}


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

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

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

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

impl Validate for AmountAndDirection29 {}


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

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

impl Validate for AmountAndDirection5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct AmountOrPercentageRange1 {
    #[yaserde(rename = "Opr")]
    #[cfg_attr(feature = "serde", serde(rename = "Opr"))]
    pub opr: Operation1Code,

    #[yaserde(rename = "Term")]
    #[cfg_attr(feature = "serde", serde(rename = "Term"))]
    pub term: Vec<Term1>,
}

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

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

impl Validate for AmountOrRate2Choice {}




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

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

pub enum Appearance1Code {
    #[yaserde(rename = "DELI")]
    #[cfg_attr(feature = "serde", serde(rename = "DELI"))]
    Deli,
    #[yaserde(rename = "NDEL")]
    #[cfg_attr(feature = "serde", serde(rename = "NDEL"))]
    Ndel,
    #[yaserde(rename = "LIMI")]
    #[cfg_attr(feature = "serde", serde(rename = "LIMI"))]
    Limi,
    #[yaserde(rename = "BENT")]
    #[cfg_attr(feature = "serde", serde(rename = "BENT"))]
    Bent,
    #[yaserde(rename = "DFBE")]
    #[cfg_attr(feature = "serde", serde(rename = "DFBE"))]
    Dfbe,
    #[yaserde(rename = "DLBE")]
    #[cfg_attr(feature = "serde", serde(rename = "DLBE"))]
    Dlbe,
    #[yaserde(rename = "TMPG")]
    #[cfg_attr(feature = "serde", serde(rename = "TMPG"))]
    Tmpg,
    #[yaserde(rename = "GLOB")]
    #[cfg_attr(feature = "serde", serde(rename = "GLOB"))]
    Glob,
    __Unknown__(String),
}

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

impl Validate for Appearance1Code {}



#[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:setr.027.001.05")]

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

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

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

impl Validate for AutomaticBorrowing6Choice {}




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

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

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

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

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

pub enum BorrowingReason1Code {
    #[yaserde(rename = "SFCT")]
    #[cfg_attr(feature = "serde", serde(rename = "SFCT"))]
    Sfct,
    #[yaserde(rename = "TTTP")]
    #[cfg_attr(feature = "serde", serde(rename = "TTTP"))]
    Tttp,
    #[yaserde(rename = "MMPP")]
    #[cfg_attr(feature = "serde", serde(rename = "MMPP"))]
    Mmpp,
    __Unknown__(String),
}

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

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

impl Validate for BorrowingReason2Choice {}




#[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:setr.027.001.05")]

pub enum BusinessProcessType1Code {
    #[yaserde(rename = "ISUP")]
    #[cfg_attr(feature = "serde", serde(rename = "ISUP"))]
    Isup,
    #[yaserde(rename = "NISP")]
    #[cfg_attr(feature = "serde", serde(rename = "NISP"))]
    Nisp,
    #[yaserde(rename = "PRAC")]
    #[cfg_attr(feature = "serde", serde(rename = "PRAC"))]
    Prac,
    #[yaserde(rename = "RSAL")]
    #[cfg_attr(feature = "serde", serde(rename = "RSAL"))]
    Rsal,
    #[yaserde(rename = "PROP")]
    #[cfg_attr(feature = "serde", serde(rename = "PROP"))]
    Prop,
    #[yaserde(rename = "THRU")]
    #[cfg_attr(feature = "serde", serde(rename = "THRU"))]
    Thru,
    #[yaserde(rename = "IDEL")]
    #[cfg_attr(feature = "serde", serde(rename = "IDEL"))]
    Idel,
    #[yaserde(rename = "DPLX")]
    #[cfg_attr(feature = "serde", serde(rename = "DPLX"))]
    Dplx,
    __Unknown__(String),
}

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

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

impl Validate for BusinessProcessType2Choice {}




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

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

pub enum CalculationType1Code {
    #[yaserde(rename = "AFTX")]
    #[cfg_attr(feature = "serde", serde(rename = "AFTX"))]
    Aftx,
    #[yaserde(rename = "ANNU")]
    #[cfg_attr(feature = "serde", serde(rename = "ANNU"))]
    Annu,
    #[yaserde(rename = "ISSU")]
    #[cfg_attr(feature = "serde", serde(rename = "ISSU"))]
    Issu,
    #[yaserde(rename = "AVMA")]
    #[cfg_attr(feature = "serde", serde(rename = "AVMA"))]
    Avma,
    #[yaserde(rename = "BOOK")]
    #[cfg_attr(feature = "serde", serde(rename = "BOOK"))]
    Book,
    #[yaserde(rename = "YTNC")]
    #[cfg_attr(feature = "serde", serde(rename = "YTNC"))]
    Ytnc,
    #[yaserde(rename = "CHCL")]
    #[cfg_attr(feature = "serde", serde(rename = "CHCL"))]
    Chcl,
    #[yaserde(rename = "CLOS")]
    #[cfg_attr(feature = "serde", serde(rename = "CLOS"))]
    Clos,
    #[yaserde(rename = "CMPD")]
    #[cfg_attr(feature = "serde", serde(rename = "CMPD"))]
    Cmpd,
    #[yaserde(rename = "CUYI")]
    #[cfg_attr(feature = "serde", serde(rename = "CUYI"))]
    Cuyi,
    #[yaserde(rename = "TRGR")]
    #[cfg_attr(feature = "serde", serde(rename = "TRGR"))]
    Trgr,
    #[yaserde(rename = "GVEQ")]
    #[cfg_attr(feature = "serde", serde(rename = "GVEQ"))]
    Gveq,
    #[yaserde(rename = "FLAS")]
    #[cfg_attr(feature = "serde", serde(rename = "FLAS"))]
    Flas,
    #[yaserde(rename = "NVFL")]
    #[cfg_attr(feature = "serde", serde(rename = "NVFL"))]
    Nvfl,
    #[yaserde(rename = "LSCL")]
    #[cfg_attr(feature = "serde", serde(rename = "LSCL"))]
    Lscl,
    #[yaserde(rename = "LSMT")]
    #[cfg_attr(feature = "serde", serde(rename = "LSMT"))]
    Lsmt,
    #[yaserde(rename = "LSQR")]
    #[cfg_attr(feature = "serde", serde(rename = "LSQR"))]
    Lsqr,
    #[yaserde(rename = "LSYR")]
    #[cfg_attr(feature = "serde", serde(rename = "LSYR"))]
    Lsyr,
    #[yaserde(rename = "LGAL")]
    #[cfg_attr(feature = "serde", serde(rename = "LGAL"))]
    Lgal,
    #[yaserde(rename = "MARK")]
    #[cfg_attr(feature = "serde", serde(rename = "MARK"))]
    Mark,
    #[yaserde(rename = "YTMA")]
    #[cfg_attr(feature = "serde", serde(rename = "YTMA"))]
    Ytma,
    #[yaserde(rename = "NXRF")]
    #[cfg_attr(feature = "serde", serde(rename = "NXRF"))]
    Nxrf,
    #[yaserde(rename = "PNAV")]
    #[cfg_attr(feature = "serde", serde(rename = "PNAV"))]
    Pnav,
    #[yaserde(rename = "NXPT")]
    #[cfg_attr(feature = "serde", serde(rename = "NXPT"))]
    Nxpt,
    #[yaserde(rename = "PRCL")]
    #[cfg_attr(feature = "serde", serde(rename = "PRCL"))]
    Prcl,
    #[yaserde(rename = "PRYL")]
    #[cfg_attr(feature = "serde", serde(rename = "PRYL"))]
    Pryl,
    #[yaserde(rename = "SEMI")]
    #[cfg_attr(feature = "serde", serde(rename = "SEMI"))]
    Semi,
    #[yaserde(rename = "SHLF")]
    #[cfg_attr(feature = "serde", serde(rename = "SHLF"))]
    Shlf,
    #[yaserde(rename = "SPLL")]
    #[cfg_attr(feature = "serde", serde(rename = "SPLL"))]
    Spll,
    #[yaserde(rename = "TXQV")]
    #[cfg_attr(feature = "serde", serde(rename = "TXQV"))]
    Txqv,
    #[yaserde(rename = "TTDT")]
    #[cfg_attr(feature = "serde", serde(rename = "TTDT"))]
    Ttdt,
    #[yaserde(rename = "TRYL")]
    #[cfg_attr(feature = "serde", serde(rename = "TRYL"))]
    Tryl,
    #[yaserde(rename = "WRST")]
    #[cfg_attr(feature = "serde", serde(rename = "WRST"))]
    Wrst,
    __Unknown__(String),
}

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

impl Validate for CalculationType1Code {}



#[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:setr.027.001.05")]

pub enum CallIn1Code {
    #[yaserde(rename = "CFAV")]
    #[cfg_attr(feature = "serde", serde(rename = "CFAV"))]
    Cfav,
    #[yaserde(rename = "CFST")]
    #[cfg_attr(feature = "serde", serde(rename = "CFST"))]
    Cfst,
    #[yaserde(rename = "CFCC")]
    #[cfg_attr(feature = "serde", serde(rename = "CFCC"))]
    Cfcc,
    __Unknown__(String),
}

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

impl Validate for CallIn1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct CashAccountIdentification5Choice {
    #[yaserde(rename = "IBAN")]
    #[cfg_attr(feature = "serde", serde(rename = "IBAN"))]
    pub iban: Option<Iban2007Identifier>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max34Text>,
}

impl Validate for CashAccountIdentification5Choice {}




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

pub enum CashMarginOrder1Code {
    #[yaserde(rename = "CASH")]
    #[cfg_attr(feature = "serde", serde(rename = "CASH"))]
    Cash,
    #[yaserde(rename = "MRGO")]
    #[cfg_attr(feature = "serde", serde(rename = "MRGO"))]
    Mrgo,
    #[yaserde(rename = "MRGC")]
    #[cfg_attr(feature = "serde", serde(rename = "MRGC"))]
    Mrgc,
    __Unknown__(String),
}

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

impl Validate for CashMarginOrder1Code {}



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

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

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

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

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

impl Validate for CashParties33 {}


#[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:setr.027.001.05")]

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

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

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

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

pub enum ChargeTaxBasis1Code {
    #[yaserde(rename = "FLAT")]
    #[cfg_attr(feature = "serde", serde(rename = "FLAT"))]
    Flat,
    #[yaserde(rename = "PERU")]
    #[cfg_attr(feature = "serde", serde(rename = "PERU"))]
    Peru,
    __Unknown__(String),
}

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

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

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

impl Validate for ClassificationType32Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct Clearing5 {
    #[yaserde(rename = "ClrMmb")]
    #[cfg_attr(feature = "serde", serde(rename = "ClrMmb"))]
    pub clr_mmb: Vec<PartyIdentificationAndAccount149>,

    #[yaserde(rename = "ClrSgmt")]
    #[cfg_attr(feature = "serde", serde(rename = "ClrSgmt"))]
    pub clr_sgmt: PartyIdentification127Choice,
}

impl Validate for Clearing5 {}


#[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:setr.027.001.05")]

pub enum ClearingAccountType1Code {
    #[yaserde(rename = "HOUS")]
    #[cfg_attr(feature = "serde", serde(rename = "HOUS"))]
    Hous,
    #[yaserde(rename = "CLIE")]
    #[cfg_attr(feature = "serde", serde(rename = "CLIE"))]
    Clie,
    #[yaserde(rename = "LIPR")]
    #[cfg_attr(feature = "serde", serde(rename = "LIPR"))]
    Lipr,
    __Unknown__(String),
}

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

impl Validate for ClearingAccountType1Code {}



#[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:setr.027.001.05")]

pub enum ClearingSide1Code {
    #[yaserde(rename = "BUYI")]
    #[cfg_attr(feature = "serde", serde(rename = "BUYI"))]
    Buyi,
    #[yaserde(rename = "SELL")]
    #[cfg_attr(feature = "serde", serde(rename = "SELL"))]
    Sell,
    #[yaserde(rename = "LEND")]
    #[cfg_attr(feature = "serde", serde(rename = "LEND"))]
    Lend,
    #[yaserde(rename = "BORW")]
    #[cfg_attr(feature = "serde", serde(rename = "BORW"))]
    Borw,
    __Unknown__(String),
}

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

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

impl Validate for ClosingDate4Choice {}




#[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:setr.027.001.05")]

pub enum ClosingType1Code {
    #[yaserde(rename = "OVER")]
    #[cfg_attr(feature = "serde", serde(rename = "OVER"))]
    Over,
    #[yaserde(rename = "TERM")]
    #[cfg_attr(feature = "serde", serde(rename = "TERM"))]
    Term,
    #[yaserde(rename = "FLEX")]
    #[cfg_attr(feature = "serde", serde(rename = "FLEX"))]
    Flex,
    #[yaserde(rename = "OPEN")]
    #[cfg_attr(feature = "serde", serde(rename = "OPEN"))]
    Open,
    __Unknown__(String),
}

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

impl Validate for ClosingType1Code {}



#[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:setr.027.001.05")]

pub enum CollateralType3Code {
    #[yaserde(rename = "CASH")]
    #[cfg_attr(feature = "serde", serde(rename = "CASH"))]
    Cash,
    #[yaserde(rename = "SECU")]
    #[cfg_attr(feature = "serde", serde(rename = "SECU"))]
    Secu,
    #[yaserde(rename = "PHYS")]
    #[cfg_attr(feature = "serde", serde(rename = "PHYS"))]
    Phys,
    #[yaserde(rename = "INSU")]
    #[cfg_attr(feature = "serde", serde(rename = "INSU"))]
    Insu,
    #[yaserde(rename = "STCF")]
    #[cfg_attr(feature = "serde", serde(rename = "STCF"))]
    Stcf,
    #[yaserde(rename = "BOND")]
    #[cfg_attr(feature = "serde", serde(rename = "BOND"))]
    Bond,
    #[yaserde(rename = "GBBK")]
    #[cfg_attr(feature = "serde", serde(rename = "GBBK"))]
    Gbbk,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    __Unknown__(String),
}

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

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

impl Validate for CollateralType4Choice {}




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

    #[yaserde(rename = "Comssn")]
    #[cfg_attr(feature = "serde", serde(rename = "Comssn"))]
    pub comssn: AmountOrRate2Choice,

    #[yaserde(rename = "RcptId")]
    #[cfg_attr(feature = "serde", serde(rename = "RcptId"))]
    pub rcpt_id: PartyIdentification117,

    #[yaserde(rename = "ClctnDt")]
    #[cfg_attr(feature = "serde", serde(rename = "ClctnDt"))]
    pub clctn_dt: Isodate,

    #[yaserde(rename = "TtlComssn")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlComssn"))]
    pub ttl_comssn: AmountAndDirection29,

    #[yaserde(rename = "TtlVATAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlVATAmt"))]
    pub ttl_vat_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "VATRate")]
    #[cfg_attr(feature = "serde", serde(rename = "VATRate"))]
    pub vat_rate: BaseOneRate,
}

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

impl Validate for CommissionType6Choice {}




#[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:setr.027.001.05")]

pub enum CommissionType9Code {
    #[yaserde(rename = "CLDI")]
    #[cfg_attr(feature = "serde", serde(rename = "CLDI"))]
    Cldi,
    #[yaserde(rename = "STEP")]
    #[cfg_attr(feature = "serde", serde(rename = "STEP"))]
    Step,
    #[yaserde(rename = "SOFT")]
    #[cfg_attr(feature = "serde", serde(rename = "SOFT"))]
    Soft,
    #[yaserde(rename = "PERN")]
    #[cfg_attr(feature = "serde", serde(rename = "PERN"))]
    Pern,
    #[yaserde(rename = "FLAT")]
    #[cfg_attr(feature = "serde", serde(rename = "FLAT"))]
    Flat,
    #[yaserde(rename = "PERU")]
    #[cfg_attr(feature = "serde", serde(rename = "PERU"))]
    Peru,
    #[yaserde(rename = "PWCD")]
    #[cfg_attr(feature = "serde", serde(rename = "PWCD"))]
    Pwcd,
    #[yaserde(rename = "PWEU")]
    #[cfg_attr(feature = "serde", serde(rename = "PWEU"))]
    Pweu,
    #[yaserde(rename = "BRKR")]
    #[cfg_attr(feature = "serde", serde(rename = "BRKR"))]
    Brkr,
    #[yaserde(rename = "DFDP")]
    #[cfg_attr(feature = "serde", serde(rename = "DFDP"))]
    Dfdp,
    #[yaserde(rename = "PBOC")]
    #[cfg_attr(feature = "serde", serde(rename = "PBOC"))]
    Pboc,
    __Unknown__(String),
}

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

impl Validate for CommissionType9Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct ConfirmationParties6 {
    #[yaserde(rename = "Buyr")]
    #[cfg_attr(feature = "serde", serde(rename = "Buyr"))]
    pub buyr: ConfirmationPartyDetails7,

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

    #[yaserde(rename = "Sellr")]
    #[cfg_attr(feature = "serde", serde(rename = "Sellr"))]
    pub sellr: ConfirmationPartyDetails7,

    #[yaserde(rename = "Lndr")]
    #[cfg_attr(feature = "serde", serde(rename = "Lndr"))]
    pub lndr: ConfirmationPartyDetails7,

    #[yaserde(rename = "BrkrOfCdt")]
    #[cfg_attr(feature = "serde", serde(rename = "BrkrOfCdt"))]
    pub brkr_of_cdt: ConfirmationPartyDetails8,

    #[yaserde(rename = "IntrdcgFirm")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrdcgFirm"))]
    pub intrdcg_firm: ConfirmationPartyDetails8,

    #[yaserde(rename = "StepInFirm")]
    #[cfg_attr(feature = "serde", serde(rename = "StepInFirm"))]
    pub step_in_firm: ConfirmationPartyDetails8,

    #[yaserde(rename = "StepOutFirm")]
    #[cfg_attr(feature = "serde", serde(rename = "StepOutFirm"))]
    pub step_out_firm: ConfirmationPartyDetails8,

    #[yaserde(rename = "ClrFirm")]
    #[cfg_attr(feature = "serde", serde(rename = "ClrFirm"))]
    pub clr_firm: ConfirmationPartyDetails9,

    #[yaserde(rename = "ExctgBrkr")]
    #[cfg_attr(feature = "serde", serde(rename = "ExctgBrkr"))]
    pub exctg_brkr: ConfirmationPartyDetails9,

    #[yaserde(rename = "CMUPty")]
    #[cfg_attr(feature = "serde", serde(rename = "CMUPty"))]
    pub cmu_pty: ConfirmationPartyDetails8,

    #[yaserde(rename = "CMUCtrPty")]
    #[cfg_attr(feature = "serde", serde(rename = "CMUCtrPty"))]
    pub cmu_ctr_pty: ConfirmationPartyDetails8,

    #[yaserde(rename = "AffrmgPty")]
    #[cfg_attr(feature = "serde", serde(rename = "AffrmgPty"))]
    pub affrmg_pty: ConfirmationPartyDetails8,

    #[yaserde(rename = "TradBnfcryPty")]
    #[cfg_attr(feature = "serde", serde(rename = "TradBnfcryPty"))]
    pub trad_bnfcry_pty: ConfirmationPartyDetails10,
}

impl Validate for ConfirmationParties6 {}


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

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

    #[yaserde(rename = "CshDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "CshDtls"))]
    pub csh_dtls: AccountIdentification55Choice,

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

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

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

    #[yaserde(rename = "PtyCpcty")]
    #[cfg_attr(feature = "serde", serde(rename = "PtyCpcty"))]
    pub pty_cpcty: TradingPartyCapacity3Choice,
}

impl Validate for ConfirmationPartyDetails10 {}


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

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

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

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

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

    #[yaserde(rename = "TradgPtyCpcty")]
    #[cfg_attr(feature = "serde", serde(rename = "TradgPtyCpcty"))]
    pub tradg_pty_cpcty: TradingPartyCapacity4Choice,
}

impl Validate for ConfirmationPartyDetails7 {}


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

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

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

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

impl Validate for ConfirmationPartyDetails8 {}


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

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

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

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

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

impl Validate for ConfirmationPartyDetails9 {}


#[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:setr.027.001.05")]

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

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

impl Validate for CreditDebitCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct CurrencyToBuyOrSell1Choice {
    #[yaserde(rename = "CcyToBuy")]
    #[cfg_attr(feature = "serde", serde(rename = "CcyToBuy"))]
    pub ccy_to_buy: Option<ActiveCurrencyCode>,
    #[yaserde(rename = "CcyToSell")]
    #[cfg_attr(feature = "serde", serde(rename = "CcyToSell"))]
    pub ccy_to_sell: Option<ActiveCurrencyCode>,
}

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

impl Validate for Date3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct DateAndDateTime1Choice {
    #[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 DateAndDateTime1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct DateAndDateTime2Choice {
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Option<Isodate>,
    #[yaserde(rename = "DtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "DtTm"))]
    pub dt_tm: Option<IsodateTime>,
}

impl Validate for DateAndDateTime2Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct DateTimePeriod1 {
    #[yaserde(rename = "FrDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "FrDtTm"))]
    pub fr_dt_tm: IsodateTime,

    #[yaserde(rename = "ToDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "ToDtTm"))]
    pub to_dt_tm: IsodateTime,
}

impl Validate for DateTimePeriod1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct DateTimePeriod1Choice {
    #[yaserde(rename = "FrDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "FrDtTm"))]
    pub fr_dt_tm: Option<IsodateTime>,
    #[yaserde(rename = "ToDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "ToDtTm"))]
    pub to_dt_tm: Option<IsodateTime>,
    #[yaserde(rename = "DtTmRg")]
    #[cfg_attr(feature = "serde", serde(rename = "DtTmRg"))]
    pub dt_tm_rg: Option<DateTimePeriod1>,
}

impl Validate for DateTimePeriod1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct DateTimePeriod2 {
    #[yaserde(rename = "FrDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "FrDtTm"))]
    pub fr_dt_tm: IsodateTime,

    #[yaserde(rename = "ToDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "ToDtTm"))]
    pub to_dt_tm: IsodateTime,
}

impl Validate for DateTimePeriod2 {}


#[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:setr.027.001.05")]

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

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

impl Validate for DateType2Code {}



#[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:setr.027.001.05")]

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

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

impl Validate for DateType3Code {}



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

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

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

pub enum DeliveryType2Code {
    #[yaserde(rename = "APMT")]
    #[cfg_attr(feature = "serde", serde(rename = "APMT"))]
    Apmt,
    #[yaserde(rename = "FREE")]
    #[cfg_attr(feature = "serde", serde(rename = "FREE"))]
    Free,
    #[yaserde(rename = "TRIP")]
    #[cfg_attr(feature = "serde", serde(rename = "TRIP"))]
    Trip,
    #[yaserde(rename = "HOIC")]
    #[cfg_attr(feature = "serde", serde(rename = "HOIC"))]
    Hoic,
    __Unknown__(String),
}

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

impl Validate for DeliveryType2Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct Document {
    #[yaserde(rename = "SctiesTradConf")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesTradConf"))]
    pub scties_trad_conf: SecuritiesTradeConfirmationV05,
}

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

impl Validate for DocumentNumber17Choice {}




#[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:setr.027.001.05")]

pub enum EucapitalGain2Code {
    #[yaserde(rename = "EUSI")]
    #[cfg_attr(feature = "serde", serde(rename = "EUSI"))]
    Eusi,
    #[yaserde(rename = "EUSO")]
    #[cfg_attr(feature = "serde", serde(rename = "EUSO"))]
    Euso,
    #[yaserde(rename = "UKWN")]
    #[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
    Ukwn,
    __Unknown__(String),
}

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

impl Validate for EucapitalGain2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct EucapitalGainType3Choice {
    #[yaserde(rename = "EUCptlGn")]
    #[cfg_attr(feature = "serde", serde(rename = "EUCptlGn"))]
    pub eucptl_gn: Option<EucapitalGain2Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification30>,
}

impl Validate for EucapitalGainType3Choice {}




#[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:setr.027.001.05")]

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

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

impl Validate for Eligibility1Code {}



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

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

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

impl Validate for EventFrequency3Code {}



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

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

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

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

impl Validate for ExposureType18Choice {}




#[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:setr.027.001.05")]

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

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

impl Validate for ExposureType3Code {}



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

impl Validate for ExternalTradeTransactionCondition1Code {
    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:setr.027.001.05")]
pub struct FxstandingInstruction4Choice {
    #[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 FxstandingInstruction4Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct FinancialInstrumentAttributes124 {
    #[yaserde(rename = "PlcOfListg")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcOfListg"))]
    pub plc_of_listg: MarketIdentification3Choice,

    #[yaserde(rename = "Ratg")]
    #[cfg_attr(feature = "serde", serde(rename = "Ratg"))]
    pub ratg: Rating1,

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

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

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

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

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

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

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

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

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

    #[yaserde(rename = "CpnDt")]
    #[cfg_attr(feature = "serde", serde(rename = "CpnDt"))]
    pub cpn_dt: Isodate,

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

    #[yaserde(rename = "FltgRateFxgDt")]
    #[cfg_attr(feature = "serde", serde(rename = "FltgRateFxgDt"))]
    pub fltg_rate_fxg_dt: Isodate,

    #[yaserde(rename = "MtrtyDt")]
    #[cfg_attr(feature = "serde", serde(rename = "MtrtyDt"))]
    pub mtrty_dt: Isodate,

    #[yaserde(rename = "IsseDt")]
    #[cfg_attr(feature = "serde", serde(rename = "IsseDt"))]
    pub isse_dt: Isodate,

    #[yaserde(rename = "NxtCllblDt")]
    #[cfg_attr(feature = "serde", serde(rename = "NxtCllblDt"))]
    pub nxt_cllbl_dt: Isodate,

    #[yaserde(rename = "ConvsDt")]
    #[cfg_attr(feature = "serde", serde(rename = "ConvsDt"))]
    pub convs_dt: Isodate,

    #[yaserde(rename = "PutblDt")]
    #[cfg_attr(feature = "serde", serde(rename = "PutblDt"))]
    pub putbl_dt: Isodate,

    #[yaserde(rename = "DtdDt")]
    #[cfg_attr(feature = "serde", serde(rename = "DtdDt"))]
    pub dtd_dt: Isodate,

    #[yaserde(rename = "FrstPmtDt")]
    #[cfg_attr(feature = "serde", serde(rename = "FrstPmtDt"))]
    pub frst_pmt_dt: Isodate,

    #[yaserde(rename = "NxtFctrDt")]
    #[cfg_attr(feature = "serde", serde(rename = "NxtFctrDt"))]
    pub nxt_fctr_dt: Isodate,

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

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

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

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

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

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

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

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

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

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

    #[yaserde(rename = "VrsnNb")]
    #[cfg_attr(feature = "serde", serde(rename = "VrsnNb"))]
    pub vrsn_nb: Number1Choice,

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

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

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

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

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

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

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

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

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

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

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

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

    #[yaserde(rename = "TaxblIncmPerShr")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxblIncmPerShr"))]
    pub taxbl_incm_per_shr: Price14,

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

    #[yaserde(rename = "MinExrcblQty")]
    #[cfg_attr(feature = "serde", serde(rename = "MinExrcblQty"))]
    pub min_exrcbl_qty: FinancialInstrumentQuantity1Choice,

    #[yaserde(rename = "MinExrcblMltplQty")]
    #[cfg_attr(feature = "serde", serde(rename = "MinExrcblMltplQty"))]
    pub min_exrcbl_mltpl_qty: FinancialInstrumentQuantity1Choice,

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

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

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

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

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

impl Validate for FinancialInstrumentQuantity1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct FinancialInstrumentStipulations4 {
    #[yaserde(rename = "Geogcs")]
    #[cfg_attr(feature = "serde", serde(rename = "Geogcs"))]
    pub geogcs: Max35Text,

    #[yaserde(rename = "YldRg")]
    #[cfg_attr(feature = "serde", serde(rename = "YldRg"))]
    pub yld_rg: AmountOrPercentageRange1,

    #[yaserde(rename = "Ratg")]
    #[cfg_attr(feature = "serde", serde(rename = "Ratg"))]
    pub ratg: Rating1,

    #[yaserde(rename = "CpnRg")]
    #[cfg_attr(feature = "serde", serde(rename = "CpnRg"))]
    pub cpn_rg: AmountOrPercentageRange1,

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

    #[yaserde(rename = "Purp")]
    #[cfg_attr(feature = "serde", serde(rename = "Purp"))]
    pub purp: Max256Text,

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

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

    #[yaserde(rename = "TxConds")]
    #[cfg_attr(feature = "serde", serde(rename = "TxConds"))]
    pub tx_conds: TradeTransactionCondition2Code,

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

    #[yaserde(rename = "CstmDt")]
    #[cfg_attr(feature = "serde", serde(rename = "CstmDt"))]
    pub cstm_dt: DateTimePeriod2,

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

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

    #[yaserde(rename = "LookBck")]
    #[cfg_attr(feature = "serde", serde(rename = "LookBck"))]
    pub look_bck: Number,

    #[yaserde(rename = "MtrtyDt")]
    #[cfg_attr(feature = "serde", serde(rename = "MtrtyDt"))]
    pub mtrty_dt: IsoyearMonth,

    #[yaserde(rename = "IsseDt")]
    #[cfg_attr(feature = "serde", serde(rename = "IsseDt"))]
    pub isse_dt: IsoyearMonth,

    #[yaserde(rename = "IssrId")]
    #[cfg_attr(feature = "serde", serde(rename = "IssrId"))]
    pub issr_id: BicnonFIDec2014Identifier,

    #[yaserde(rename = "IsseSz")]
    #[cfg_attr(feature = "serde", serde(rename = "IsseSz"))]
    pub isse_sz: Number,

    #[yaserde(rename = "MinDnmtn")]
    #[cfg_attr(feature = "serde", serde(rename = "MinDnmtn"))]
    pub min_dnmtn: FinancialInstrumentQuantity1Choice,

    #[yaserde(rename = "MaxSbstitn")]
    #[cfg_attr(feature = "serde", serde(rename = "MaxSbstitn"))]
    pub max_sbstitn: Number,

    #[yaserde(rename = "MinIncrmt")]
    #[cfg_attr(feature = "serde", serde(rename = "MinIncrmt"))]
    pub min_incrmt: FinancialInstrumentQuantity1Choice,

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

    #[yaserde(rename = "MinQty")]
    #[cfg_attr(feature = "serde", serde(rename = "MinQty"))]
    pub min_qty: FinancialInstrumentQuantity1Choice,

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

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

    #[yaserde(rename = "PricFrqcy")]
    #[cfg_attr(feature = "serde", serde(rename = "PricFrqcy"))]
    pub pric_frqcy: Frequency1Code,

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

    #[yaserde(rename = "SbstitnFrqcy")]
    #[cfg_attr(feature = "serde", serde(rename = "SbstitnFrqcy"))]
    pub sbstitn_frqcy: Frequency1Code,

    #[yaserde(rename = "SbstitnLft")]
    #[cfg_attr(feature = "serde", serde(rename = "SbstitnLft"))]
    pub sbstitn_lft: Number,

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

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

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

    #[yaserde(rename = "OverAlltmtAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "OverAlltmtAmt"))]
    pub over_alltmt_amt: ActiveCurrencyAndAmount,

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

    #[yaserde(rename = "PricRg")]
    #[cfg_attr(feature = "serde", serde(rename = "PricRg"))]
    pub pric_rg: AmountOrPercentageRange1,

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

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

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

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

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

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

impl Validate for FinancialInstrumentStipulations4 {}


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

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

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

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

impl Validate for ForeignExchangeTerms18 {}


#[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:setr.027.001.05")]

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

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

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

impl Validate for FormOfSecurity6Choice {}




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

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

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

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

impl Validate for Frequency23Choice {}




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

pub enum FutureAndOptionContractType1Code {
    #[yaserde(rename = "ORDY")]
    #[cfg_attr(feature = "serde", serde(rename = "ORDY"))]
    Ordy,
    #[yaserde(rename = "INDX")]
    #[cfg_attr(feature = "serde", serde(rename = "INDX"))]
    Indx,
    #[yaserde(rename = "EXFU")]
    #[cfg_attr(feature = "serde", serde(rename = "EXFU"))]
    Exfu,
    __Unknown__(String),
}

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

impl Validate for FutureAndOptionContractType1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct FutureOrOptionDetails3 {
    #[yaserde(rename = "FutrAndOptnCtrctTp")]
    #[cfg_attr(feature = "serde", serde(rename = "FutrAndOptnCtrctTp"))]
    pub futr_and_optn_ctrct_tp: FutureAndOptionContractType1Code,

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

    #[yaserde(rename = "UnitOfMeasr")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitOfMeasr"))]
    pub unit_of_measr: UnitOfMeasure1Code,

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

    #[yaserde(rename = "MinSz")]
    #[cfg_attr(feature = "serde", serde(rename = "MinSz"))]
    pub min_sz: ActiveCurrencyAndAmount,

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

    #[yaserde(rename = "Apprnc")]
    #[cfg_attr(feature = "serde", serde(rename = "Apprnc"))]
    pub apprnc: Appearance1Code,

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

    #[yaserde(rename = "PosLmt")]
    #[cfg_attr(feature = "serde", serde(rename = "PosLmt"))]
    pub pos_lmt: Number,

    #[yaserde(rename = "NearTermPosLmt")]
    #[cfg_attr(feature = "serde", serde(rename = "NearTermPosLmt"))]
    pub near_term_pos_lmt: Number,

    #[yaserde(rename = "MinTradgPricgIncrmt")]
    #[cfg_attr(feature = "serde", serde(rename = "MinTradgPricgIncrmt"))]
    pub min_tradg_pricg_incrmt: Number,

    #[yaserde(rename = "Purp")]
    #[cfg_attr(feature = "serde", serde(rename = "Purp"))]
    pub purp: Max256Text,

    #[yaserde(rename = "CtrctSttlmMnth")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrctSttlmMnth"))]
    pub ctrct_sttlm_mnth: IsoyearMonth,

    #[yaserde(rename = "FrstDealgDt")]
    #[cfg_attr(feature = "serde", serde(rename = "FrstDealgDt"))]
    pub frst_dealg_dt: DateAndDateTime1Choice,

    #[yaserde(rename = "Ratio")]
    #[cfg_attr(feature = "serde", serde(rename = "Ratio"))]
    pub ratio: Vec<UnderlyingRatio2>,

    #[yaserde(rename = "Ratg")]
    #[cfg_attr(feature = "serde", serde(rename = "Ratg"))]
    pub ratg: Vec<Rating1>,

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

    #[yaserde(rename = "OptnRghts")]
    #[cfg_attr(feature = "serde", serde(rename = "OptnRghts"))]
    pub optn_rghts: OptionRight2Choice,

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

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

impl Validate for FutureOrOptionDetails3 {}


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

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

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

impl Validate for GenericIdentification1 {}


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

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

impl Validate for GenericIdentification37 {}


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

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

impl Validate for GenericIdentification7 {}


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

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

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

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

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

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

impl Validate for IsoyearMonth {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct IdentificationReference15Choice {
    #[yaserde(rename = "InstgPtyTxId")]
    #[cfg_attr(feature = "serde", serde(rename = "InstgPtyTxId"))]
    pub instg_pty_tx_id: Option<Max35Text>,
    #[yaserde(rename = "ExctgPtyTxId")]
    #[cfg_attr(feature = "serde", serde(rename = "ExctgPtyTxId"))]
    pub exctg_pty_tx_id: Option<Max35Text>,
    #[yaserde(rename = "MktInfrstrctrTxId")]
    #[cfg_attr(feature = "serde", serde(rename = "MktInfrstrctrTxId"))]
    pub mkt_infrstrctr_tx_id: Option<Max35Text>,
    #[yaserde(rename = "ClntOrdrLkId")]
    #[cfg_attr(feature = "serde", serde(rename = "ClntOrdrLkId"))]
    pub clnt_ordr_lk_id: Option<Max35Text>,
    #[yaserde(rename = "PoolId")]
    #[cfg_attr(feature = "serde", serde(rename = "PoolId"))]
    pub pool_id: Option<Max35Text>,
    #[yaserde(rename = "BlckId")]
    #[cfg_attr(feature = "serde", serde(rename = "BlckId"))]
    pub blck_id: Option<Max35Text>,
    #[yaserde(rename = "AllcnId")]
    #[cfg_attr(feature = "serde", serde(rename = "AllcnId"))]
    pub allcn_id: Option<Max35Text>,
    #[yaserde(rename = "IndvAllcnId")]
    #[cfg_attr(feature = "serde", serde(rename = "IndvAllcnId"))]
    pub indv_allcn_id: Option<Max35Text>,
    #[yaserde(rename = "ScndryAllcnId")]
    #[cfg_attr(feature = "serde", serde(rename = "ScndryAllcnId"))]
    pub scndry_allcn_id: Option<Max35Text>,
    #[yaserde(rename = "IndxId")]
    #[cfg_attr(feature = "serde", serde(rename = "IndxId"))]
    pub indx_id: Option<Max35Text>,
    #[yaserde(rename = "CmonId")]
    #[cfg_attr(feature = "serde", serde(rename = "CmonId"))]
    pub cmon_id: Option<Max35Text>,
    #[yaserde(rename = "CmplcId")]
    #[cfg_attr(feature = "serde", serde(rename = "CmplcId"))]
    pub cmplc_id: Option<Max35Text>,
    #[yaserde(rename = "CollTxId")]
    #[cfg_attr(feature = "serde", serde(rename = "CollTxId"))]
    pub coll_tx_id: Option<Max35Text>,
    #[yaserde(rename = "UnqTxIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "UnqTxIdr"))]
    pub unq_tx_idr: Option<Utiidentifier>,
}

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

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

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

impl Validate for IdentificationType43Choice {}




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

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

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

pub enum InterestComputationMethod1Code {
    A001,
    A002,
    A003,
    A004,
    A005,
    A006,
    A007,
    A008,
    A009,
    A010,
    A011,
    A012,
    A013,
    A014,
    __Unknown__(String),
}

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

impl Validate for InterestComputationMethod1Code {}



#[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:setr.027.001.05")]

pub enum InterestComputationMethod2Code {
    A001,
    A002,
    A003,
    A004,
    A005,
    A006,
    A007,
    A008,
    A009,
    A010,
    A011,
    A012,
    A013,
    A014,
    #[yaserde(rename = "NARR")]
    #[cfg_attr(feature = "serde", serde(rename = "NARR"))]
    Narr,
    __Unknown__(String),
}

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

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

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

impl Validate for InterestComputationMethodFormat4Choice {}




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

pub enum InterestType2Code {
    #[yaserde(rename = "CINT")]
    #[cfg_attr(feature = "serde", serde(rename = "CINT"))]
    Cint,
    #[yaserde(rename = "XINT")]
    #[cfg_attr(feature = "serde", serde(rename = "XINT"))]
    Xint,
    __Unknown__(String),
}

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

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

impl Validate for InvestorCapacity4Choice {}




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

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

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

impl Validate for LegalFramework1Code {}



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

pub enum LendingTransactionMethod1Code {
    #[yaserde(rename = "ODTR")]
    #[cfg_attr(feature = "serde", serde(rename = "ODTR"))]
    Odtr,
    #[yaserde(rename = "EXTR")]
    #[cfg_attr(feature = "serde", serde(rename = "EXTR"))]
    Extr,
    __Unknown__(String),
}

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

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

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

impl Validate for LetterOfGuarantee4Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct Linkages76 {
    #[yaserde(rename = "MsgNb")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgNb"))]
    pub msg_nb: DocumentNumber17Choice,

    #[yaserde(rename = "Ref")]
    #[cfg_attr(feature = "serde", serde(rename = "Ref"))]
    pub _ref: IdentificationReference15Choice,
}

impl Validate for Linkages76 {}


#[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:setr.027.001.05")]

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:setr.027.001.05")]
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:setr.027.001.05")]
pub struct MarketIdentification3Choice {
    #[yaserde(rename = "MktIdrCd")]
    #[cfg_attr(feature = "serde", serde(rename = "MktIdrCd"))]
    pub mkt_idr_cd: Option<Micidentifier>,
    #[yaserde(rename = "Desc")]
    #[cfg_attr(feature = "serde", serde(rename = "Desc"))]
    pub desc: Option<Max35Text>,
}

impl Validate for MarketIdentification3Choice {}




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

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

impl Validate for MarketIdentification93 {}


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

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

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

impl Validate for MarketType18Choice {}




#[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:setr.027.001.05")]

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

pub enum MarketType6Code {
    #[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 MarketType6Code {
    fn default() -> MarketType6Code {
        Self::__Unknown__("No valid variants".into())
    }
}

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

pub enum MatchingStatus1Code {
    #[yaserde(rename = "MACH")]
    #[cfg_attr(feature = "serde", serde(rename = "MACH"))]
    Mach,
    #[yaserde(rename = "NMAT")]
    #[cfg_attr(feature = "serde", serde(rename = "NMAT"))]
    Nmat,
    __Unknown__(String),
}

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

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

impl Validate for MatchingStatus27Choice {}




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

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

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

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

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

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

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

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

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

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

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

impl Validate for Max4NumericText {}
#[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)]
pub struct Max8Text (pub String);
crate::simple_type!(Max8Text);

impl Validate for Max8Text {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 8 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 8 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct ModificationCancellationAllowed4Choice {
    #[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 ModificationCancellationAllowed4Choice {}




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

impl Validate for NameAndAddress13 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
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:setr.027.001.05")]
pub struct NettingEligibility4Choice {
    #[yaserde(rename = "Ind")]
    #[cfg_attr(feature = "serde", serde(rename = "Ind"))]
    pub ind: Option<YesNoIndicator>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification30>,
}

impl Validate for NettingEligibility4Choice {}




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

impl Validate for Number {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct Number1Choice {
    #[yaserde(rename = "NbId")]
    #[cfg_attr(feature = "serde", serde(rename = "NbId"))]
    pub nb_id: Option<Max3NumericText>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification7>,
}

impl Validate for Number1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct Number24Choice {
    #[yaserde(rename = "NbId")]
    #[cfg_attr(feature = "serde", serde(rename = "NbId"))]
    pub nb_id: Option<Max4NumericText>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification36>,
}

impl Validate for Number24Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct NumberCount1Choice {
    #[yaserde(rename = "CurInstrNb")]
    #[cfg_attr(feature = "serde", serde(rename = "CurInstrNb"))]
    pub cur_instr_nb: Option<Exact3NumericText>,
    #[yaserde(rename = "TtlNb")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlNb"))]
    pub ttl_nb: Option<TotalNumber1>,
}

impl Validate for NumberCount1Choice {}




#[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:setr.027.001.05")]

pub enum Operation1Code {
    #[yaserde(rename = "TILL")]
    #[cfg_attr(feature = "serde", serde(rename = "TILL"))]
    Till,
    #[yaserde(rename = "ORRR")]
    #[cfg_attr(feature = "serde", serde(rename = "ORRR"))]
    Orrr,
    #[yaserde(rename = "ANDD")]
    #[cfg_attr(feature = "serde", serde(rename = "ANDD"))]
    Andd,
    __Unknown__(String),
}

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

impl Validate for Operation1Code {}



#[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:setr.027.001.05")]

pub enum Operator1Code {
    #[yaserde(rename = "SMAL")]
    #[cfg_attr(feature = "serde", serde(rename = "SMAL"))]
    Smal,
    #[yaserde(rename = "SMEQ")]
    #[cfg_attr(feature = "serde", serde(rename = "SMEQ"))]
    Smeq,
    #[yaserde(rename = "GREA")]
    #[cfg_attr(feature = "serde", serde(rename = "GREA"))]
    Grea,
    #[yaserde(rename = "GREQ")]
    #[cfg_attr(feature = "serde", serde(rename = "GREQ"))]
    Greq,
    #[yaserde(rename = "EQAL")]
    #[cfg_attr(feature = "serde", serde(rename = "EQAL"))]
    Eqal,
    __Unknown__(String),
}

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

impl Validate for Operator1Code {}



#[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:setr.027.001.05")]

pub enum OptionRight1Code {
    #[yaserde(rename = "EXER")]
    #[cfg_attr(feature = "serde", serde(rename = "EXER"))]
    Exer,
    #[yaserde(rename = "ASGN")]
    #[cfg_attr(feature = "serde", serde(rename = "ASGN"))]
    Asgn,
    #[yaserde(rename = "RENO")]
    #[cfg_attr(feature = "serde", serde(rename = "RENO"))]
    Reno,
    #[yaserde(rename = "EXPI")]
    #[cfg_attr(feature = "serde", serde(rename = "EXPI"))]
    Expi,
    __Unknown__(String),
}

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

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

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

impl Validate for OptionStyle10Choice {}




#[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:setr.027.001.05")]

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

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

impl Validate for OptionStyle4Code {}



#[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:setr.027.001.05")]

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

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

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

impl Validate for OptionType6Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct Order24 {
    #[yaserde(rename = "BizPrcTp")]
    #[cfg_attr(feature = "serde", serde(rename = "BizPrcTp"))]
    pub biz_prc_tp: BusinessProcessType2Choice,

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

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

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

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

    #[yaserde(rename = "Sd")]
    #[cfg_attr(feature = "serde", serde(rename = "Sd"))]
    pub sd: Side3Code,

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

    #[yaserde(rename = "TradTxTp")]
    #[cfg_attr(feature = "serde", serde(rename = "TradTxTp"))]
    pub trad_tx_tp: TradeType4Choice,

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

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

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

    #[yaserde(rename = "OrdrBookgDt")]
    #[cfg_attr(feature = "serde", serde(rename = "OrdrBookgDt"))]
    pub ordr_bookg_dt: Isodate,

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

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

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

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

    #[yaserde(rename = "NAVDt")]
    #[cfg_attr(feature = "serde", serde(rename = "NAVDt"))]
    pub nav_dt: DateAndDateTime1Choice,

    #[yaserde(rename = "PrtlFillDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtlFillDtls"))]
    pub prtl_fill_dtls: Vec<PartialFill4>,

    #[yaserde(rename = "ConfQty")]
    #[cfg_attr(feature = "serde", serde(rename = "ConfQty"))]
    pub conf_qty: Quantity6Choice,

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

    #[yaserde(rename = "GrssTradAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "GrssTradAmt"))]
    pub grss_trad_amt: AmountAndDirection29,

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

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

    #[yaserde(rename = "CshMrgn")]
    #[cfg_attr(feature = "serde", serde(rename = "CshMrgn"))]
    pub csh_mrgn: CashMarginOrder1Code,

    #[yaserde(rename = "Comssn")]
    #[cfg_attr(feature = "serde", serde(rename = "Comssn"))]
    pub comssn: Commission24,

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

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

    #[yaserde(rename = "IntrstTp")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstTp"))]
    pub intrst_tp: InterestType2Code,

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

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

    #[yaserde(rename = "TradRgltryCondsTp")]
    #[cfg_attr(feature = "serde", serde(rename = "TradRgltryCondsTp"))]
    pub trad_rgltry_conds_tp: TradeRegulatoryConditions1Code,

    #[yaserde(rename = "CcyToBuyOrSell")]
    #[cfg_attr(feature = "serde", serde(rename = "CcyToBuyOrSell"))]
    pub ccy_to_buy_or_sell: CurrencyToBuyOrSell1Choice,

    #[yaserde(rename = "OrdrOrgtrElgblty")]
    #[cfg_attr(feature = "serde", serde(rename = "OrdrOrgtrElgblty"))]
    pub ordr_orgtr_elgblty: Eligibility1Code,

    #[yaserde(rename = "PosFct")]
    #[cfg_attr(feature = "serde", serde(rename = "PosFct"))]
    pub pos_fct: PositionEffect2Code,

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

    #[yaserde(rename = "ChrgTaxBsisTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ChrgTaxBsisTp"))]
    pub chrg_tax_bsis_tp: ChargeTaxBasisType2Choice,

    #[yaserde(rename = "CptlGnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CptlGnTp"))]
    pub cptl_gn_tp: EucapitalGainType3Choice,

    #[yaserde(rename = "MtchSts")]
    #[cfg_attr(feature = "serde", serde(rename = "MtchSts"))]
    pub mtch_sts: MatchingStatus27Choice,

    #[yaserde(rename = "CallInTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CallInTp"))]
    pub call_in_tp: CallIn1Code,

    #[yaserde(rename = "YldTp")]
    #[cfg_attr(feature = "serde", serde(rename = "YldTp"))]
    pub yld_tp: YieldCalculation7,

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

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

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

impl Validate for Order24 {}


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    #[yaserde(rename = "MtchgConfFee")]
    #[cfg_attr(feature = "serde", serde(rename = "MtchgConfFee"))]
    pub mtchg_conf_fee: AmountAndDirection29,

    #[yaserde(rename = "ConvtdAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "ConvtdAmt"))]
    pub convtd_amt: AmountAndDirection29,

    #[yaserde(rename = "OrgnlCcyAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlCcyAmt"))]
    pub orgnl_ccy_amt: AmountAndDirection29,

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

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

    #[yaserde(rename = "LclTaxCtrySpcfc1")]
    #[cfg_attr(feature = "serde", serde(rename = "LclTaxCtrySpcfc1"))]
    pub lcl_tax_ctry_spcfc_1: AmountAndDirection29,

    #[yaserde(rename = "LclTaxCtrySpcfc2")]
    #[cfg_attr(feature = "serde", serde(rename = "LclTaxCtrySpcfc2"))]
    pub lcl_tax_ctry_spcfc_2: AmountAndDirection29,

    #[yaserde(rename = "LclTaxCtrySpcfc3")]
    #[cfg_attr(feature = "serde", serde(rename = "LclTaxCtrySpcfc3"))]
    pub lcl_tax_ctry_spcfc_3: AmountAndDirection29,

    #[yaserde(rename = "LclTaxCtrySpcfc4")]
    #[cfg_attr(feature = "serde", serde(rename = "LclTaxCtrySpcfc4"))]
    pub lcl_tax_ctry_spcfc_4: AmountAndDirection29,

    #[yaserde(rename = "ShrdBrkrgAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "ShrdBrkrgAmt"))]
    pub shrd_brkrg_amt: AmountAndDirection29,

    #[yaserde(rename = "MktMmbFeeAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "MktMmbFeeAmt"))]
    pub mkt_mmb_fee_amt: AmountAndDirection29,

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

    #[yaserde(rename = "RmnrtnAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "RmnrtnAmt"))]
    pub rmnrtn_amt: AmountAndDirection29,

    #[yaserde(rename = "BrrwgIntrstAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "BrrwgIntrstAmt"))]
    pub brrwg_intrst_amt: AmountAndDirection29,

    #[yaserde(rename = "BrrwgFee")]
    #[cfg_attr(feature = "serde", serde(rename = "BrrwgFee"))]
    pub brrwg_fee: AmountAndDirection29,

    #[yaserde(rename = "NetMktVal")]
    #[cfg_attr(feature = "serde", serde(rename = "NetMktVal"))]
    pub net_mkt_val: AmountAndDirection29,

    #[yaserde(rename = "RmngFaceVal")]
    #[cfg_attr(feature = "serde", serde(rename = "RmngFaceVal"))]
    pub rmng_face_val: AmountAndDirection29,

    #[yaserde(rename = "RmngBookVal")]
    #[cfg_attr(feature = "serde", serde(rename = "RmngBookVal"))]
    pub rmng_book_val: AmountAndDirection29,

    #[yaserde(rename = "ClrBrkrComssn")]
    #[cfg_attr(feature = "serde", serde(rename = "ClrBrkrComssn"))]
    pub clr_brkr_comssn: AmountAndDirection29,

    #[yaserde(rename = "DiffInPric")]
    #[cfg_attr(feature = "serde", serde(rename = "DiffInPric"))]
    pub diff_in_pric: AmountAndDirection29,

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

impl Validate for OtherAmounts16 {}


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

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

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

impl Validate for OtherIdentification1 {}


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

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

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

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

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

impl Validate for OtherParties32 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct OtherPrices5 {
    #[yaserde(rename = "Max")]
    #[cfg_attr(feature = "serde", serde(rename = "Max"))]
    pub max: Price14,

    #[yaserde(rename = "Tx")]
    #[cfg_attr(feature = "serde", serde(rename = "Tx"))]
    pub tx: Price14,

    #[yaserde(rename = "MktBrkrComssn")]
    #[cfg_attr(feature = "serde", serde(rename = "MktBrkrComssn"))]
    pub mkt_brkr_comssn: Price14,

    #[yaserde(rename = "MrkdUp")]
    #[cfg_attr(feature = "serde", serde(rename = "MrkdUp"))]
    pub mrkd_up: Price14,

    #[yaserde(rename = "MrkdDwn")]
    #[cfg_attr(feature = "serde", serde(rename = "MrkdDwn"))]
    pub mrkd_dwn: Price14,

    #[yaserde(rename = "NetDscld")]
    #[cfg_attr(feature = "serde", serde(rename = "NetDscld"))]
    pub net_dscld: Price14,

    #[yaserde(rename = "NetUdscld")]
    #[cfg_attr(feature = "serde", serde(rename = "NetUdscld"))]
    pub net_udscld: Price14,

    #[yaserde(rename = "NtnlGrss")]
    #[cfg_attr(feature = "serde", serde(rename = "NtnlGrss"))]
    pub ntnl_grss: Price14,

    #[yaserde(rename = "BchmkWghtdAvrg")]
    #[cfg_attr(feature = "serde", serde(rename = "BchmkWghtdAvrg"))]
    pub bchmk_wghtd_avrg: Price14,

    #[yaserde(rename = "AllMktsWghtdAvrg")]
    #[cfg_attr(feature = "serde", serde(rename = "AllMktsWghtdAvrg"))]
    pub all_mkts_wghtd_avrg: Price14,

    #[yaserde(rename = "Bchmk")]
    #[cfg_attr(feature = "serde", serde(rename = "Bchmk"))]
    pub bchmk: Price14,

    #[yaserde(rename = "OthrPric")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrPric"))]
    pub othr_pric: Price14,

    #[yaserde(rename = "IndxPric")]
    #[cfg_attr(feature = "serde", serde(rename = "IndxPric"))]
    pub indx_pric: Price14,

    #[yaserde(rename = "RptdPric")]
    #[cfg_attr(feature = "serde", serde(rename = "RptdPric"))]
    pub rptd_pric: Price14,

    #[yaserde(rename = "RefPric")]
    #[cfg_attr(feature = "serde", serde(rename = "RefPric"))]
    pub ref_pric: PriceInformation28,
}

impl Validate for OtherPrices5 {}


#[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:setr.027.001.05")]

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:setr.027.001.05")]
pub struct PartialFill4 {
    #[yaserde(rename = "ConfQty")]
    #[cfg_attr(feature = "serde", serde(rename = "ConfQty"))]
    pub conf_qty: Quantity6Choice,

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

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

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

    #[yaserde(rename = "OrgnlOrdrdQty")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlOrdrdQty"))]
    pub orgnl_ordrd_qty: QuantityOrAmount2Choice,

    #[yaserde(rename = "PrevslyExctdQty")]
    #[cfg_attr(feature = "serde", serde(rename = "PrevslyExctdQty"))]
    pub prevsly_exctd_qty: QuantityOrAmount2Choice,

    #[yaserde(rename = "RmngQty")]
    #[cfg_attr(feature = "serde", serde(rename = "RmngQty"))]
    pub rmng_qty: QuantityOrAmount2Choice,

    #[yaserde(rename = "MtchIncrmtQty")]
    #[cfg_attr(feature = "serde", serde(rename = "MtchIncrmtQty"))]
    pub mtch_incrmt_qty: QuantityOrAmount2Choice,
}

impl Validate for PartialFill4 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct PartyIdentification116Choice {
    #[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<NameAndAddress13>,
    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: Option<CountryCode>,
}

impl Validate for PartyIdentification116Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct PartyIdentification117 {
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_bic: AnyBICDec2014Identifier,

    #[yaserde(rename = "PrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
    pub prtry_id: GenericIdentification36,

    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: NameAndAddress13,
}

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

impl Validate for PartyIdentification117Choice {}




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

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

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

impl Validate for PartyIdentification118 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
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:setr.027.001.05")]
pub struct PartyIdentification245Choice {
    #[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<GenericIdentification1>,
    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: Option<NameAndAddress5>,
}

impl Validate for PartyIdentification245Choice {}




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

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

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

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

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

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

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

impl Validate for PartyIdentificationAndAccount148 {}


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

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

    #[yaserde(rename = "Sd")]
    #[cfg_attr(feature = "serde", serde(rename = "Sd"))]
    pub sd: ClearingSide1Code,

    #[yaserde(rename = "ClrAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "ClrAcct"))]
    pub clr_acct: SecuritiesAccount20,

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

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

impl Validate for PartyIdentificationAndAccount149 {}


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

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

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

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

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

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

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

impl Validate for PartyIdentificationAndAccount150 {}


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

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

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

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

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

impl Validate for PartyIdentificationAndAccount151 {}


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

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

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

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

impl Validate for PartyIdentificationAndAccount152 {}


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

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

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

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

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

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

impl Validate for PartyIdentificationAndAccount154 {}


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

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

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

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

impl Validate for PartyIdentificationAndAccount155 {}


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

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

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

impl Validate for PartyTextInformation1 {}


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

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

impl Validate for PartyTextInformation2 {}


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

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

impl Validate for PartyTextInformation5 {}


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

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

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

pub enum PositionEffect2Code {
    #[yaserde(rename = "OPEN")]
    #[cfg_attr(feature = "serde", serde(rename = "OPEN"))]
    Open,
    #[yaserde(rename = "CLOS")]
    #[cfg_attr(feature = "serde", serde(rename = "CLOS"))]
    Clos,
    #[yaserde(rename = "ROLL")]
    #[cfg_attr(feature = "serde", serde(rename = "ROLL"))]
    Roll,
    #[yaserde(rename = "FIFO")]
    #[cfg_attr(feature = "serde", serde(rename = "FIFO"))]
    Fifo,
    #[yaserde(rename = "CLOA")]
    #[cfg_attr(feature = "serde", serde(rename = "CLOA"))]
    Cloa,
    __Unknown__(String),
}

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

impl Validate for PositionEffect2Code {}



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


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct Price14 {
    #[yaserde(rename = "Val")]
    #[cfg_attr(feature = "serde", serde(rename = "Val"))]
    pub val: PriceRateOrAmount3Choice,

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

impl Validate for Price14 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct PriceInformation28 {
    #[yaserde(rename = "Val")]
    #[cfg_attr(feature = "serde", serde(rename = "Val"))]
    pub val: Price14,

    #[yaserde(rename = "QtnDt")]
    #[cfg_attr(feature = "serde", serde(rename = "QtnDt"))]
    pub qtn_dt: DateAndDateTime1Choice,

    #[yaserde(rename = "PricClctnPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "PricClctnPrd"))]
    pub pric_clctn_prd: DateTimePeriod1Choice,

    #[yaserde(rename = "SrcOfPric")]
    #[cfg_attr(feature = "serde", serde(rename = "SrcOfPric"))]
    pub src_of_pric: MarketIdentification93,
}

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

impl Validate for PriceRateOrAmount3Choice {}




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

pub enum PriceValueType7Code {
    #[yaserde(rename = "DISC")]
    #[cfg_attr(feature = "serde", serde(rename = "DISC"))]
    Disc,
    #[yaserde(rename = "PREM")]
    #[cfg_attr(feature = "serde", serde(rename = "PREM"))]
    Prem,
    #[yaserde(rename = "PARV")]
    #[cfg_attr(feature = "serde", serde(rename = "PARV"))]
    Parv,
    #[yaserde(rename = "YIEL")]
    #[cfg_attr(feature = "serde", serde(rename = "YIEL"))]
    Yiel,
    #[yaserde(rename = "SPRE")]
    #[cfg_attr(feature = "serde", serde(rename = "SPRE"))]
    Spre,
    #[yaserde(rename = "PEUN")]
    #[cfg_attr(feature = "serde", serde(rename = "PEUN"))]
    Peun,
    #[yaserde(rename = "ABSO")]
    #[cfg_attr(feature = "serde", serde(rename = "ABSO"))]
    Abso,
    #[yaserde(rename = "TEDP")]
    #[cfg_attr(feature = "serde", serde(rename = "TEDP"))]
    Tedp,
    #[yaserde(rename = "TEDY")]
    #[cfg_attr(feature = "serde", serde(rename = "TEDY"))]
    Tedy,
    #[yaserde(rename = "FICT")]
    #[cfg_attr(feature = "serde", serde(rename = "FICT"))]
    Fict,
    #[yaserde(rename = "VACT")]
    #[cfg_attr(feature = "serde", serde(rename = "VACT"))]
    Vact,
    #[yaserde(rename = "PRCT")]
    #[cfg_attr(feature = "serde", serde(rename = "PRCT"))]
    Prct,
    #[yaserde(rename = "ACTU")]
    #[cfg_attr(feature = "serde", serde(rename = "ACTU"))]
    Actu,
    __Unknown__(String),
}

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

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

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

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

impl Validate for Quantity6Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct QuantityBreakdown76 {
    #[yaserde(rename = "LotNb")]
    #[cfg_attr(feature = "serde", serde(rename = "LotNb"))]
    pub lot_nb: GenericIdentification37,

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

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

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

impl Validate for QuantityBreakdown76 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct QuantityOrAmount2Choice {
    #[yaserde(rename = "Qty")]
    #[cfg_attr(feature = "serde", serde(rename = "Qty"))]
    pub qty: Option<FinancialInstrumentQuantity1Choice>,
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<ActiveCurrencyAndAmount>,
}

impl Validate for QuantityOrAmount2Choice {}




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

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

impl Validate for Rate2 {}


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

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

impl Validate for RateName1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct RateOrAbsoluteValue1Choice {
    #[yaserde(rename = "RateVal")]
    #[cfg_attr(feature = "serde", serde(rename = "RateVal"))]
    pub rate_val: Option<PercentageRate>,
    #[yaserde(rename = "AbsVal")]
    #[cfg_attr(feature = "serde", serde(rename = "AbsVal"))]
    pub abs_val: Option<Number>,
}

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

impl Validate for RateOrName1Choice {}




#[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:setr.027.001.05")]

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

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

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

impl Validate for RateType35Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct Rating1 {
    #[yaserde(rename = "RatgSchme")]
    #[cfg_attr(feature = "serde", serde(rename = "RatgSchme"))]
    pub ratg_schme: Max35Text,

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

    #[yaserde(rename = "ValId")]
    #[cfg_attr(feature = "serde", serde(rename = "ValId"))]
    pub val_id: RatingValueIdentifier,
}

impl Validate for Rating1 {}


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

impl Validate for RatingValueIdentifier {}
#[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:setr.027.001.05")]

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

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

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

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

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

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

impl Validate for RegistrationParameters3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct RegulatoryStipulations1 {
    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: CountryCode,

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

impl Validate for RegulatoryStipulations1 {}


#[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:setr.027.001.05")]

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

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

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

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

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:setr.027.001.05")]
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:setr.027.001.05")]
pub struct Revaluation3Choice {
    #[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 Revaluation3Choice {}




#[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:setr.027.001.05")]

pub enum Reversible1Code {
    #[yaserde(rename = "REVL")]
    #[cfg_attr(feature = "serde", serde(rename = "REVL"))]
    Revl,
    #[yaserde(rename = "FIXD")]
    #[cfg_attr(feature = "serde", serde(rename = "FIXD"))]
    Fixd,
    #[yaserde(rename = "CABK")]
    #[cfg_attr(feature = "serde", serde(rename = "CABK"))]
    Cabk,
    __Unknown__(String),
}

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

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

impl Validate for Reversible2Choice {}




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

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

impl Validate for SecuritiesAccount20 {}


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

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

impl Validate for SecuritiesAccount35 {}


#[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:setr.027.001.05")]

pub enum SecuritiesAccountPurposeType1Code {
    #[yaserde(rename = "MARG")]
    #[cfg_attr(feature = "serde", serde(rename = "MARG"))]
    Marg,
    #[yaserde(rename = "SHOR")]
    #[cfg_attr(feature = "serde", serde(rename = "SHOR"))]
    Shor,
    #[yaserde(rename = "ABRD")]
    #[cfg_attr(feature = "serde", serde(rename = "ABRD"))]
    Abrd,
    #[yaserde(rename = "CEND")]
    #[cfg_attr(feature = "serde", serde(rename = "CEND"))]
    Cend,
    #[yaserde(rename = "DVPA")]
    #[cfg_attr(feature = "serde", serde(rename = "DVPA"))]
    Dvpa,
    #[yaserde(rename = "PHYS")]
    #[cfg_attr(feature = "serde", serde(rename = "PHYS"))]
    Phys,
    __Unknown__(String),
}

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

impl Validate for SecuritiesAccountPurposeType1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct SecuritiesCertificate3 {
    #[yaserde(rename = "Nb")]
    #[cfg_attr(feature = "serde", serde(rename = "Nb"))]
    pub nb: Max35Text,

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

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

impl Validate for SecuritiesCertificate3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct SecuritiesFinancing12 {
    #[yaserde(rename = "RateChngDt")]
    #[cfg_attr(feature = "serde", serde(rename = "RateChngDt"))]
    pub rate_chng_dt: IsodateTime,

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

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

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

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

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

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

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

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

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

    #[yaserde(rename = "SprdRate")]
    #[cfg_attr(feature = "serde", serde(rename = "SprdRate"))]
    pub sprd_rate: SpreadRate1,

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

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

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

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

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

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

    #[yaserde(rename = "ClsgAmtPerPcsOfColl")]
    #[cfg_attr(feature = "serde", serde(rename = "ClsgAmtPerPcsOfColl"))]
    pub clsg_amt_per_pcs_of_coll: AmountAndDirection5,

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

    #[yaserde(rename = "FincgAgrmt")]
    #[cfg_attr(feature = "serde", serde(rename = "FincgAgrmt"))]
    pub fincg_agrmt: Agreement5,

    #[yaserde(rename = "LndgTxMtd")]
    #[cfg_attr(feature = "serde", serde(rename = "LndgTxMtd"))]
    pub lndg_tx_mtd: LendingTransactionMethod2Choice,

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

    #[yaserde(rename = "BrrwgRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "BrrwgRsn"))]
    pub brrwg_rsn: BorrowingReason2Choice,

    #[yaserde(rename = "CollTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CollTp"))]
    pub coll_tp: CollateralType4Choice,

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

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

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

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

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

    #[yaserde(rename = "NbOfDaysLndgBrrwg")]
    #[cfg_attr(feature = "serde", serde(rename = "NbOfDaysLndgBrrwg"))]
    pub nb_of_days_lndg_brrwg: Number24Choice,

    #[yaserde(rename = "StdCollAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "StdCollAmt"))]
    pub std_coll_amt: AmountAndDirection5,

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

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

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

    #[yaserde(rename = "SctiesLndgTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesLndgTp"))]
    pub scties_lndg_tp: SecuritiesLendingType2Choice,

    #[yaserde(rename = "Rvsbl")]
    #[cfg_attr(feature = "serde", serde(rename = "Rvsbl"))]
    pub rvsbl: Reversible2Choice,

    #[yaserde(rename = "MinDtForCallBck")]
    #[cfg_attr(feature = "serde", serde(rename = "MinDtForCallBck"))]
    pub min_dt_for_call_bck: Isodate,

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

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

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

impl Validate for SecuritiesFinancing12 {}


#[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:setr.027.001.05")]

pub enum SecuritiesLendingType1Code {
    #[yaserde(rename = "NWRG")]
    #[cfg_attr(feature = "serde", serde(rename = "NWRG"))]
    Nwrg,
    #[yaserde(rename = "RENW")]
    #[cfg_attr(feature = "serde", serde(rename = "RENW"))]
    Renw,
    #[yaserde(rename = "CABK")]
    #[cfg_attr(feature = "serde", serde(rename = "CABK"))]
    Cabk,
    __Unknown__(String),
}

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

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

impl Validate for SecuritiesLendingType2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
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:setr.027.001.05")]
pub struct SecuritiesTradeConfirmationV05 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: TransactiontIdentification4,

    #[yaserde(rename = "NbCnt")]
    #[cfg_attr(feature = "serde", serde(rename = "NbCnt"))]
    pub nb_cnt: NumberCount1Choice,

    #[yaserde(rename = "Refs")]
    #[cfg_attr(feature = "serde", serde(rename = "Refs"))]
    pub refs: Vec<Linkages76>,

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

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

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

    #[yaserde(rename = "UndrlygFinInstrm")]
    #[cfg_attr(feature = "serde", serde(rename = "UndrlygFinInstrm"))]
    pub undrlyg_fin_instrm: Vec<UnderlyingFinancialInstrument7>,

    #[yaserde(rename = "Stiptns")]
    #[cfg_attr(feature = "serde", serde(rename = "Stiptns"))]
    pub stiptns: FinancialInstrumentStipulations4,

    #[yaserde(rename = "ConfPties")]
    #[cfg_attr(feature = "serde", serde(rename = "ConfPties"))]
    pub conf_pties: Vec<ConfirmationParties6>,

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

    #[yaserde(rename = "StgSttlmInstr")]
    #[cfg_attr(feature = "serde", serde(rename = "StgSttlmInstr"))]
    pub stg_sttlm_instr: StandingSettlementInstruction13,

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

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

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

    #[yaserde(rename = "ClrDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "ClrDtls"))]
    pub clr_dtls: Clearing5,

    #[yaserde(rename = "SttlmAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmAmt"))]
    pub sttlm_amt: AmountAndDirection28,

    #[yaserde(rename = "OthrAmts")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrAmts"))]
    pub othr_amts: Vec<OtherAmounts16>,

    #[yaserde(rename = "OthrPrics")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrPrics"))]
    pub othr_prics: Vec<OtherPrices5>,

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

    #[yaserde(rename = "TwoLegTxDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "TwoLegTxDtls"))]
    pub two_leg_tx_dtls: TwoLegTransactionDetails5,

    #[yaserde(rename = "RgltryStiptns")]
    #[cfg_attr(feature = "serde", serde(rename = "RgltryStiptns"))]
    pub rgltry_stiptns: RegulatoryStipulations1,

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

impl Validate for SecuritiesTradeConfirmationV05 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
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:setr.027.001.05")]
pub struct SettlementDate16Choice {
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Option<DateAndDateTime1Choice>,
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<SettlementDateCode12Choice>,
}

impl Validate for SettlementDate16Choice {}




#[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:setr.027.001.05")]

pub enum SettlementDate5Code {
    #[yaserde(rename = "REGU")]
    #[cfg_attr(feature = "serde", serde(rename = "REGU"))]
    Regu,
    #[yaserde(rename = "CASH")]
    #[cfg_attr(feature = "serde", serde(rename = "CASH"))]
    Cash,
    #[yaserde(rename = "NXTD")]
    #[cfg_attr(feature = "serde", serde(rename = "NXTD"))]
    Nxtd,
    #[yaserde(rename = "TONE")]
    #[cfg_attr(feature = "serde", serde(rename = "TONE"))]
    Tone,
    #[yaserde(rename = "TTWO")]
    #[cfg_attr(feature = "serde", serde(rename = "TTWO"))]
    Ttwo,
    #[yaserde(rename = "TTRE")]
    #[cfg_attr(feature = "serde", serde(rename = "TTRE"))]
    Ttre,
    #[yaserde(rename = "TFOR")]
    #[cfg_attr(feature = "serde", serde(rename = "TFOR"))]
    Tfor,
    #[yaserde(rename = "TFIV")]
    #[cfg_attr(feature = "serde", serde(rename = "TFIV"))]
    Tfiv,
    #[yaserde(rename = "SELL")]
    #[cfg_attr(feature = "serde", serde(rename = "SELL"))]
    Sell,
    #[yaserde(rename = "WDIS")]
    #[cfg_attr(feature = "serde", serde(rename = "WDIS"))]
    Wdis,
    #[yaserde(rename = "WHID")]
    #[cfg_attr(feature = "serde", serde(rename = "WHID"))]
    Whid,
    #[yaserde(rename = "TBAT")]
    #[cfg_attr(feature = "serde", serde(rename = "TBAT"))]
    Tbat,
    #[yaserde(rename = "WISS")]
    #[cfg_attr(feature = "serde", serde(rename = "WISS"))]
    Wiss,
    __Unknown__(String),
}

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

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

impl Validate for SettlementDateCode12Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct SettlementDetails213 {
    #[yaserde(rename = "SttlmTxTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmTxTp"))]
    pub sttlm_tx_tp: SettlementTransactionType3Choice,

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

    #[yaserde(rename = "Prty")]
    #[cfg_attr(feature = "serde", serde(rename = "Prty"))]
    pub prty: PriorityNumeric4Choice,

    #[yaserde(rename = "SttlmInstrGnrtn")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmInstrGnrtn"))]
    pub sttlm_instr_gnrtn: SettlementInstructionGeneration2Choice,

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

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

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

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

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

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

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

    #[yaserde(rename = "FxStgInstr")]
    #[cfg_attr(feature = "serde", serde(rename = "FxStgInstr"))]
    pub fx_stg_instr: FxstandingInstruction4Choice,

    #[yaserde(rename = "CcyToBuyOrSell")]
    #[cfg_attr(feature = "serde", serde(rename = "CcyToBuyOrSell"))]
    pub ccy_to_buy_or_sell: CurrencyToBuyOrSell1Choice,

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

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

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

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

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

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

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

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

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

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

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

    #[yaserde(rename = "Trckg")]
    #[cfg_attr(feature = "serde", serde(rename = "Trckg"))]
    pub trckg: Tracking4Choice,

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

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

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

    #[yaserde(rename = "ModCxlAllwd")]
    #[cfg_attr(feature = "serde", serde(rename = "ModCxlAllwd"))]
    pub mod_cxl_allwd: ModificationCancellationAllowed4Choice,

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

impl Validate for SettlementDetails213 {}


#[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:setr.027.001.05")]

pub enum SettlementInstructionGeneration1Code {
    #[yaserde(rename = "GENS")]
    #[cfg_attr(feature = "serde", serde(rename = "GENS"))]
    Gens,
    #[yaserde(rename = "NOGE")]
    #[cfg_attr(feature = "serde", serde(rename = "NOGE"))]
    Noge,
    __Unknown__(String),
}

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

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

impl Validate for SettlementInstructionGeneration2Choice {}




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

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

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

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

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

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

impl Validate for SettlementParties59 {}


#[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:setr.027.001.05")]

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

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

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

impl Validate for SettlementStandingInstructionDatabase4Choice {}




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

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

impl Validate for SettlementTransactionCondition31Choice {}




#[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:setr.027.001.05")]

pub enum SettlementTransactionCondition7Code {
    #[yaserde(rename = "ASGN")]
    #[cfg_attr(feature = "serde", serde(rename = "ASGN"))]
    Asgn,
    #[yaserde(rename = "CLEN")]
    #[cfg_attr(feature = "serde", serde(rename = "CLEN"))]
    Clen,
    #[yaserde(rename = "DIRT")]
    #[cfg_attr(feature = "serde", serde(rename = "DIRT"))]
    Dirt,
    #[yaserde(rename = "DLWM")]
    #[cfg_attr(feature = "serde", serde(rename = "DLWM"))]
    Dlwm,
    #[yaserde(rename = "DRAW")]
    #[cfg_attr(feature = "serde", serde(rename = "DRAW"))]
    Draw,
    #[yaserde(rename = "EXER")]
    #[cfg_attr(feature = "serde", serde(rename = "EXER"))]
    Exer,
    #[yaserde(rename = "FRCL")]
    #[cfg_attr(feature = "serde", serde(rename = "FRCL"))]
    Frcl,
    #[yaserde(rename = "KNOC")]
    #[cfg_attr(feature = "serde", serde(rename = "KNOC"))]
    Knoc,
    #[yaserde(rename = "PHYS")]
    #[cfg_attr(feature = "serde", serde(rename = "PHYS"))]
    Phys,
    #[yaserde(rename = "CSDP")]
    #[cfg_attr(feature = "serde", serde(rename = "CSDP"))]
    Csdp,
    #[yaserde(rename = "SPCS")]
    #[cfg_attr(feature = "serde", serde(rename = "SPCS"))]
    Spcs,
    #[yaserde(rename = "SPDL")]
    #[cfg_attr(feature = "serde", serde(rename = "SPDL"))]
    Spdl,
    #[yaserde(rename = "SPST")]
    #[cfg_attr(feature = "serde", serde(rename = "SPST"))]
    Spst,
    #[yaserde(rename = "UNEX")]
    #[cfg_attr(feature = "serde", serde(rename = "UNEX"))]
    Unex,
    __Unknown__(String),
}

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

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

impl Validate for SettlementTransactionType3Choice {}




#[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:setr.027.001.05")]

pub enum SettlementTransactionType7Code {
    #[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 = "CONV")]
    #[cfg_attr(feature = "serde", serde(rename = "CONV"))]
    Conv,
    #[yaserde(rename = "FCTA")]
    #[cfg_attr(feature = "serde", serde(rename = "FCTA"))]
    Fcta,
    #[yaserde(rename = "INSP")]
    #[cfg_attr(feature = "serde", serde(rename = "INSP"))]
    Insp,
    #[yaserde(rename = "ISSU")]
    #[cfg_attr(feature = "serde", serde(rename = "ISSU"))]
    Issu,
    #[yaserde(rename = "MKDW")]
    #[cfg_attr(feature = "serde", serde(rename = "MKDW"))]
    Mkdw,
    #[yaserde(rename = "MKUP")]
    #[cfg_attr(feature = "serde", serde(rename = "MKUP"))]
    Mkup,
    #[yaserde(rename = "NETT")]
    #[cfg_attr(feature = "serde", serde(rename = "NETT"))]
    Nett,
    #[yaserde(rename = "NSYN")]
    #[cfg_attr(feature = "serde", serde(rename = "NSYN"))]
    Nsyn,
    #[yaserde(rename = "OWNE")]
    #[cfg_attr(feature = "serde", serde(rename = "OWNE"))]
    Owne,
    #[yaserde(rename = "OWNI")]
    #[cfg_attr(feature = "serde", serde(rename = "OWNI"))]
    Owni,
    #[yaserde(rename = "PAIR")]
    #[cfg_attr(feature = "serde", serde(rename = "PAIR"))]
    Pair,
    #[yaserde(rename = "PLAC")]
    #[cfg_attr(feature = "serde", serde(rename = "PLAC"))]
    Plac,
    #[yaserde(rename = "PORT")]
    #[cfg_attr(feature = "serde", serde(rename = "PORT"))]
    Port,
    #[yaserde(rename = "REAL")]
    #[cfg_attr(feature = "serde", serde(rename = "REAL"))]
    Real,
    #[yaserde(rename = "REDI")]
    #[cfg_attr(feature = "serde", serde(rename = "REDI"))]
    Redi,
    #[yaserde(rename = "RELE")]
    #[cfg_attr(feature = "serde", serde(rename = "RELE"))]
    Rele,
    #[yaserde(rename = "REPU")]
    #[cfg_attr(feature = "serde", serde(rename = "REPU"))]
    Repu,
    #[yaserde(rename = "RODE")]
    #[cfg_attr(feature = "serde", serde(rename = "RODE"))]
    Rode,
    #[yaserde(rename = "RPTO")]
    #[cfg_attr(feature = "serde", serde(rename = "RPTO"))]
    Rpto,
    #[yaserde(rename = "RVPO")]
    #[cfg_attr(feature = "serde", serde(rename = "RVPO"))]
    Rvpo,
    #[yaserde(rename = "SBBK")]
    #[cfg_attr(feature = "serde", serde(rename = "SBBK"))]
    Sbbk,
    #[yaserde(rename = "SECB")]
    #[cfg_attr(feature = "serde", serde(rename = "SECB"))]
    Secb,
    #[yaserde(rename = "SECL")]
    #[cfg_attr(feature = "serde", serde(rename = "SECL"))]
    Secl,
    #[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 = "GUAR")]
    #[cfg_attr(feature = "serde", serde(rename = "GUAR"))]
    Guar,
    #[yaserde(rename = "OFIT")]
    #[cfg_attr(feature = "serde", serde(rename = "OFIT"))]
    Ofit,
    __Unknown__(String),
}

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

impl Validate for SettlementTransactionType7Code {}



#[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:setr.027.001.05")]

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

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

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

impl Validate for SettlingCapacity9Choice {}




#[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:setr.027.001.05")]

pub enum Side3Code {
    #[yaserde(rename = "BUYI")]
    #[cfg_attr(feature = "serde", serde(rename = "BUYI"))]
    Buyi,
    #[yaserde(rename = "SELL")]
    #[cfg_attr(feature = "serde", serde(rename = "SELL"))]
    Sell,
    #[yaserde(rename = "CROS")]
    #[cfg_attr(feature = "serde", serde(rename = "CROS"))]
    Cros,
    #[yaserde(rename = "CRSH")]
    #[cfg_attr(feature = "serde", serde(rename = "CRSH"))]
    Crsh,
    #[yaserde(rename = "CSHE")]
    #[cfg_attr(feature = "serde", serde(rename = "CSHE"))]
    Cshe,
    #[yaserde(rename = "DEFI")]
    #[cfg_attr(feature = "serde", serde(rename = "DEFI"))]
    Defi,
    #[yaserde(rename = "OPPO")]
    #[cfg_attr(feature = "serde", serde(rename = "OPPO"))]
    Oppo,
    #[yaserde(rename = "UNDI")]
    #[cfg_attr(feature = "serde", serde(rename = "UNDI"))]
    Undi,
    #[yaserde(rename = "TWOS")]
    #[cfg_attr(feature = "serde", serde(rename = "TWOS"))]
    Twos,
    #[yaserde(rename = "BUMI")]
    #[cfg_attr(feature = "serde", serde(rename = "BUMI"))]
    Bumi,
    #[yaserde(rename = "SEPL")]
    #[cfg_attr(feature = "serde", serde(rename = "SEPL"))]
    Sepl,
    #[yaserde(rename = "SESH")]
    #[cfg_attr(feature = "serde", serde(rename = "SESH"))]
    Sesh,
    #[yaserde(rename = "SSEX")]
    #[cfg_attr(feature = "serde", serde(rename = "SSEX"))]
    Ssex,
    #[yaserde(rename = "LEND")]
    #[cfg_attr(feature = "serde", serde(rename = "LEND"))]
    Lend,
    #[yaserde(rename = "BORW")]
    #[cfg_attr(feature = "serde", serde(rename = "BORW"))]
    Borw,
    #[yaserde(rename = "OPEX")]
    #[cfg_attr(feature = "serde", serde(rename = "OPEX"))]
    Opex,
    __Unknown__(String),
}

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

impl Validate for Side3Code {}



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

impl Validate for SimpleIdentificationInformation2 {}


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

    #[yaserde(rename = "RateOrAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "RateOrAmt"))]
    pub rate_or_amt: AmountOrRate1Choice,
}

impl Validate for SpreadRate1 {}


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

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

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

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

impl Validate for StandingSettlementInstruction13 {}


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

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:setr.027.001.05")]
pub struct Term1 {
    #[yaserde(rename = "Oprtr")]
    #[cfg_attr(feature = "serde", serde(rename = "Oprtr"))]
    pub oprtr: Operator1Code,

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

impl Validate for Term1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct TotalNumber1 {
    #[yaserde(rename = "CurInstrNb")]
    #[cfg_attr(feature = "serde", serde(rename = "CurInstrNb"))]
    pub cur_instr_nb: Exact3NumericText,

    #[yaserde(rename = "TtlOfLkdInstrs")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlOfLkdInstrs"))]
    pub ttl_of_lkd_instrs: Exact3NumericText,
}

impl Validate for TotalNumber1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct Tracking4Choice {
    #[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 Tracking4Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct TradeDate7Choice {
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Option<DateAndDateTime1Choice>,
    #[yaserde(rename = "Val")]
    #[cfg_attr(feature = "serde", serde(rename = "Val"))]
    pub val: Option<TradingDateCode2Choice>,
}

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

pub enum TradeRegulatoryConditions1Code {
    #[yaserde(rename = "SOLI")]
    #[cfg_attr(feature = "serde", serde(rename = "SOLI"))]
    Soli,
    #[yaserde(rename = "USOL")]
    #[cfg_attr(feature = "serde", serde(rename = "USOL"))]
    Usol,
    __Unknown__(String),
}

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

impl Validate for TradeRegulatoryConditions1Code {}



#[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:setr.027.001.05")]

pub enum TradeTransactionCondition2Code {
    #[yaserde(rename = "SPCC")]
    #[cfg_attr(feature = "serde", serde(rename = "SPCC"))]
    Spcc,
    #[yaserde(rename = "SECN")]
    #[cfg_attr(feature = "serde", serde(rename = "SECN"))]
    Secn,
    #[yaserde(rename = "SEBN")]
    #[cfg_attr(feature = "serde", serde(rename = "SEBN"))]
    Sebn,
    #[yaserde(rename = "SCBN")]
    #[cfg_attr(feature = "serde", serde(rename = "SCBN"))]
    Scbn,
    #[yaserde(rename = "SCRT")]
    #[cfg_attr(feature = "serde", serde(rename = "SCRT"))]
    Scrt,
    #[yaserde(rename = "SERT")]
    #[cfg_attr(feature = "serde", serde(rename = "SERT"))]
    Sert,
    #[yaserde(rename = "SCCR")]
    #[cfg_attr(feature = "serde", serde(rename = "SCCR"))]
    Sccr,
    #[yaserde(rename = "SECR")]
    #[cfg_attr(feature = "serde", serde(rename = "SECR"))]
    Secr,
    #[yaserde(rename = "CAST")]
    #[cfg_attr(feature = "serde", serde(rename = "CAST"))]
    Cast,
    #[yaserde(rename = "SPPR")]
    #[cfg_attr(feature = "serde", serde(rename = "SPPR"))]
    Sppr,
    #[yaserde(rename = "SPCU")]
    #[cfg_attr(feature = "serde", serde(rename = "SPCU"))]
    Spcu,
    #[yaserde(rename = "SPEX")]
    #[cfg_attr(feature = "serde", serde(rename = "SPEX"))]
    Spex,
    #[yaserde(rename = "GTDL")]
    #[cfg_attr(feature = "serde", serde(rename = "GTDL"))]
    Gtdl,
    __Unknown__(String),
}

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

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

impl Validate for TradeTransactionCondition9Choice {}




#[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:setr.027.001.05")]

pub enum TradeType3Code {
    #[yaserde(rename = "BSKT")]
    #[cfg_attr(feature = "serde", serde(rename = "BSKT"))]
    Bskt,
    #[yaserde(rename = "INDX")]
    #[cfg_attr(feature = "serde", serde(rename = "INDX"))]
    Indx,
    #[yaserde(rename = "IPOO")]
    #[cfg_attr(feature = "serde", serde(rename = "IPOO"))]
    Ipoo,
    #[yaserde(rename = "LIST")]
    #[cfg_attr(feature = "serde", serde(rename = "LIST"))]
    List,
    #[yaserde(rename = "PRAL")]
    #[cfg_attr(feature = "serde", serde(rename = "PRAL"))]
    Pral,
    #[yaserde(rename = "PROG")]
    #[cfg_attr(feature = "serde", serde(rename = "PROG"))]
    Prog,
    #[yaserde(rename = "TRAD")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAD"))]
    Trad,
    #[yaserde(rename = "BRBR")]
    #[cfg_attr(feature = "serde", serde(rename = "BRBR"))]
    Brbr,
    #[yaserde(rename = "RISK")]
    #[cfg_attr(feature = "serde", serde(rename = "RISK"))]
    Risk,
    #[yaserde(rename = "VWAP")]
    #[cfg_attr(feature = "serde", serde(rename = "VWAP"))]
    Vwap,
    #[yaserde(rename = "AGEN")]
    #[cfg_attr(feature = "serde", serde(rename = "AGEN"))]
    Agen,
    #[yaserde(rename = "GUAR")]
    #[cfg_attr(feature = "serde", serde(rename = "GUAR"))]
    Guar,
    #[yaserde(rename = "EMTR")]
    #[cfg_attr(feature = "serde", serde(rename = "EMTR"))]
    Emtr,
    #[yaserde(rename = "ISSU")]
    #[cfg_attr(feature = "serde", serde(rename = "ISSU"))]
    Issu,
    #[yaserde(rename = "BOST")]
    #[cfg_attr(feature = "serde", serde(rename = "BOST"))]
    Bost,
    #[yaserde(rename = "BOEN")]
    #[cfg_attr(feature = "serde", serde(rename = "BOEN"))]
    Boen,
    #[yaserde(rename = "LABO")]
    #[cfg_attr(feature = "serde", serde(rename = "LABO"))]
    Labo,
    #[yaserde(rename = "BORE")]
    #[cfg_attr(feature = "serde", serde(rename = "BORE"))]
    Bore,
    #[yaserde(rename = "OFIT")]
    #[cfg_attr(feature = "serde", serde(rename = "OFIT"))]
    Ofit,
    #[yaserde(rename = "BOSU")]
    #[cfg_attr(feature = "serde", serde(rename = "BOSU"))]
    Bosu,
    #[yaserde(rename = "FBBT")]
    #[cfg_attr(feature = "serde", serde(rename = "FBBT"))]
    Fbbt,
    #[yaserde(rename = "OPTN")]
    #[cfg_attr(feature = "serde", serde(rename = "OPTN"))]
    Optn,
    #[yaserde(rename = "FUOP")]
    #[cfg_attr(feature = "serde", serde(rename = "FUOP"))]
    Fuop,
    #[yaserde(rename = "FUTR")]
    #[cfg_attr(feature = "serde", serde(rename = "FUTR"))]
    Futr,
    __Unknown__(String),
}

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

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

impl Validate for TradeType4Choice {}




#[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:setr.027.001.05")]

pub enum TradingCapacity4Code {
    #[yaserde(rename = "PRIN")]
    #[cfg_attr(feature = "serde", serde(rename = "PRIN"))]
    Prin,
    #[yaserde(rename = "CPRN")]
    #[cfg_attr(feature = "serde", serde(rename = "CPRN"))]
    Cprn,
    #[yaserde(rename = "RISP")]
    #[cfg_attr(feature = "serde", serde(rename = "RISP"))]
    Risp,
    #[yaserde(rename = "PROP")]
    #[cfg_attr(feature = "serde", serde(rename = "PROP"))]
    Prop,
    #[yaserde(rename = "AGEN")]
    #[cfg_attr(feature = "serde", serde(rename = "AGEN"))]
    Agen,
    #[yaserde(rename = "CAGN")]
    #[cfg_attr(feature = "serde", serde(rename = "CAGN"))]
    Cagn,
    #[yaserde(rename = "OAGN")]
    #[cfg_attr(feature = "serde", serde(rename = "OAGN"))]
    Oagn,
    #[yaserde(rename = "PRAG")]
    #[cfg_attr(feature = "serde", serde(rename = "PRAG"))]
    Prag,
    #[yaserde(rename = "BAGN")]
    #[cfg_attr(feature = "serde", serde(rename = "BAGN"))]
    Bagn,
    #[yaserde(rename = "INFI")]
    #[cfg_attr(feature = "serde", serde(rename = "INFI"))]
    Infi,
    #[yaserde(rename = "MKTM")]
    #[cfg_attr(feature = "serde", serde(rename = "MKTM"))]
    Mktm,
    #[yaserde(rename = "MLTF")]
    #[cfg_attr(feature = "serde", serde(rename = "MLTF"))]
    Mltf,
    #[yaserde(rename = "RMKT")]
    #[cfg_attr(feature = "serde", serde(rename = "RMKT"))]
    Rmkt,
    #[yaserde(rename = "SINT")]
    #[cfg_attr(feature = "serde", serde(rename = "SINT"))]
    Sint,
    #[yaserde(rename = "TAGT")]
    #[cfg_attr(feature = "serde", serde(rename = "TAGT"))]
    Tagt,
    __Unknown__(String),
}

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

impl Validate for TradingCapacity4Code {}



#[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:setr.027.001.05")]

pub enum TradingCapacity6Code {
    #[yaserde(rename = "AGEN")]
    #[cfg_attr(feature = "serde", serde(rename = "AGEN"))]
    Agen,
    #[yaserde(rename = "BAGN")]
    #[cfg_attr(feature = "serde", serde(rename = "BAGN"))]
    Bagn,
    #[yaserde(rename = "CAGN")]
    #[cfg_attr(feature = "serde", serde(rename = "CAGN"))]
    Cagn,
    #[yaserde(rename = "CPRN")]
    #[cfg_attr(feature = "serde", serde(rename = "CPRN"))]
    Cprn,
    #[yaserde(rename = "OAGN")]
    #[cfg_attr(feature = "serde", serde(rename = "OAGN"))]
    Oagn,
    #[yaserde(rename = "PRAG")]
    #[cfg_attr(feature = "serde", serde(rename = "PRAG"))]
    Prag,
    #[yaserde(rename = "PRIN")]
    #[cfg_attr(feature = "serde", serde(rename = "PRIN"))]
    Prin,
    __Unknown__(String),
}

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

impl Validate for TradingCapacity6Code {}



#[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:setr.027.001.05")]

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

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

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

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

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

impl Validate for TradingPartyCapacity4Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct TransactiontIdentification4 {
    #[yaserde(rename = "TxId")]
    #[cfg_attr(feature = "serde", serde(rename = "TxId"))]
    pub tx_id: Max35Text,
}

impl Validate for TransactiontIdentification4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct TwoLegTransactionDetails5 {
    #[yaserde(rename = "TradDt")]
    #[cfg_attr(feature = "serde", serde(rename = "TradDt"))]
    pub trad_dt: TradeDate8Choice,

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

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

    #[yaserde(rename = "GrssTradAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "GrssTradAmt"))]
    pub grss_trad_amt: AmountAndDirection29,

    #[yaserde(rename = "OthrAmts")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrAmts"))]
    pub othr_amts: Vec<OtherAmounts16>,

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

    #[yaserde(rename = "EndPric")]
    #[cfg_attr(feature = "serde", serde(rename = "EndPric"))]
    pub end_pric: Price14,

    #[yaserde(rename = "ClsgDt")]
    #[cfg_attr(feature = "serde", serde(rename = "ClsgDt"))]
    pub clsg_dt: ClosingDate4Choice,

    #[yaserde(rename = "ClsgSttlmAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "ClsgSttlmAmt"))]
    pub clsg_sttlm_amt: AmountAndDirection5,

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

    #[yaserde(rename = "TwoLegTxTp")]
    #[cfg_attr(feature = "serde", serde(rename = "TwoLegTxTp"))]
    pub two_leg_tx_tp: TwoLegTransactionType4Choice,
}

impl Validate for TwoLegTransactionDetails5 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct TwoLegTransactionType4Choice {
    #[yaserde(rename = "FutrOrOptnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "FutrOrOptnDtls"))]
    pub futr_or_optn_dtls: Option<FutureOrOptionDetails3>,
    #[yaserde(rename = "SctiesFincgDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesFincgDtls"))]
    pub scties_fincg_dtls: Option<SecuritiesFinancing12>,
}

impl Validate for TwoLegTransactionType4Choice {}




#[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:setr.027.001.05")]

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

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

impl Validate for TypeOfIdentification1Code {}



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

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

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

impl Validate for TypeOfIdentification2Code {}



#[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:setr.027.001.05")]

pub enum TypeOfPrice3Code {
    #[yaserde(rename = "AVER")]
    #[cfg_attr(feature = "serde", serde(rename = "AVER"))]
    Aver,
    #[yaserde(rename = "AVOV")]
    #[cfg_attr(feature = "serde", serde(rename = "AVOV"))]
    Avov,
    #[yaserde(rename = "GREX")]
    #[cfg_attr(feature = "serde", serde(rename = "GREX"))]
    Grex,
    #[yaserde(rename = "NET2")]
    #[cfg_attr(feature = "serde", serde(rename = "NET2"))]
    Net2,
    #[yaserde(rename = "NET1")]
    #[cfg_attr(feature = "serde", serde(rename = "NET1"))]
    Net1,
    #[yaserde(rename = "PARV")]
    #[cfg_attr(feature = "serde", serde(rename = "PARV"))]
    Parv,
    #[yaserde(rename = "RDAV")]
    #[cfg_attr(feature = "serde", serde(rename = "RDAV"))]
    Rdav,
    __Unknown__(String),
}

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

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

impl Validate for TypeOfPrice47Choice {}




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

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

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

    #[yaserde(rename = "Attrbts")]
    #[cfg_attr(feature = "serde", serde(rename = "Attrbts"))]
    pub attrbts: FinancialInstrumentAttributes124,
}

impl Validate for UnderlyingFinancialInstrument7 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct UnderlyingRatio2 {
    #[yaserde(rename = "UndrlygQtyDnmtr")]
    #[cfg_attr(feature = "serde", serde(rename = "UndrlygQtyDnmtr"))]
    pub undrlyg_qty_dnmtr: FinancialInstrumentQuantity1Choice,

    #[yaserde(rename = "UndrlygQtyNmrtr")]
    #[cfg_attr(feature = "serde", serde(rename = "UndrlygQtyNmrtr"))]
    pub undrlyg_qty_nmrtr: FinancialInstrumentQuantity1Choice,

    #[yaserde(rename = "RltdFinInstrmId")]
    #[cfg_attr(feature = "serde", serde(rename = "RltdFinInstrmId"))]
    pub rltd_fin_instrm_id: Vec<SecurityIdentification19>,
}

impl Validate for UnderlyingRatio2 {}


#[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:setr.027.001.05")]

pub enum UnitOfMeasure1Code {
    #[yaserde(rename = "PIEC")]
    #[cfg_attr(feature = "serde", serde(rename = "PIEC"))]
    Piec,
    #[yaserde(rename = "TONS")]
    #[cfg_attr(feature = "serde", serde(rename = "TONS"))]
    Tons,
    #[yaserde(rename = "FOOT")]
    #[cfg_attr(feature = "serde", serde(rename = "FOOT"))]
    Foot,
    #[yaserde(rename = "GBGA")]
    #[cfg_attr(feature = "serde", serde(rename = "GBGA"))]
    Gbga,
    #[yaserde(rename = "USGA")]
    #[cfg_attr(feature = "serde", serde(rename = "USGA"))]
    Usga,
    #[yaserde(rename = "GRAM")]
    #[cfg_attr(feature = "serde", serde(rename = "GRAM"))]
    Gram,
    #[yaserde(rename = "INCH")]
    #[cfg_attr(feature = "serde", serde(rename = "INCH"))]
    Inch,
    #[yaserde(rename = "KILO")]
    #[cfg_attr(feature = "serde", serde(rename = "KILO"))]
    Kilo,
    #[yaserde(rename = "PUND")]
    #[cfg_attr(feature = "serde", serde(rename = "PUND"))]
    Pund,
    #[yaserde(rename = "METR")]
    #[cfg_attr(feature = "serde", serde(rename = "METR"))]
    Metr,
    #[yaserde(rename = "CMET")]
    #[cfg_attr(feature = "serde", serde(rename = "CMET"))]
    Cmet,
    #[yaserde(rename = "MMET")]
    #[cfg_attr(feature = "serde", serde(rename = "MMET"))]
    Mmet,
    #[yaserde(rename = "LITR")]
    #[cfg_attr(feature = "serde", serde(rename = "LITR"))]
    Litr,
    #[yaserde(rename = "CELI")]
    #[cfg_attr(feature = "serde", serde(rename = "CELI"))]
    Celi,
    #[yaserde(rename = "MILI")]
    #[cfg_attr(feature = "serde", serde(rename = "MILI"))]
    Mili,
    #[yaserde(rename = "GBOU")]
    #[cfg_attr(feature = "serde", serde(rename = "GBOU"))]
    Gbou,
    #[yaserde(rename = "USOU")]
    #[cfg_attr(feature = "serde", serde(rename = "USOU"))]
    Usou,
    #[yaserde(rename = "GBQA")]
    #[cfg_attr(feature = "serde", serde(rename = "GBQA"))]
    Gbqa,
    #[yaserde(rename = "USQA")]
    #[cfg_attr(feature = "serde", serde(rename = "USQA"))]
    Usqa,
    #[yaserde(rename = "GBPI")]
    #[cfg_attr(feature = "serde", serde(rename = "GBPI"))]
    Gbpi,
    #[yaserde(rename = "USPI")]
    #[cfg_attr(feature = "serde", serde(rename = "USPI"))]
    Uspi,
    #[yaserde(rename = "MILE")]
    #[cfg_attr(feature = "serde", serde(rename = "MILE"))]
    Mile,
    #[yaserde(rename = "KMET")]
    #[cfg_attr(feature = "serde", serde(rename = "KMET"))]
    Kmet,
    #[yaserde(rename = "YARD")]
    #[cfg_attr(feature = "serde", serde(rename = "YARD"))]
    Yard,
    #[yaserde(rename = "SQKI")]
    #[cfg_attr(feature = "serde", serde(rename = "SQKI"))]
    Sqki,
    #[yaserde(rename = "HECT")]
    #[cfg_attr(feature = "serde", serde(rename = "HECT"))]
    Hect,
    #[yaserde(rename = "ARES")]
    #[cfg_attr(feature = "serde", serde(rename = "ARES"))]
    Ares,
    #[yaserde(rename = "SMET")]
    #[cfg_attr(feature = "serde", serde(rename = "SMET"))]
    Smet,
    #[yaserde(rename = "SCMT")]
    #[cfg_attr(feature = "serde", serde(rename = "SCMT"))]
    Scmt,
    #[yaserde(rename = "SMIL")]
    #[cfg_attr(feature = "serde", serde(rename = "SMIL"))]
    Smil,
    #[yaserde(rename = "SQMI")]
    #[cfg_attr(feature = "serde", serde(rename = "SQMI"))]
    Sqmi,
    #[yaserde(rename = "SQYA")]
    #[cfg_attr(feature = "serde", serde(rename = "SQYA"))]
    Sqya,
    #[yaserde(rename = "SQFO")]
    #[cfg_attr(feature = "serde", serde(rename = "SQFO"))]
    Sqfo,
    #[yaserde(rename = "SQIN")]
    #[cfg_attr(feature = "serde", serde(rename = "SQIN"))]
    Sqin,
    #[yaserde(rename = "ACRE")]
    #[cfg_attr(feature = "serde", serde(rename = "ACRE"))]
    Acre,
    __Unknown__(String),
}

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

impl Validate for UnitOfMeasure1Code {}



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

impl Validate for YesNoIndicator {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.027.001.05")]
pub struct YieldCalculation7 {
    #[yaserde(rename = "Val")]
    #[cfg_attr(feature = "serde", serde(rename = "Val"))]
    pub val: PercentageRate,

    #[yaserde(rename = "ClctnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ClctnTp"))]
    pub clctn_tp: CalculationType1Code,

    #[yaserde(rename = "RedPric")]
    #[cfg_attr(feature = "serde", serde(rename = "RedPric"))]
    pub red_pric: Price14,

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

    #[yaserde(rename = "ValPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "ValPrd"))]
    pub val_prd: DateTimePeriod1Choice,

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

impl Validate for YieldCalculation7 {}

impl crate::MxMessage for Document {
    const BUSINESS_AREA: crate::BusinessArea = crate::BusinessArea::setr;
    const FUNCTIONALITY: &'static str = "027";
    const VARIANT: &'static str = "001";
    const VERSION: &'static str = "05";
    const MESSAGE_NAME: &'static str = "setr.027.001.05";
    const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:setr.027.001.05";
}