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:sese.039.002.06")]
pub struct AcknowledgedAcceptedStatus30Choice {
    #[yaserde(rename = "NoSpcfdRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "NoSpcfdRsn"))]
    pub no_spcfd_rsn: Option<NoReasonCode>,
    #[yaserde(rename = "Rsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
    pub rsn: Vec<AcknowledgementReason18>,
}

impl Validate for AcknowledgedAcceptedStatus30Choice {}




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

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

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

impl Validate for AcknowledgementReason21Choice {}




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

pub enum AcknowledgementReason6Code {
    #[yaserde(rename = "ADEA")]
    #[cfg_attr(feature = "serde", serde(rename = "ADEA"))]
    Adea,
    #[yaserde(rename = "SMPG")]
    #[cfg_attr(feature = "serde", serde(rename = "SMPG"))]
    Smpg,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "NSTP")]
    #[cfg_attr(feature = "serde", serde(rename = "NSTP"))]
    Nstp,
    #[yaserde(rename = "LATE")]
    #[cfg_attr(feature = "serde", serde(rename = "LATE"))]
    Late,
    __Unknown__(String),
}

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

impl Validate for AcknowledgementReason6Code {}



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

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

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

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

impl Validate for AmountAndDirection67 {}


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

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

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

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

impl Validate for BlockChainAddressWallet7 {}


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

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

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

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

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

impl Validate for DateAndDateTime2Choice {}




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

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

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

impl Validate for DateType3Code {}



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

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

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

impl Validate for DateType4Code {}



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

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

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

impl Validate for DeliveryReceiptType2Code {}



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

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

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

impl Validate for DeniedReason24Choice {}




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

pub enum DeniedReason6Code {
    #[yaserde(rename = "ADEA")]
    #[cfg_attr(feature = "serde", serde(rename = "ADEA"))]
    Adea,
    #[yaserde(rename = "CDCY")]
    #[cfg_attr(feature = "serde", serde(rename = "CDCY"))]
    Cdcy,
    #[yaserde(rename = "CDRE")]
    #[cfg_attr(feature = "serde", serde(rename = "CDRE"))]
    Cdre,
    #[yaserde(rename = "DCAN")]
    #[cfg_attr(feature = "serde", serde(rename = "DCAN"))]
    Dcan,
    #[yaserde(rename = "DSET")]
    #[cfg_attr(feature = "serde", serde(rename = "DSET"))]
    Dset,
    #[yaserde(rename = "DPRG")]
    #[cfg_attr(feature = "serde", serde(rename = "DPRG"))]
    Dprg,
    #[yaserde(rename = "DREP")]
    #[cfg_attr(feature = "serde", serde(rename = "DREP"))]
    Drep,
    #[yaserde(rename = "LATE")]
    #[cfg_attr(feature = "serde", serde(rename = "LATE"))]
    Late,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "CDRG")]
    #[cfg_attr(feature = "serde", serde(rename = "CDRG"))]
    Cdrg,
    __Unknown__(String),
}

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

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

impl Validate for DeniedStatus19Choice {}




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

impl Validate for Document {}


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

impl Validate for ExternalFinancialInstrumentIdentificationType1Code {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 4 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 4 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.039.002.06")]
pub struct FinancialInstrumentQuantity36Choice {
    #[yaserde(rename = "Unit")]
    #[cfg_attr(feature = "serde", serde(rename = "Unit"))]
    pub unit: Option<RestrictedFINDecimalNumber>,
    #[yaserde(rename = "FaceAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "FaceAmt"))]
    pub face_amt: Option<RestrictedFINImpliedCurrencyAndAmount>,
    #[yaserde(rename = "AmtsdVal")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtsdVal"))]
    pub amtsd_val: Option<RestrictedFINImpliedCurrencyAndAmount>,
    #[yaserde(rename = "DgtlTknUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "DgtlTknUnit"))]
    pub dgtl_tkn_unit: Option<Max30DecimalNumber>,
}

impl Validate for FinancialInstrumentQuantity36Choice {}




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

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

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

impl Validate for GenericIdentification47 {}


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

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

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

impl Validate for GenericIdentification84 {}


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

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

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

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

impl Validate for IdentificationSource4Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
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)]
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 Max4AlphaNumericText (pub String);
crate::simple_type!(Max4AlphaNumericText);

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

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

