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

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

    #[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 = "FinInstrmId")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrmId"))]
    pub fin_instrm_id: SecurityIdentification20,

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

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

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

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

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

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

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

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

impl Validate for AdditionalInformation28 {}


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

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

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

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

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

impl Validate for AutomaticBorrowing11Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.030.002.09")]
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 Cfioct2015Identifier (pub String);
crate::simple_type!(Cfioct2015Identifier);

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

impl Validate for ClassificationType33Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.030.002.09")]
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:sese.030.002.09")]
pub struct Document {
    #[yaserde(rename = "SctiesSttlmCondsModReq")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesSttlmCondsModReq"))]
    pub scties_sttlm_conds_mod_req: SecuritiesSettlementConditionsModificationRequest002V09,
}

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

impl Validate for DocumentNumber16Choice {}




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

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

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

impl Validate for Exact4NumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
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.030.002.09")]
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.030.002.09")]
pub struct GenericIdentification163 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

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

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

impl Validate for GenericIdentification163 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.030.002.09")]
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.030.002.09")]
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.030.002.09")]
pub struct GenericIdentification86 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: RestrictedFINXMax30Text,

    #[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 GenericIdentification86 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.030.002.09")]
pub struct HoldIndicator7 {
    #[yaserde(rename = "Ind")]
    #[cfg_attr(feature = "serde", serde(rename = "Ind"))]
    pub ind: YesNoIndicator,

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

impl Validate for HoldIndicator7 {}


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

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

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

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

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

pub enum LinkageType1Code {
    #[yaserde(rename = "LINK")]
    #[cfg_attr(feature = "serde", serde(rename = "LINK"))]
    Link,
    #[yaserde(rename = "UNLK")]
    #[cfg_attr(feature = "serde", serde(rename = "UNLK"))]
    Unlk,
    #[yaserde(rename = "SOFT")]
    #[cfg_attr(feature = "serde", serde(rename = "SOFT"))]
    Soft,
    __Unknown__(String),
}

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

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

impl Validate for LinkageType4Choice {}




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

    #[yaserde(rename = "MsgNb")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgNb"))]
    pub msg_nb: DocumentNumber16Choice,

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

    #[yaserde(rename = "RefOwnr")]
    #[cfg_attr(feature = "serde", serde(rename = "RefOwnr"))]
    pub ref_ownr: PartyIdentification136Choice,
}

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

impl Validate for MatchingDenied4Choice {}




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

pub enum MatchingProcess1Code {
    #[yaserde(rename = "UNMT")]
    #[cfg_attr(feature = "serde", serde(rename = "UNMT"))]
    Unmt,
    #[yaserde(rename = "MTRE")]
    #[cfg_attr(feature = "serde", serde(rename = "MTRE"))]
    Mtre,
    __Unknown__(String),
}

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

impl Validate for MatchingProcess1Code {}



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

impl Validate for PartyIdentification157 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.030.002.09")]
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.030.002.09")]
pub struct PriorityNumeric5Choice {
    #[yaserde(rename = "Nmrc")]
    #[cfg_attr(feature = "serde", serde(rename = "Nmrc"))]
    pub nmrc: Option<Exact4NumericText>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

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

impl Validate for ProcessingPosition18Choice {}




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

pub enum ProcessingPosition4Code {
    #[yaserde(rename = "AFTE")]
    #[cfg_attr(feature = "serde", serde(rename = "AFTE"))]
    Afte,
    #[yaserde(rename = "BEFO")]
    #[cfg_attr(feature = "serde", serde(rename = "BEFO"))]
    Befo,
    #[yaserde(rename = "WITH")]
    #[cfg_attr(feature = "serde", serde(rename = "WITH"))]
    With,
    __Unknown__(String),
}

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

impl Validate for ProcessingPosition4Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.030.002.09")]
pub struct References28 {
    #[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 = "CtrPtyMktInfrstrctrTxId")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrPtyMktInfrstrctrTxId"))]
    pub ctr_pty_mkt_infrstrctr_tx_id: RestrictedFINXMax16Text,

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

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

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

