rust_iso20022 0.1.1

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

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

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

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.016.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 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.016.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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.016.001.05")]
pub struct AdditionalAmount1Choice {
    #[yaserde(rename = "AddtlCshIn")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlCshIn"))]
    pub addtl_csh_in: Option<ActiveOrHistoricCurrencyAndAmount>,
    #[yaserde(rename = "RsltgCshOut")]
    #[cfg_attr(feature = "serde", serde(rename = "RsltgCshOut"))]
    pub rsltg_csh_out: Option<ActiveOrHistoricCurrencyAndAmount>,
}

impl Validate for AdditionalAmount1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.05")]
pub struct AdditionalReference10 {
    #[yaserde(rename = "Ref")]
    #[cfg_attr(feature = "serde", serde(rename = "Ref"))]
    pub _ref: Max35Text,

    #[yaserde(rename = "RefIssr")]
    #[cfg_attr(feature = "serde", serde(rename = "RefIssr"))]
    pub ref_issr: PartyIdentification139,

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

impl Validate for AdditionalReference10 {}


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

    #[yaserde(rename = "IdSrc")]
    #[cfg_attr(feature = "serde", serde(rename = "IdSrc"))]
    pub id_src: IdentificationSource1Choice,
}

impl Validate for AlternateSecurityIdentification7 {}


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

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

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

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

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

impl Validate for BlockChainAddressWallet3 {}


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

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

impl Validate for Cusipidentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.05")]
pub struct CancelledReason12Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<CancelledStatusReason2Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification1>,
    #[yaserde(rename = "NoSpcfdRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "NoSpcfdRsn"))]
    pub no_spcfd_rsn: Option<NoReasonCode>,
}

impl Validate for CancelledReason12Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.05")]
pub struct CancelledStatusReason16 {
    #[yaserde(rename = "Rsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
    pub rsn: CancelledReason12Choice,

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

impl Validate for CancelledStatusReason16 {}


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

pub enum CancelledStatusReason2Code {
    #[yaserde(rename = "CANH")]
    #[cfg_attr(feature = "serde", serde(rename = "CANH"))]
    Canh,
    #[yaserde(rename = "CANP")]
    #[cfg_attr(feature = "serde", serde(rename = "CANP"))]
    Canp,
    #[yaserde(rename = "CXLR")]
    #[cfg_attr(feature = "serde", serde(rename = "CXLR"))]
    Cxlr,
    #[yaserde(rename = "CANO")]
    #[cfg_attr(feature = "serde", serde(rename = "CANO"))]
    Cano,
    __Unknown__(String),
}

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

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

impl Validate for ChargeType10Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.05")]
pub struct ConditionallyAcceptedStatus3Choice {
    #[yaserde(rename = "NoSpcfdRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "NoSpcfdRsn"))]
    pub no_spcfd_rsn: Option<NoReasonCode>,
    #[yaserde(rename = "RsnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "RsnDtls"))]
    pub rsn_dtls: Vec<ConditionallyAcceptedStatusReason3>,
}

impl Validate for ConditionallyAcceptedStatus3Choice {}




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

pub enum ConditionallyAcceptedStatusReason2Code {
    #[yaserde(rename = "DOCC")]
    #[cfg_attr(feature = "serde", serde(rename = "DOCC"))]
    Docc,
    #[yaserde(rename = "AWRM")]
    #[cfg_attr(feature = "serde", serde(rename = "AWRM"))]
    Awrm,
    #[yaserde(rename = "AWSM")]
    #[cfg_attr(feature = "serde", serde(rename = "AWSM"))]
    Awsm,
    #[yaserde(rename = "DUPL")]
    #[cfg_attr(feature = "serde", serde(rename = "DUPL"))]
    Dupl,
    #[yaserde(rename = "CRED")]
    #[cfg_attr(feature = "serde", serde(rename = "CRED"))]
    Cred,
    __Unknown__(String),
}

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

impl Validate for ConditionallyAcceptedStatusReason2Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.05")]
pub struct ConditionallyAcceptedStatusReason3 {
    #[yaserde(rename = "Rsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
    pub rsn: ConditionallyAcceptedStatusReason3Choice,

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

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

impl Validate for ConditionallyAcceptedStatusReason3Choice {}




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

impl Validate for ConsolidatedTapeAssociationIdentifier {
    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 CountryCode (pub String);
crate::simple_type!(CountryCode);

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

impl Validate for Dti2024Identifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.016.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.016.001.05")]
pub struct DateFormat42Choice {
    #[yaserde(rename = "YrMnth")]
    #[cfg_attr(feature = "serde", serde(rename = "YrMnth"))]
    pub yr_mnth: Option<IsoyearMonth>,
    #[yaserde(rename = "YrMnthDay")]
    #[cfg_attr(feature = "serde", serde(rename = "YrMnthDay"))]
    pub yr_mnth_day: Option<Isodate>,
}

impl Validate for DateFormat42Choice {}




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

pub enum DistributionPolicy1Code {
    #[yaserde(rename = "DIST")]
    #[cfg_attr(feature = "serde", serde(rename = "DIST"))]
    Dist,
    #[yaserde(rename = "ACCU")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCU"))]
    Accu,
    __Unknown__(String),
}

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

impl Validate for DistributionPolicy1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.05")]
pub struct Document {
    #[yaserde(rename = "OrdrInstrStsRpt")]
    #[cfg_attr(feature = "serde", serde(rename = "OrdrInstrStsRpt"))]
    pub ordr_instr_sts_rpt: OrderInstructionStatusReportV05,
}

impl Validate for Document {}


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

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

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

#[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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.016.001.05")]
pub struct ExpectedExecution6 {
    #[yaserde(rename = "XpctdTradDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "XpctdTradDtTm"))]
    pub xpctd_trad_dt_tm: DateAndDateTime2Choice,

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

impl Validate for ExpectedExecution6 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.05")]
pub struct ExpectedExecutionDetails5 {
    #[yaserde(rename = "XpctdTradDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "XpctdTradDtTm"))]
    pub xpctd_trad_dt_tm: DateAndDateTime2Choice,

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

impl Validate for ExpectedExecutionDetails5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.05")]
pub struct Extension1 {
    #[yaserde(rename = "PlcAndNm")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcAndNm"))]
    pub plc_and_nm: Max350Text,

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

impl Validate for Extension1 {}


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

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

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

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

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

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

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

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

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

impl Validate for Fee12 {}


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

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

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

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

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