impl Validate for Max70Text {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 70 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 70 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.039.002.06")]
pub struct ModificationProcessingStatus11Choice {
    #[yaserde(rename = "AckdAccptd")]
    #[cfg_attr(feature = "serde", serde(rename = "AckdAccptd"))]
    pub ackd_accptd: Option<AcknowledgedAcceptedStatus30Choice>,
    #[yaserde(rename = "PdgPrcg")]
    #[cfg_attr(feature = "serde", serde(rename = "PdgPrcg"))]
    pub pdg_prcg: Option<PendingProcessingStatus16Choice>,
    #[yaserde(rename = "Dnd")]
    #[cfg_attr(feature = "serde", serde(rename = "Dnd"))]
    pub dnd: Option<DeniedStatus19Choice>,
    #[yaserde(rename = "Rjctd")]
    #[cfg_attr(feature = "serde", serde(rename = "Rjctd"))]
    pub rjctd: Option<RejectionStatus42Choice>,
    #[yaserde(rename = "Rprd")]
    #[cfg_attr(feature = "serde", serde(rename = "Rprd"))]
    pub rprd: Option<RepairStatus17Choice>,
    #[yaserde(rename = "Modfd")]
    #[cfg_attr(feature = "serde", serde(rename = "Modfd"))]
    pub modfd: Option<ModificationStatus5Choice>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<ProprietaryStatusAndReason7>,
}

impl Validate for ModificationProcessingStatus11Choice {}




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

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

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

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

impl Validate for ModificationStatus5Choice {}




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

pub enum ModifiedStatusReason1Code {
    #[yaserde(rename = "MDBY")]
    #[cfg_attr(feature = "serde", serde(rename = "MDBY"))]
    Mdby,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    __Unknown__(String),
}

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

impl Validate for ModifiedStatusReason1Code {}



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

impl Validate for NameAndAddress12 {}


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

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:sese.039.002.06")]
pub struct OriginalAndCurrentQuantities4 {
    #[yaserde(rename = "FaceAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "FaceAmt"))]
    pub face_amt: RestrictedFINImpliedCurrencyAndAmount,

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

impl Validate for OriginalAndCurrentQuantities4 {}


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

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

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

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

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

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

impl Validate for PartyIdentification145Choice {}




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

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

impl Validate for PartyIdentification156 {}


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

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

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

impl Validate for PartyIdentification176Choice {}




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

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

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

impl Validate for PartyIdentification191 {}


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

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

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

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

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

impl Validate for PartyIdentificationAndAccount215 {}


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

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

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

impl Validate for PendingProcessingReason15Choice {}




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

pub enum PendingProcessingReason3Code {
    #[yaserde(rename = "ADEA")]
    #[cfg_attr(feature = "serde", serde(rename = "ADEA"))]
    Adea,
    #[yaserde(rename = "BLOC")]
    #[cfg_attr(feature = "serde", serde(rename = "BLOC"))]
    Bloc,
    #[yaserde(rename = "MUNO")]
    #[cfg_attr(feature = "serde", serde(rename = "MUNO"))]
    Muno,
    #[yaserde(rename = "NEXT")]
    #[cfg_attr(feature = "serde", serde(rename = "NEXT"))]
    Next,
    #[yaserde(rename = "MINO")]
    #[cfg_attr(feature = "serde", serde(rename = "MINO"))]
    Mino,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "DENO")]
    #[cfg_attr(feature = "serde", serde(rename = "DENO"))]
    Deno,
    #[yaserde(rename = "CERT")]
    #[cfg_attr(feature = "serde", serde(rename = "CERT"))]
    Cert,
    __Unknown__(String),
}

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

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

impl Validate for PendingProcessingStatus16Choice {}




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

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

impl Validate for ProprietaryReason5 {}


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

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

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

impl Validate for Quantity54Choice {}




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

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

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

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

impl Validate for RejectionReason48Choice {}




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

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

impl Validate for RejectionReason63 {}


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

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

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

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

impl Validate for RejectionStatus42Choice {}




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

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

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

impl Validate for RepairReason14Choice {}




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

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

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

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

impl Validate for RepairStatus17Choice {}




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

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

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

impl Validate for RestrictedFINActiveCurrencyAndAmount {}


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

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

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

impl Validate for RestrictedFINActiveOrHistoricCurrencyAndAmount {}


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Validate for SecuritiesAccount30 {}


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

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

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

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

    #[yaserde(rename = "TxId")]
    #[cfg_attr(feature = "serde", serde(rename = "TxId"))]
    pub tx_id: TransactionIdentifications37,

    #[yaserde(rename = "ModPrcgSts")]
    #[cfg_attr(feature = "serde", serde(rename = "ModPrcgSts"))]
    pub mod_prcg_sts: ModificationProcessingStatus11Choice,

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

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

impl Validate for SecuritiesSettlementTransactionModificationRequestStatusAdvice002V06 {}


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

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

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

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

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

impl Validate for SettlementDateCode11Choice {}




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

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

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

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

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

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

impl Validate for SettlementParties109 {}


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

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

impl Validate for SupplementaryData1 {}


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

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

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

impl Validate for TradeDateCode4Choice {}




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

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

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

    #[yaserde(rename = "SttlmQty")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmQty"))]
    pub sttlm_qty: Quantity54Choice,

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

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

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

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

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

    #[yaserde(rename = "Invstr")]
    #[cfg_attr(feature = "serde", serde(rename = "Invstr"))]
    pub invstr: PartyIdentification170,
}

impl Validate for TransactionDetails158 {}


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

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

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

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

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

impl Validate for TransactionIdentifications37 {}

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