    #[yaserde(rename = "TradId")]
    #[cfg_attr(feature = "serde", serde(rename = "TradId"))]
    pub trad_id: RestrictedFINXMax52Text,
}

impl Validate for References28 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.030.002.09")]
pub struct References76Choice {
    #[yaserde(rename = "SctiesSttlmTxId")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesSttlmTxId"))]
    pub scties_sttlm_tx_id: Option<RestrictedFINXMax16Text>,
    #[yaserde(rename = "IntraPosMvmntId")]
    #[cfg_attr(feature = "serde", serde(rename = "IntraPosMvmntId"))]
    pub intra_pos_mvmnt_id: Option<RestrictedFINXMax16Text>,
    #[yaserde(rename = "IntraBalMvmntId")]
    #[cfg_attr(feature = "serde", serde(rename = "IntraBalMvmntId"))]
    pub intra_bal_mvmnt_id: Option<RestrictedFINXMax16Text>,
    #[yaserde(rename = "AcctSvcrTxId")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctSvcrTxId"))]
    pub acct_svcr_tx_id: Option<RestrictedFINXMax16Text>,
    #[yaserde(rename = "MktInfrstrctrTxId")]
    #[cfg_attr(feature = "serde", serde(rename = "MktInfrstrctrTxId"))]
    pub mkt_infrstrctr_tx_id: Option<RestrictedFINXMax16Text>,
    #[yaserde(rename = "CtrPtyMktInfrstrctrTxId")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrPtyMktInfrstrctrTxId"))]
    pub ctr_pty_mkt_infrstrctr_tx_id: Option<RestrictedFINXMax16Text>,
    #[yaserde(rename = "PoolId")]
    #[cfg_attr(feature = "serde", serde(rename = "PoolId"))]
    pub pool_id: Option<RestrictedFINXMax16Text>,
    #[yaserde(rename = "CmonId")]
    #[cfg_attr(feature = "serde", serde(rename = "CmonId"))]
    pub cmon_id: Option<RestrictedFINXMax16Text>,
    #[yaserde(rename = "TradId")]
    #[cfg_attr(feature = "serde", serde(rename = "TradId"))]
    pub trad_id: Option<RestrictedFINXMax52Text>,
    #[yaserde(rename = "OthrTxId")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrTxId"))]
    pub othr_tx_id: Option<RestrictedFINXMax16Text>,
}

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

impl Validate for Registration12Choice {}




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

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

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

impl Validate for Registration2Code {}



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

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

impl Validate for RegistrationReason6 {}


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

    #[yaserde(rename = "RstrctnRef")]
    #[cfg_attr(feature = "serde", serde(rename = "RstrctnRef"))]
    pub rstrctn_ref: Vec<RestrictionIdentification2>,

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

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

    #[yaserde(rename = "Lkg")]
    #[cfg_attr(feature = "serde", serde(rename = "Lkg"))]
    pub lkg: LinkageType4Choice,

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

    #[yaserde(rename = "OthrPrcg")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrPrcg"))]
    pub othr_prcg: Vec<GenericIdentification47>,

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

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

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

    #[yaserde(rename = "MtchgDnl")]
    #[cfg_attr(feature = "serde", serde(rename = "MtchgDnl"))]
    pub mtchg_dnl: MatchingDenied4Choice,

    #[yaserde(rename = "UnltrlSplt")]
    #[cfg_attr(feature = "serde", serde(rename = "UnltrlSplt"))]
    pub unltrl_splt: UnilateralSplit4Choice,

    #[yaserde(rename = "Lnkgs")]
    #[cfg_attr(feature = "serde", serde(rename = "Lnkgs"))]
    pub lnkgs: Vec<Linkages66>,
}

impl Validate for RequestDetails29 {}


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

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

impl Validate for RestrictedFINXMax52Text {
    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() > 52 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 52 \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.030.002.09")]
pub struct RestrictionIdentification2 {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: RestrictionReference1Code,

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

impl Validate for RestrictionIdentification2 {}


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

pub enum RestrictionReference1Code {
    #[yaserde(rename = "ADDC")]
    #[cfg_attr(feature = "serde", serde(rename = "ADDC"))]
    Addc,
    #[yaserde(rename = "ADDS")]
    #[cfg_attr(feature = "serde", serde(rename = "ADDS"))]
    Adds,
    #[yaserde(rename = "REMC")]
    #[cfg_attr(feature = "serde", serde(rename = "REMC"))]
    Remc,
    #[yaserde(rename = "REMS")]
    #[cfg_attr(feature = "serde", serde(rename = "REMS"))]
    Rems,
    __Unknown__(String),
}

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

impl Validate for RestrictionReference1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.030.002.09")]
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.030.002.09")]
pub struct SecuritiesRTGS5Choice {
    #[yaserde(rename = "Ind")]
    #[cfg_attr(feature = "serde", serde(rename = "Ind"))]
    pub ind: Option<YesNoIndicator>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for SecuritiesRTGS5Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.030.002.09")]
pub struct SecuritiesSettlementConditionsModificationRequest002V09 {
    #[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 = "ReqDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "ReqDtls"))]
    pub req_dtls: Vec<RequestDetails29>,

    #[yaserde(rename = "AddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
    pub addtl_inf: Vec<AdditionalInformation28>,

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

impl Validate for SecuritiesSettlementConditionsModificationRequest002V09 {}


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

pub enum SecuritiesTransactionType5Code {
    #[yaserde(rename = "TRAD")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAD"))]
    Trad,
    __Unknown__(String),
}

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

impl Validate for SecuritiesTransactionType5Code {}



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

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

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

impl Validate for SettlementTransactionCondition5Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.030.002.09")]
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.030.002.09")]
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.030.002.09")]
pub struct UnilateralSplit4Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<SecuritiesTransactionType5Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for UnilateralSplit4Choice {}




#[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::sese;
    const FUNCTIONALITY: &'static str = "030";
    const VARIANT: &'static str = "002";
    const VERSION: &'static str = "09";
    const MESSAGE_NAME: &'static str = "sese.030.002.09";
    const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:sese.030.002.09";
}