    #[yaserde(rename = "SctiesForm")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesForm"))]
    pub scties_form: FormOfSecurity1Code,

    #[yaserde(rename = "DstrbtnPlcy")]
    #[cfg_attr(feature = "serde", serde(rename = "DstrbtnPlcy"))]
    pub dstrbtn_plcy: DistributionPolicy1Code,

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

    #[yaserde(rename = "SrsId")]
    #[cfg_attr(feature = "serde", serde(rename = "SrsId"))]
    pub srs_id: Series1,
}

impl Validate for FinancialInstrument107 {}


#[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.016.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.016.001.05")]
pub struct FundOrderData6 {
    #[yaserde(rename = "SttlmAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmAmt"))]
    pub sttlm_amt: ActiveCurrencyAndAmount,

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

    #[yaserde(rename = "AddtlAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlAmt"))]
    pub addtl_amt: AdditionalAmount1Choice,

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

impl Validate for FundOrderData6 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.05")]
pub struct FundOrderData7 {
    #[yaserde(rename = "InvstmtAcctDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "InvstmtAcctDtls"))]
    pub invstmt_acct_dtls: InvestmentAccount81,

    #[yaserde(rename = "FinInstrmDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrmDtls"))]
    pub fin_instrm_dtls: FinancialInstrument107,

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

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

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

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

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

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

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

impl Validate for FundOrderData7 {}


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

pub enum GateHoldBack1Code {
    #[yaserde(rename = "GATE")]
    #[cfg_attr(feature = "serde", serde(rename = "GATE"))]
    Gate,
    #[yaserde(rename = "HOLD")]
    #[cfg_attr(feature = "serde", serde(rename = "HOLD"))]
    Hold,
    __Unknown__(String),
}

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

impl Validate for GateHoldBack1Code {}



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

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

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

impl Validate for GenericIdentification47 {}


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

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

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

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

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

    #[yaserde(rename = "RedCmpltn")]
    #[cfg_attr(feature = "serde", serde(rename = "RedCmpltn"))]
    pub red_cmpltn: RedemptionCompletion1Code,
}

impl Validate for HoldBackInformation4 {}


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

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

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

impl Validate for IsodateTime {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
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.016.001.05")]
pub struct IdentificationSource1Choice {
    #[yaserde(rename = "Dmst")]
    #[cfg_attr(feature = "serde", serde(rename = "Dmst"))]
    pub dmst: Option<CountryCode>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max35Text>,
}

impl Validate for IdentificationSource1Choice {}




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

pub enum InRepairStatusReason1Code {
    #[yaserde(rename = "COMA")]
    #[cfg_attr(feature = "serde", serde(rename = "COMA"))]
    Coma,
    __Unknown__(String),
}

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

impl Validate for InRepairStatusReason1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.05")]
pub struct InRepairStatusReason4 {
    #[yaserde(rename = "Rsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
    pub rsn: InRepairStatusReason5Choice,

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

impl Validate for InRepairStatusReason4 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.05")]
pub struct InRepairStatusReason4Choice {
    #[yaserde(rename = "NoSpcfdRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "NoSpcfdRsn"))]
    pub no_spcfd_rsn: Option<NoReasonCode>,
    #[yaserde(rename = "RsnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "RsnDtls"))]
    pub rsn_dtls: Vec<InRepairStatusReason4>,
}

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

impl Validate for InRepairStatusReason5Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.05")]
pub struct IndividualOrderStatusAndReason9 {
    #[yaserde(rename = "MstrRef")]
    #[cfg_attr(feature = "serde", serde(rename = "MstrRef"))]
    pub mstr_ref: Max35Text,

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

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

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

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

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

    #[yaserde(rename = "OrdrSts")]
    #[cfg_attr(feature = "serde", serde(rename = "OrdrSts"))]
    pub ordr_sts: OrderStatus6Choice,

    #[yaserde(rename = "RprdFee")]
    #[cfg_attr(feature = "serde", serde(rename = "RprdFee"))]
    pub rprd_fee: Vec<Fee12>,

    #[yaserde(rename = "StsInitr")]
    #[cfg_attr(feature = "serde", serde(rename = "StsInitr"))]
    pub sts_initr: PartyIdentification139,

    #[yaserde(rename = "OrdrData")]
    #[cfg_attr(feature = "serde", serde(rename = "OrdrData"))]
    pub ordr_data: FundOrderData7,

    #[yaserde(rename = "NewDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "NewDtls"))]
    pub new_dtls: ExpectedExecutionDetails5,

    #[yaserde(rename = "GtgOrHldBckDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "GtgOrHldBckDtls"))]
    pub gtg_or_hld_bck_dtls: HoldBackInformation4,
}

impl Validate for IndividualOrderStatusAndReason9 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.05")]
pub struct InvestmentAccount81 {
    #[yaserde(rename = "AcctId")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctId"))]
    pub acct_id: Max35Text,

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

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

    #[yaserde(rename = "OwnrId")]
    #[cfg_attr(feature = "serde", serde(rename = "OwnrId"))]
    pub ownr_id: Vec<PartyIdentification139>,

    #[yaserde(rename = "AcctSvcr")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctSvcr"))]
    pub acct_svcr: PartyIdentification139,

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

    #[yaserde(rename = "SubAcctDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "SubAcctDtls"))]
    pub sub_acct_dtls: SubAccount6,

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

impl Validate for InvestmentAccount81 {}


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

pub enum InvestmentFundFee3Code {
    #[yaserde(rename = "BEND")]
    #[cfg_attr(feature = "serde", serde(rename = "BEND"))]
    Bend,
    #[yaserde(rename = "BRKF")]
    #[cfg_attr(feature = "serde", serde(rename = "BRKF"))]
    Brkf,
    #[yaserde(rename = "CDSC")]
    #[cfg_attr(feature = "serde", serde(rename = "CDSC"))]
    Cdsc,
    #[yaserde(rename = "CBCH")]
    #[cfg_attr(feature = "serde", serde(rename = "CBCH"))]
    Cbch,
    #[yaserde(rename = "DLEV")]
    #[cfg_attr(feature = "serde", serde(rename = "DLEV"))]
    Dlev,
    #[yaserde(rename = "FEND")]
    #[cfg_attr(feature = "serde", serde(rename = "FEND"))]
    Fend,
    #[yaserde(rename = "INIT")]
    #[cfg_attr(feature = "serde", serde(rename = "INIT"))]
    Init,
    #[yaserde(rename = "PREM")]
    #[cfg_attr(feature = "serde", serde(rename = "PREM"))]
    Prem,
    #[yaserde(rename = "CHAR")]
    #[cfg_attr(feature = "serde", serde(rename = "CHAR"))]
    Char,
    #[yaserde(rename = "SWIT")]
    #[cfg_attr(feature = "serde", serde(rename = "SWIT"))]
    Swit,
    #[yaserde(rename = "UCIC")]
    #[cfg_attr(feature = "serde", serde(rename = "UCIC"))]
    Ucic,
    #[yaserde(rename = "COMM")]
    #[cfg_attr(feature = "serde", serde(rename = "COMM"))]
    Comm,
    #[yaserde(rename = "SHIP")]
    #[cfg_attr(feature = "serde", serde(rename = "SHIP"))]
    Ship,
    #[yaserde(rename = "POST")]
    #[cfg_attr(feature = "serde", serde(rename = "POST"))]
    Post,
    #[yaserde(rename = "CDPL")]
    #[cfg_attr(feature = "serde", serde(rename = "CDPL"))]
    Cdpl,
    #[yaserde(rename = "ADDF")]
    #[cfg_attr(feature = "serde", serde(rename = "ADDF"))]
    Addf,
    #[yaserde(rename = "REGF")]
    #[cfg_attr(feature = "serde", serde(rename = "REGF"))]
    Regf,
    #[yaserde(rename = "PENA")]
    #[cfg_attr(feature = "serde", serde(rename = "PENA"))]
    Pena,
    #[yaserde(rename = "NTWK")]
    #[cfg_attr(feature = "serde", serde(rename = "NTWK"))]
    Ntwk,
    __Unknown__(String),
}

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

impl Validate for InvestmentFundFee3Code {}



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

impl Validate for Leiidentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.016.001.05")]
pub struct LegIdentification1Choice {
    #[yaserde(rename = "RedLegId")]
    #[cfg_attr(feature = "serde", serde(rename = "RedLegId"))]
    pub red_leg_id: Option<Max35Text>,
    #[yaserde(rename = "SbcptLegId")]
    #[cfg_attr(feature = "serde", serde(rename = "SbcptLegId"))]
    pub sbcpt_leg_id: Option<Max35Text>,
}

impl Validate for LegIdentification1Choice {}




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

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

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

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

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

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

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

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

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

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

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

impl Validate for MessageIdentification1 {}


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

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

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

impl Validate for NoReasonCode {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.016.001.05")]
pub struct OrderInstructionStatusReportV05 {
    #[yaserde(rename = "MsgId")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgId"))]
    pub msg_id: MessageIdentification1,

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

    #[yaserde(rename = "StsRpt")]
    #[cfg_attr(feature = "serde", serde(rename = "StsRpt"))]
    pub sts_rpt: Status40Choice,

    #[yaserde(rename = "Xtnsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Xtnsn"))]
    pub xtnsn: Vec<Extension1>,
}

impl Validate for OrderInstructionStatusReportV05 {}


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

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

impl Validate for OrderOriginatorEligibility1Code {}



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

pub enum OrderStatus4Code {
    #[yaserde(rename = "PACK")]
    #[cfg_attr(feature = "serde", serde(rename = "PACK"))]
    Pack,
    #[yaserde(rename = "COSE")]
    #[cfg_attr(feature = "serde", serde(rename = "COSE"))]
    Cose,
    #[yaserde(rename = "STNP")]
    #[cfg_attr(feature = "serde", serde(rename = "STNP"))]
    Stnp,
    #[yaserde(rename = "RECE")]
    #[cfg_attr(feature = "serde", serde(rename = "RECE"))]
    Rece,
    #[yaserde(rename = "SETT")]
    #[cfg_attr(feature = "serde", serde(rename = "SETT"))]
    Sett,
    #[yaserde(rename = "CPNP")]
    #[cfg_attr(feature = "serde", serde(rename = "CPNP"))]
    Cpnp,
    #[yaserde(rename = "CNFC")]
    #[cfg_attr(feature = "serde", serde(rename = "CNFC"))]
    Cnfc,
    #[yaserde(rename = "DONE")]
    #[cfg_attr(feature = "serde", serde(rename = "DONE"))]
    Done,
    #[yaserde(rename = "DONF")]
    #[cfg_attr(feature = "serde", serde(rename = "DONF"))]
    Donf,
    #[yaserde(rename = "OPOD")]
    #[cfg_attr(feature = "serde", serde(rename = "OPOD"))]
    Opod,
    #[yaserde(rename = "IACO")]
    #[cfg_attr(feature = "serde", serde(rename = "IACO"))]
    Iaco,
    __Unknown__(String),
}

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

impl Validate for OrderStatus4Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.05")]
pub struct OrderStatus6Choice {
    #[yaserde(rename = "Sts")]
    #[cfg_attr(feature = "serde", serde(rename = "Sts"))]
    pub sts: Option<OrderStatus4Code>,
    #[yaserde(rename = "Canc")]
    #[cfg_attr(feature = "serde", serde(rename = "Canc"))]
    pub canc: Option<CancelledStatusReason16>,
    #[yaserde(rename = "CondlyAccptd")]
    #[cfg_attr(feature = "serde", serde(rename = "CondlyAccptd"))]
    pub condly_accptd: Option<ConditionallyAcceptedStatus3Choice>,
    #[yaserde(rename = "Rjctd")]
    #[cfg_attr(feature = "serde", serde(rename = "Rjctd"))]
    pub rjctd: Vec<RejectedStatus14>,
    #[yaserde(rename = "Sspd")]
    #[cfg_attr(feature = "serde", serde(rename = "Sspd"))]
    pub sspd: Option<SuspendedStatusReason4Choice>,
    #[yaserde(rename = "InRpr")]
    #[cfg_attr(feature = "serde", serde(rename = "InRpr"))]
    pub in_rpr: Option<InRepairStatusReason4Choice>,
    #[yaserde(rename = "PrtlySttld")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtlySttld"))]
    pub prtly_sttld: Option<PartiallySettledStatus10>,
}

impl Validate for OrderStatus6Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.05")]
pub struct OrderStatus7Choice {
    #[yaserde(rename = "Sts")]
    #[cfg_attr(feature = "serde", serde(rename = "Sts"))]
    pub sts: Option<OrderStatus4Code>,
    #[yaserde(rename = "Canc")]
    #[cfg_attr(feature = "serde", serde(rename = "Canc"))]
    pub canc: Option<CancelledStatusReason16>,
    #[yaserde(rename = "CondlyAccptd")]
    #[cfg_attr(feature = "serde", serde(rename = "CondlyAccptd"))]
    pub condly_accptd: Option<ConditionallyAcceptedStatus3Choice>,
    #[yaserde(rename = "Rjctd")]
    #[cfg_attr(feature = "serde", serde(rename = "Rjctd"))]
    pub rjctd: Vec<RejectedStatus14>,
    #[yaserde(rename = "Sspd")]
    #[cfg_attr(feature = "serde", serde(rename = "Sspd"))]
    pub sspd: Option<SuspendedStatusReason4Choice>,
    #[yaserde(rename = "InRpr")]
    #[cfg_attr(feature = "serde", serde(rename = "InRpr"))]
    pub in_rpr: Option<InRepairStatusReason4Choice>,
    #[yaserde(rename = "PrtlySttld")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtlySttld"))]
    pub prtly_sttld: Option<PartiallySettledStatus10>,
}

impl Validate for OrderStatus7Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.05")]
pub struct OrderStatus8Choice {
    #[yaserde(rename = "Sts")]
    #[cfg_attr(feature = "serde", serde(rename = "Sts"))]
    pub sts: Option<OrderStatus4Code>,
    #[yaserde(rename = "Canc")]
    #[cfg_attr(feature = "serde", serde(rename = "Canc"))]
    pub canc: Option<CancelledStatusReason16>,
    #[yaserde(rename = "CondlyAccptd")]
    #[cfg_attr(feature = "serde", serde(rename = "CondlyAccptd"))]
    pub condly_accptd: Option<ConditionallyAcceptedStatus3Choice>,
    #[yaserde(rename = "Rjctd")]
    #[cfg_attr(feature = "serde", serde(rename = "Rjctd"))]
    pub rjctd: Vec<RejectedStatus14>,
    #[yaserde(rename = "Sspd")]
    #[cfg_attr(feature = "serde", serde(rename = "Sspd"))]
    pub sspd: Option<SuspendedStatusReason4Choice>,
    #[yaserde(rename = "PrtlySttld")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtlySttld"))]
    pub prtly_sttld: Option<PartiallySettledStatus10>,
}

impl Validate for OrderStatus8Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.05")]
pub struct OrderStatusAndReason11 {
    #[yaserde(rename = "MstrRef")]
    #[cfg_attr(feature = "serde", serde(rename = "MstrRef"))]
    pub mstr_ref: Max35Text,

    #[yaserde(rename = "OrdrSts")]
    #[cfg_attr(feature = "serde", serde(rename = "OrdrSts"))]
    pub ordr_sts: OrderStatus8Choice,

    #[yaserde(rename = "StsInitr")]
    #[cfg_attr(feature = "serde", serde(rename = "StsInitr"))]
    pub sts_initr: PartyIdentification139,
}

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

impl Validate for PartiallySettled21Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.05")]
pub struct PartiallySettledStatus10 {
    #[yaserde(rename = "Rsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
    pub rsn: PartiallySettled21Choice,

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

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




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.05")]
pub struct PartyIdentification139 {
    #[yaserde(rename = "Pty")]
    #[cfg_attr(feature = "serde", serde(rename = "Pty"))]
    pub pty: PartyIdentification125Choice,

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

impl Validate for PartyIdentification139 {}


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

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

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

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

pub enum RedemptionCompletion1Code {
    #[yaserde(rename = "RED0")]
    #[cfg_attr(feature = "serde", serde(rename = "RED0"))]
    Red0,
    #[yaserde(rename = "RED1")]
    #[cfg_attr(feature = "serde", serde(rename = "RED1"))]
    Red1,
    __Unknown__(String),
}

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

impl Validate for RedemptionCompletion1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.05")]
pub struct References64Choice {
    #[yaserde(rename = "RltdRef")]
    #[cfg_attr(feature = "serde", serde(rename = "RltdRef"))]
    pub rltd_ref: Vec<AdditionalReference10>,
    #[yaserde(rename = "OthrRef")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrRef"))]
    pub othr_ref: Vec<AdditionalReference10>,
}

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

impl Validate for RejectedReason67Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.05")]
pub struct RejectedStatus14 {
    #[yaserde(rename = "Rsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
    pub rsn: RejectedReason67Choice,

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

impl Validate for RejectedStatus14 {}


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

pub enum RejectedStatusReason15Code {
    #[yaserde(rename = "DDAT")]
    #[cfg_attr(feature = "serde", serde(rename = "DDAT"))]
    Ddat,
    #[yaserde(rename = "POIN")]
    #[cfg_attr(feature = "serde", serde(rename = "POIN"))]
    Poin,
    #[yaserde(rename = "ICAG")]
    #[cfg_attr(feature = "serde", serde(rename = "ICAG"))]
    Icag,
    #[yaserde(rename = "IDDB")]
    #[cfg_attr(feature = "serde", serde(rename = "IDDB"))]
    Iddb,
    #[yaserde(rename = "INTE")]
    #[cfg_attr(feature = "serde", serde(rename = "INTE"))]
    Inte,
    #[yaserde(rename = "SAFE")]
    #[cfg_attr(feature = "serde", serde(rename = "SAFE"))]
    Safe,
    #[yaserde(rename = "IPAY")]
    #[cfg_attr(feature = "serde", serde(rename = "IPAY"))]
    Ipay,
    #[yaserde(rename = "ICTR")]
    #[cfg_attr(feature = "serde", serde(rename = "ICTR"))]
    Ictr,
    #[yaserde(rename = "DEPT")]
    #[cfg_attr(feature = "serde", serde(rename = "DEPT"))]
    Dept,
    #[yaserde(rename = "IVAG")]
    #[cfg_attr(feature = "serde", serde(rename = "IVAG"))]
    Ivag,
    #[yaserde(rename = "ISAF")]
    #[cfg_attr(feature = "serde", serde(rename = "ISAF"))]
    Isaf,
    #[yaserde(rename = "DFOR")]
    #[cfg_attr(feature = "serde", serde(rename = "DFOR"))]
    Dfor,
    #[yaserde(rename = "DSEC")]
    #[cfg_attr(feature = "serde", serde(rename = "DSEC"))]
    Dsec,
    #[yaserde(rename = "BLCA")]
    #[cfg_attr(feature = "serde", serde(rename = "BLCA"))]
    Blca,
    #[yaserde(rename = "BLTR")]
    #[cfg_attr(feature = "serde", serde(rename = "BLTR"))]
    Bltr,
    #[yaserde(rename = "DOCC")]
    #[cfg_attr(feature = "serde", serde(rename = "DOCC"))]
    Docc,
    #[yaserde(rename = "MONY")]
    #[cfg_attr(feature = "serde", serde(rename = "MONY"))]
    Mony,
    #[yaserde(rename = "SECU")]
    #[cfg_attr(feature = "serde", serde(rename = "SECU"))]
    Secu,
    #[yaserde(rename = "IDNA")]
    #[cfg_attr(feature = "serde", serde(rename = "IDNA"))]
    Idna,
    #[yaserde(rename = "UWAI")]
    #[cfg_attr(feature = "serde", serde(rename = "UWAI"))]
    Uwai,
    #[yaserde(rename = "UDCY")]
    #[cfg_attr(feature = "serde", serde(rename = "UDCY"))]
    Udcy,
    #[yaserde(rename = "UNAV")]
    #[cfg_attr(feature = "serde", serde(rename = "UNAV"))]
    Unav,
    #[yaserde(rename = "UPAY")]
    #[cfg_attr(feature = "serde", serde(rename = "UPAY"))]
    Upay,
    #[yaserde(rename = "URSC")]
    #[cfg_attr(feature = "serde", serde(rename = "URSC"))]
    Ursc,
    #[yaserde(rename = "SHIG")]
    #[cfg_attr(feature = "serde", serde(rename = "SHIG"))]
    Shig,
    #[yaserde(rename = "SLOW")]
    #[cfg_attr(feature = "serde", serde(rename = "SLOW"))]
    Slow,
    #[yaserde(rename = "ULNK")]
    #[cfg_attr(feature = "serde", serde(rename = "ULNK"))]
    Ulnk,
    #[yaserde(rename = "DLVY")]
    #[cfg_attr(feature = "serde", serde(rename = "DLVY"))]
    Dlvy,
    #[yaserde(rename = "ORRF")]
    #[cfg_attr(feature = "serde", serde(rename = "ORRF"))]
    Orrf,
    #[yaserde(rename = "IPAC")]
    #[cfg_attr(feature = "serde", serde(rename = "IPAC"))]
    Ipac,
    #[yaserde(rename = "IOTP")]
    #[cfg_attr(feature = "serde", serde(rename = "IOTP"))]
    Iotp,
    #[yaserde(rename = "NSLA")]
    #[cfg_attr(feature = "serde", serde(rename = "NSLA"))]
    Nsla,
    #[yaserde(rename = "CUTO")]
    #[cfg_attr(feature = "serde", serde(rename = "CUTO"))]
    Cuto,
    #[yaserde(rename = "DQUA")]
    #[cfg_attr(feature = "serde", serde(rename = "DQUA"))]
    Dqua,
    #[yaserde(rename = "LATE")]
    #[cfg_attr(feature = "serde", serde(rename = "LATE"))]
    Late,
    #[yaserde(rename = "ADEA")]
    #[cfg_attr(feature = "serde", serde(rename = "ADEA"))]
    Adea,
    #[yaserde(rename = "DTRD")]
    #[cfg_attr(feature = "serde", serde(rename = "DTRD"))]
    Dtrd,
    #[yaserde(rename = "FEEE")]
    #[cfg_attr(feature = "serde", serde(rename = "FEEE"))]
    Feee,
    #[yaserde(rename = "IEXE")]
    #[cfg_attr(feature = "serde", serde(rename = "IEXE"))]
    Iexe,
    #[yaserde(rename = "NCRR")]
    #[cfg_attr(feature = "serde", serde(rename = "NCRR"))]
    Ncrr,
    #[yaserde(rename = "PHYS")]
    #[cfg_attr(feature = "serde", serde(rename = "PHYS"))]
    Phys,
    #[yaserde(rename = "PLCE")]
    #[cfg_attr(feature = "serde", serde(rename = "PLCE"))]
    Plce,
    #[yaserde(rename = "SETR")]
    #[cfg_attr(feature = "serde", serde(rename = "SETR"))]
    Setr,
    #[yaserde(rename = "RTGS")]
    #[cfg_attr(feature = "serde", serde(rename = "RTGS"))]
    Rtgs,
    #[yaserde(rename = "CASH")]
    #[cfg_attr(feature = "serde", serde(rename = "CASH"))]
    Cash,
    #[yaserde(rename = "DMON")]
    #[cfg_attr(feature = "serde", serde(rename = "DMON"))]
    Dmon,
    #[yaserde(rename = "BMIN")]
    #[cfg_attr(feature = "serde", serde(rename = "BMIN"))]
    Bmin,
    #[yaserde(rename = "INSU")]
    #[cfg_attr(feature = "serde", serde(rename = "INSU"))]
    Insu,
    #[yaserde(rename = "PRCT")]
    #[cfg_attr(feature = "serde", serde(rename = "PRCT"))]
    Prct,
    #[yaserde(rename = "BMRA")]
    #[cfg_attr(feature = "serde", serde(rename = "BMRA"))]
    Bmra,
    #[yaserde(rename = "BMRV")]
    #[cfg_attr(feature = "serde", serde(rename = "BMRV"))]
    Bmrv,
    #[yaserde(rename = "LOCK")]
    #[cfg_attr(feature = "serde", serde(rename = "LOCK"))]
    Lock,
    #[yaserde(rename = "ILLI")]
    #[cfg_attr(feature = "serde", serde(rename = "ILLI"))]
    Illi,
    #[yaserde(rename = "CLOS")]
    #[cfg_attr(feature = "serde", serde(rename = "CLOS"))]
    Clos,
    #[yaserde(rename = "UNSC")]
    #[cfg_attr(feature = "serde", serde(rename = "UNSC"))]
    Unsc,
    __Unknown__(String),
}

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

impl Validate for RejectedStatusReason15Code {}



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

impl Validate for Sedolidentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.05")]
pub struct SecurityIdentification46Choice {
    #[yaserde(rename = "ISIN")]
    #[cfg_attr(feature = "serde", serde(rename = "ISIN"))]
    pub isin: Option<Isinoct2015Identifier>,
    #[yaserde(rename = "SEDOL")]
    #[cfg_attr(feature = "serde", serde(rename = "SEDOL"))]
    pub sedol: Option<Sedolidentifier>,
    #[yaserde(rename = "CUSIP")]
    #[cfg_attr(feature = "serde", serde(rename = "CUSIP"))]
    pub cusip: Option<Cusipidentifier>,
    #[yaserde(rename = "RIC")]
    #[cfg_attr(feature = "serde", serde(rename = "RIC"))]
    pub ric: Option<Ricidentifier>,
    #[yaserde(rename = "TckrSymb")]
    #[cfg_attr(feature = "serde", serde(rename = "TckrSymb"))]
    pub tckr_symb: Option<TickerIdentifier>,
    #[yaserde(rename = "Blmbrg")]
    #[cfg_attr(feature = "serde", serde(rename = "Blmbrg"))]
    pub blmbrg: Option<Bloomberg2Identifier>,
    #[yaserde(rename = "CTA")]
    #[cfg_attr(feature = "serde", serde(rename = "CTA"))]
    pub cta: Option<ConsolidatedTapeAssociationIdentifier>,
    #[yaserde(rename = "QUICK")]
    #[cfg_attr(feature = "serde", serde(rename = "QUICK"))]
    pub quick: Option<Quickidentifier>,
    #[yaserde(rename = "Wrtppr")]
    #[cfg_attr(feature = "serde", serde(rename = "Wrtppr"))]
    pub wrtppr: Option<WertpapierIdentifier>,
    #[yaserde(rename = "Dtch")]
    #[cfg_attr(feature = "serde", serde(rename = "Dtch"))]
    pub dtch: Option<DutchIdentifier>,
    #[yaserde(rename = "Vlrn")]
    #[cfg_attr(feature = "serde", serde(rename = "Vlrn"))]
    pub vlrn: Option<ValorenIdentifier>,
    #[yaserde(rename = "SCVM")]
    #[cfg_attr(feature = "serde", serde(rename = "SCVM"))]
    pub scvm: Option<SicovamIdentifier>,
    #[yaserde(rename = "Belgn")]
    #[cfg_attr(feature = "serde", serde(rename = "Belgn"))]
    pub belgn: Option<BelgianIdentifier>,
    #[yaserde(rename = "Cmon")]
    #[cfg_attr(feature = "serde", serde(rename = "Cmon"))]
    pub cmon: Option<EuroclearClearstreamIdentifier>,
    #[yaserde(rename = "DTI")]
    #[cfg_attr(feature = "serde", serde(rename = "DTI"))]
    pub dti: Option<Dti2024Identifier>,
    #[yaserde(rename = "OthrPrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrPrtryId"))]
    pub othr_prtry_id: Option<AlternateSecurityIdentification7>,
}

impl Validate for SecurityIdentification46Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.05")]
pub struct Series1 {
    #[yaserde(rename = "SrsDt")]
    #[cfg_attr(feature = "serde", serde(rename = "SrsDt"))]
    pub srs_dt: DateFormat42Choice,

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

impl Validate for Series1 {}


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

pub enum SettledStatusReason2Code {
    #[yaserde(rename = "CPST")]
    #[cfg_attr(feature = "serde", serde(rename = "CPST"))]
    Cpst,
    #[yaserde(rename = "GATM")]
    #[cfg_attr(feature = "serde", serde(rename = "GATM"))]
    Gatm,
    #[yaserde(rename = "GAT1")]
    #[cfg_attr(feature = "serde", serde(rename = "GAT1"))]
    Gat1,
    #[yaserde(rename = "UCPS")]
    #[cfg_attr(feature = "serde", serde(rename = "UCPS"))]
    Ucps,
    #[yaserde(rename = "UPST")]
    #[cfg_attr(feature = "serde", serde(rename = "UPST"))]
    Upst,
    __Unknown__(String),
}

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

impl Validate for SettledStatusReason2Code {}



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

impl Validate for SicovamIdentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.05")]
pub struct Status40Choice {
    #[yaserde(rename = "OrdrDtlsRpt")]
    #[cfg_attr(feature = "serde", serde(rename = "OrdrDtlsRpt"))]
    pub ordr_dtls_rpt: Option<OrderStatusAndReason11>,
    #[yaserde(rename = "IndvOrdrDtlsRpt")]
    #[cfg_attr(feature = "serde", serde(rename = "IndvOrdrDtlsRpt"))]
    pub indv_ordr_dtls_rpt: Vec<IndividualOrderStatusAndReason9>,
    #[yaserde(rename = "SwtchOrdrDtlsRpt")]
    #[cfg_attr(feature = "serde", serde(rename = "SwtchOrdrDtlsRpt"))]
    pub swtch_ordr_dtls_rpt: Vec<SwitchOrderStatusAndReason3>,
}

impl Validate for Status40Choice {}




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

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

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

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

impl Validate for SubAccount6 {}


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

pub enum SuspendedStatusReason3Code {
    #[yaserde(rename = "PRIC")]
    #[cfg_attr(feature = "serde", serde(rename = "PRIC"))]
    Pric,
    #[yaserde(rename = "FLOW")]
    #[cfg_attr(feature = "serde", serde(rename = "FLOW"))]
    Flow,
    __Unknown__(String),
}

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

impl Validate for SuspendedStatusReason3Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.05")]
pub struct SuspendedStatusReason4 {
    #[yaserde(rename = "Rsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
    pub rsn: SuspendedStatusReason5Choice,

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

impl Validate for SuspendedStatusReason4 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.05")]
pub struct SuspendedStatusReason4Choice {
    #[yaserde(rename = "NoSpcfdRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "NoSpcfdRsn"))]
    pub no_spcfd_rsn: Option<NoReasonCode>,
    #[yaserde(rename = "RsnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "RsnDtls"))]
    pub rsn_dtls: Vec<SuspendedStatusReason4>,
}

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

impl Validate for SuspendedStatusReason5Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.05")]
pub struct SwitchLegReferences3 {
    #[yaserde(rename = "LegId")]
    #[cfg_attr(feature = "serde", serde(rename = "LegId"))]
    pub leg_id: LegIdentification1Choice,

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

    #[yaserde(rename = "RprdFee")]
    #[cfg_attr(feature = "serde", serde(rename = "RprdFee"))]
    pub rprd_fee: Vec<Fee12>,

    #[yaserde(rename = "InvstmtAcctDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "InvstmtAcctDtls"))]
    pub invstmt_acct_dtls: InvestmentAccount81,

    #[yaserde(rename = "FinInstrmDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrmDtls"))]
    pub fin_instrm_dtls: FinancialInstrument107,
}

impl Validate for SwitchLegReferences3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.05")]
pub struct SwitchOrderStatusAndReason3 {
    #[yaserde(rename = "MstrRef")]
    #[cfg_attr(feature = "serde", serde(rename = "MstrRef"))]
    pub mstr_ref: Max35Text,

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

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

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

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

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

    #[yaserde(rename = "OrdrSts")]
    #[cfg_attr(feature = "serde", serde(rename = "OrdrSts"))]
    pub ordr_sts: OrderStatus7Choice,

    #[yaserde(rename = "LegInf")]
    #[cfg_attr(feature = "serde", serde(rename = "LegInf"))]
    pub leg_inf: Vec<SwitchLegReferences3>,

    #[yaserde(rename = "StsInitr")]
    #[cfg_attr(feature = "serde", serde(rename = "StsInitr"))]
    pub sts_initr: PartyIdentification139,

    #[yaserde(rename = "OrdrData")]
    #[cfg_attr(feature = "serde", serde(rename = "OrdrData"))]
    pub ordr_data: FundOrderData6,

    #[yaserde(rename = "NewDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "NewDtls"))]
    pub new_dtls: ExpectedExecution6,
}

impl Validate for SwitchOrderStatusAndReason3 {}


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

impl Validate for TickerIdentifier {
    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 ValorenIdentifier (pub String);
crate::simple_type!(ValorenIdentifier);

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

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

impl Validate for YesNoIndicator {}

impl crate::MxMessage for Document {
    const BUSINESS_AREA: crate::BusinessArea = crate::BusinessArea::setr;
    const FUNCTIONALITY: &'static str = "016";
    const VARIANT: &'static str = "001";
    const VERSION: &'static str = "05";
    const MESSAGE_NAME: &'static str = "setr.016.001.05";
    const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:setr.016.001.05";
}