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:tsin.005.001.01")]
pub struct AccountIdentification4Choice {
    #[yaserde(rename = "IBAN")]
    #[cfg_attr(feature = "serde", serde(rename = "IBAN"))]
    pub iban: Option<Iban2007Identifier>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<GenericAccountIdentification1>,
}

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

impl Validate for AccountSchemeName1Choice {}




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

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

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

impl Validate for ActiveCurrencyAndAmount {}


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

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

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

pub enum AddressType2Code {
    #[yaserde(rename = "ADDR")]
    #[cfg_attr(feature = "serde", serde(rename = "ADDR"))]
    Addr,
    #[yaserde(rename = "PBOX")]
    #[cfg_attr(feature = "serde", serde(rename = "PBOX"))]
    Pbox,
    #[yaserde(rename = "HOME")]
    #[cfg_attr(feature = "serde", serde(rename = "HOME"))]
    Home,
    #[yaserde(rename = "BIZZ")]
    #[cfg_attr(feature = "serde", serde(rename = "BIZZ"))]
    Bizz,
    #[yaserde(rename = "MLTO")]
    #[cfg_attr(feature = "serde", serde(rename = "MLTO"))]
    Mlto,
    #[yaserde(rename = "DLVY")]
    #[cfg_attr(feature = "serde", serde(rename = "DLVY"))]
    Dlvy,
    __Unknown__(String),
}

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

impl Validate for AddressType2Code {}



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

    #[yaserde(rename = "AmtDtlsChc")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtDtlsChc"))]
    pub amt_dtls_chc: AmountOrPercentage1Choice,

    #[yaserde(rename = "Trggr")]
    #[cfg_attr(feature = "serde", serde(rename = "Trggr"))]
    pub trggr: Vec<Trigger1>,
}

impl Validate for AmountAndTrigger1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsin.005.001.01")]
pub struct AmountOrPercentage1Choice {
    #[yaserde(rename = "DfndAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "DfndAmt"))]
    pub dfnd_amt: Option<UndertakingAmount4>,
    #[yaserde(rename = "PctgAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "PctgAmt"))]
    pub pctg_amt: Option<Percentage1>,
}

impl Validate for AmountOrPercentage1Choice {}




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

impl Validate for AnyBICIdentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsin.005.001.01")]
pub struct AutoExtend1Choice {
    #[yaserde(rename = "Days")]
    #[cfg_attr(feature = "serde", serde(rename = "Days"))]
    pub days: Option<Number>,
    #[yaserde(rename = "Mnths")]
    #[cfg_attr(feature = "serde", serde(rename = "Mnths"))]
    pub mnths: Option<Number>,
    #[yaserde(rename = "Yrs")]
    #[cfg_attr(feature = "serde", serde(rename = "Yrs"))]
    pub yrs: Option<Number>,
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Option<Isodate>,
}

impl Validate for AutoExtend1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsin.005.001.01")]
pub struct AutoExtension1 {
    #[yaserde(rename = "Prd")]
    #[cfg_attr(feature = "serde", serde(rename = "Prd"))]
    pub prd: AutoExtend1Choice,

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

    #[yaserde(rename = "NonXtnsnNtfctn")]
    #[cfg_attr(feature = "serde", serde(rename = "NonXtnsnNtfctn"))]
    pub non_xtnsn_ntfctn: Vec<NonExtension1>,
}

impl Validate for AutoExtension1 {}


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

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

    #[yaserde(rename = "AmtAndTrggr")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtAndTrggr"))]
    pub amt_and_trggr: Vec<AmountAndTrigger1>,

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

impl Validate for AutomaticVariation1 {}


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

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

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

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

impl Validate for Channel1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsin.005.001.01")]
pub struct CommunicationChannel1 {
    #[yaserde(rename = "Mtd")]
    #[cfg_attr(feature = "serde", serde(rename = "Mtd"))]
    pub mtd: ExternalChannel1Code,

    #[yaserde(rename = "DlvrToPtyTp")]
    #[cfg_attr(feature = "serde", serde(rename = "DlvrToPtyTp"))]
    pub dlvr_to_pty_tp: PartyType1Choice,

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

    #[yaserde(rename = "DlvrToAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "DlvrToAdr"))]
    pub dlvr_to_adr: PostalAddress6,
}

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

impl Validate for CommunicationMethod1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsin.005.001.01")]
pub struct ContactDetails2 {
    #[yaserde(rename = "NmPrfx")]
    #[cfg_attr(feature = "serde", serde(rename = "NmPrfx"))]
    pub nm_prfx: NamePrefix1Code,

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

    #[yaserde(rename = "PhneNb")]
    #[cfg_attr(feature = "serde", serde(rename = "PhneNb"))]
    pub phne_nb: PhoneNumber,

    #[yaserde(rename = "MobNb")]
    #[cfg_attr(feature = "serde", serde(rename = "MobNb"))]
    pub mob_nb: PhoneNumber,

    #[yaserde(rename = "FaxNb")]
    #[cfg_attr(feature = "serde", serde(rename = "FaxNb"))]
    pub fax_nb: PhoneNumber,

    #[yaserde(rename = "EmailAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "EmailAdr"))]
    pub email_adr: Max2048Text,

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

impl Validate for ContactDetails2 {}


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

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

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




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsin.005.001.01")]
pub struct DateAndPlaceOfBirth {
    #[yaserde(rename = "BirthDt")]
    #[cfg_attr(feature = "serde", serde(rename = "BirthDt"))]
    pub birth_dt: Isodate,

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

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

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

impl Validate for DateAndPlaceOfBirth {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsin.005.001.01")]
pub struct DateInformation1 {
    #[yaserde(rename = "StartDt")]
    #[cfg_attr(feature = "serde", serde(rename = "StartDt"))]
    pub start_dt: Isodate,

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

    #[yaserde(rename = "Nb")]
    #[cfg_attr(feature = "serde", serde(rename = "Nb"))]
    pub nb: Number,
}

impl Validate for DateInformation1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsin.005.001.01")]
pub struct Document {
    #[yaserde(rename = "UdrtkgAppl")]
    #[cfg_attr(feature = "serde", serde(rename = "UdrtkgAppl"))]
    pub udrtkg_appl: UndertakingApplicationV01,
}

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:tsin.005.001.01")]
pub struct Document10 {
    #[yaserde(rename = "DocTp")]
    #[cfg_attr(feature = "serde", serde(rename = "DocTp"))]
    pub doc_tp: UndertakingDocumentType2Choice,

    #[yaserde(rename = "PresntnChanl")]
    #[cfg_attr(feature = "serde", serde(rename = "PresntnChanl"))]
    pub presntn_chanl: Channel1Choice,

    #[yaserde(rename = "DocFrmt")]
    #[cfg_attr(feature = "serde", serde(rename = "DocFrmt"))]
    pub doc_frmt: DocumentFormat1Choice,

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

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

impl Validate for Document10 {}


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

    #[yaserde(rename = "Wrdg")]
    #[cfg_attr(feature = "serde", serde(rename = "Wrdg"))]
    pub wrdg: Max20000Text,

    #[yaserde(rename = "ElctrncDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "ElctrncDtls"))]
    pub elctrnc_dtls: Vec<Presentation3>,
}

impl Validate for Document11 {}


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

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

    #[yaserde(rename = "Frmt")]
    #[cfg_attr(feature = "serde", serde(rename = "Frmt"))]
    pub frmt: DocumentFormat1Choice,

    #[yaserde(rename = "Nclsr")]
    #[cfg_attr(feature = "serde", serde(rename = "Nclsr"))]
    pub nclsr: Max2MBBinary,

    #[yaserde(rename = "DgtlSgntr")]
    #[cfg_attr(feature = "serde", serde(rename = "DgtlSgntr"))]
    pub dgtl_sgntr: PartyAndSignature2,
}

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

impl Validate for DocumentFormat1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsin.005.001.01")]
pub struct ExpiryDetails2 {
    #[yaserde(rename = "XpryTerms")]
    #[cfg_attr(feature = "serde", serde(rename = "XpryTerms"))]
    pub xpry_terms: ExpiryTerms2,

    #[yaserde(rename = "AddtlXpryInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlXpryInf"))]
    pub addtl_xpry_inf: Vec<Max2000Text>,
}

impl Validate for ExpiryDetails2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsin.005.001.01")]
pub struct ExpiryTerms2 {
    #[yaserde(rename = "DtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "DtTm"))]
    pub dt_tm: DateAndDateTimeChoice,

    #[yaserde(rename = "AutoXtnsn")]
    #[cfg_attr(feature = "serde", serde(rename = "AutoXtnsn"))]
    pub auto_xtnsn: AutoExtension1,

    #[yaserde(rename = "Cond")]
    #[cfg_attr(feature = "serde", serde(rename = "Cond"))]
    pub cond: Max2000Text,

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

impl Validate for ExpiryTerms2 {}


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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Validate for ExternalUndertakingType1Code {
    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:tsin.005.001.01")]
pub struct FixedOrRecurrentDate1Choice {
    #[yaserde(rename = "FxdDt")]
    #[cfg_attr(feature = "serde", serde(rename = "FxdDt"))]
    pub fxd_dt: Option<Isodate>,
    #[yaserde(rename = "RcrntDt")]
    #[cfg_attr(feature = "serde", serde(rename = "RcrntDt"))]
    pub rcrnt_dt: Option<DateInformation1>,
}

impl Validate for FixedOrRecurrentDate1Choice {}




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

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

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

impl Validate for GenericAccountIdentification1 {}


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

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

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

impl Validate for GenericIdentification1 {}


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

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

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

impl Validate for GenericOrganisationIdentification1 {}


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

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

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

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

impl Validate for GovernanceIdentification1Choice {}




#[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:tsin.005.001.01")]

pub enum GovernanceIdentification1Code {
    #[yaserde(rename = "ISPR")]
    #[cfg_attr(feature = "serde", serde(rename = "ISPR"))]
    Ispr,
    #[yaserde(rename = "NONE")]
    #[cfg_attr(feature = "serde", serde(rename = "NONE"))]
    None,
    #[yaserde(rename = "UCPR")]
    #[cfg_attr(feature = "serde", serde(rename = "UCPR"))]
    Ucpr,
    #[yaserde(rename = "URDG")]
    #[cfg_attr(feature = "serde", serde(rename = "URDG"))]
    Urdg,
    __Unknown__(String),
}

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

impl Validate for GovernanceIdentification1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsin.005.001.01")]
pub struct GovernanceRules1 {
    #[yaserde(rename = "RuleId")]
    #[cfg_attr(feature = "serde", serde(rename = "RuleId"))]
    pub rule_id: GovernanceIdentification1Choice,

    #[yaserde(rename = "AplblLaw")]
    #[cfg_attr(feature = "serde", serde(rename = "AplblLaw"))]
    pub aplbl_law: Location1,

    #[yaserde(rename = "Jursdctn")]
    #[cfg_attr(feature = "serde", serde(rename = "Jursdctn"))]
    pub jursdctn: Vec<Location1>,
}

impl Validate for GovernanceRules1 {}


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

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

impl Validate for Iso2AlanguageCode {}
#[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:tsin.005.001.01")]
pub struct Location1 {
    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: CountryCode,

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

    #[yaserde(rename = "Txt")]
    #[cfg_attr(feature = "serde", serde(rename = "Txt"))]
    pub txt: Vec<Max2000Text>,
}

impl Validate for Location1 {}


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct 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:tsin.005.001.01")]
pub struct ModelFormIdentification1 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: ModelFormIdentification1Choice,

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

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

impl Validate for ModelFormIdentification1Choice {}




#[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:tsin.005.001.01")]

pub enum NamePrefix1Code {
    #[yaserde(rename = "DOCT")]
    #[cfg_attr(feature = "serde", serde(rename = "DOCT"))]
    Doct,
    #[yaserde(rename = "MIST")]
    #[cfg_attr(feature = "serde", serde(rename = "MIST"))]
    Mist,
    #[yaserde(rename = "MISS")]
    #[cfg_attr(feature = "serde", serde(rename = "MISS"))]
    Miss,
    #[yaserde(rename = "MADM")]
    #[cfg_attr(feature = "serde", serde(rename = "MADM"))]
    Madm,
    __Unknown__(String),
}

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

impl Validate for NamePrefix1Code {}



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

    #[yaserde(rename = "Txt")]
    #[cfg_attr(feature = "serde", serde(rename = "Txt"))]
    pub txt: Vec<Max20000Text>,
}

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

impl Validate for NarrativeType1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsin.005.001.01")]
pub struct NonExtension1 {
    #[yaserde(rename = "NtfctnPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "NtfctnPrd"))]
    pub ntfctn_prd: Number,

    #[yaserde(rename = "NtfctnMtd")]
    #[cfg_attr(feature = "serde", serde(rename = "NtfctnMtd"))]
    pub ntfctn_mtd: CommunicationMethod1Choice,

    #[yaserde(rename = "NtfctnRcptTp")]
    #[cfg_attr(feature = "serde", serde(rename = "NtfctnRcptTp"))]
    pub ntfctn_rcpt_tp: PartyType1Choice,

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

    #[yaserde(rename = "NtfctnRcptAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NtfctnRcptAdr"))]
    pub ntfctn_rcpt_adr: PostalAddress6,
}

impl Validate for NonExtension1 {}


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

impl Validate for Number {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsin.005.001.01")]
pub struct OrganisationIdentification8 {
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_bic: AnyBICIdentifier,

    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Vec<GenericOrganisationIdentification1>,
}

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

impl Validate for OrganisationIdentificationSchemeName1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsin.005.001.01")]
pub struct Party11Choice {
    #[yaserde(rename = "OrgId")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgId"))]
    pub org_id: Option<OrganisationIdentification8>,
    #[yaserde(rename = "PrvtId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvtId"))]
    pub prvt_id: Option<PersonIdentification5>,
}

impl Validate for Party11Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsin.005.001.01")]
pub struct PartyAndSignature2 {
    #[yaserde(rename = "Pty")]
    #[cfg_attr(feature = "serde", serde(rename = "Pty"))]
    pub pty: PartyIdentification43,

    #[yaserde(rename = "Sgntr")]
    #[cfg_attr(feature = "serde", serde(rename = "Sgntr"))]
    pub sgntr: ProprietaryData3,
}

impl Validate for PartyAndSignature2 {}


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

    #[yaserde(rename = "Pty")]
    #[cfg_attr(feature = "serde", serde(rename = "Pty"))]
    pub pty: PartyIdentification43,
}

impl Validate for PartyAndType1 {}


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

    #[yaserde(rename = "PstlAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "PstlAdr"))]
    pub pstl_adr: PostalAddress6,

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

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

    #[yaserde(rename = "CtctDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "CtctDtls"))]
    pub ctct_dtls: ContactDetails2,
}

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

impl Validate for PartyType1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsin.005.001.01")]
pub struct Percentage1 {
    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: PercentageRate,

    #[yaserde(rename = "RltvTo")]
    #[cfg_attr(feature = "serde", serde(rename = "RltvTo"))]
    pub rltv_to: ExternalRelativeTo1Code,
}

impl Validate for Percentage1 {}


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

impl Validate for PercentageRate {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsin.005.001.01")]
pub struct PersonIdentification5 {
    #[yaserde(rename = "DtAndPlcOfBirth")]
    #[cfg_attr(feature = "serde", serde(rename = "DtAndPlcOfBirth"))]
    pub dt_and_plc_of_birth: DateAndPlaceOfBirth,

    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Vec<GenericPersonIdentification1>,
}

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

impl Validate for PersonIdentificationSchemeName1Choice {}




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

impl Validate for PhoneNumber {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsin.005.001.01")]
pub struct PostalAddress6 {
    #[yaserde(rename = "AdrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "AdrTp"))]
    pub adr_tp: AddressType2Code,

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

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

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

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

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

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

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

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

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

impl Validate for PostalAddress6 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsin.005.001.01")]
pub struct Presentation3 {
    #[yaserde(rename = "Frmt")]
    #[cfg_attr(feature = "serde", serde(rename = "Frmt"))]
    pub frmt: DocumentFormat1Choice,

    #[yaserde(rename = "Chanl")]
    #[cfg_attr(feature = "serde", serde(rename = "Chanl"))]
    pub chanl: Channel1Choice,

    #[yaserde(rename = "Adr")]
    #[cfg_attr(feature = "serde", serde(rename = "Adr"))]
    pub adr: Max256Text,
}

impl Validate for Presentation3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsin.005.001.01")]
pub struct Presentation4 {
    #[yaserde(rename = "Mdm")]
    #[cfg_attr(feature = "serde", serde(rename = "Mdm"))]
    pub mdm: PresentationMedium1Choice,

    #[yaserde(rename = "Doc")]
    #[cfg_attr(feature = "serde", serde(rename = "Doc"))]
    pub doc: Vec<Document11>,

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

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

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

impl Validate for PresentationMedium1Choice {}




#[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:tsin.005.001.01")]

pub enum PresentationMedium1Code {
    #[yaserde(rename = "BOTH")]
    #[cfg_attr(feature = "serde", serde(rename = "BOTH"))]
    Both,
    #[yaserde(rename = "ELEC")]
    #[cfg_attr(feature = "serde", serde(rename = "ELEC"))]
    Elec,
    #[yaserde(rename = "PAPR")]
    #[cfg_attr(feature = "serde", serde(rename = "PAPR"))]
    Papr,
    __Unknown__(String),
}

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

impl Validate for PresentationMedium1Code {}



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

impl Validate for ProprietaryData3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsin.005.001.01")]
pub struct Trigger1 {
    #[yaserde(rename = "DtChc")]
    #[cfg_attr(feature = "serde", serde(rename = "DtChc"))]
    pub dt_chc: FixedOrRecurrentDate1Choice,

    #[yaserde(rename = "DcmntryEvt")]
    #[cfg_attr(feature = "serde", serde(rename = "DcmntryEvt"))]
    pub dcmntry_evt: Vec<Document10>,
}

impl Validate for Trigger1 {}


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

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

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

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

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

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

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

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

impl Validate for UnderlyingTradeTransactionType1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsin.005.001.01")]
pub struct Undertaking1 {
    #[yaserde(rename = "ApplcntRefNb")]
    #[cfg_attr(feature = "serde", serde(rename = "ApplcntRefNb"))]
    pub applcnt_ref_nb: Max35Text,

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

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

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

    #[yaserde(rename = "Oblgr")]
    #[cfg_attr(feature = "serde", serde(rename = "Oblgr"))]
    pub oblgr: PartyIdentification43,

    #[yaserde(rename = "Applcnt")]
    #[cfg_attr(feature = "serde", serde(rename = "Applcnt"))]
    pub applcnt: Vec<PartyIdentification43>,

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

    #[yaserde(rename = "Bnfcry")]
    #[cfg_attr(feature = "serde", serde(rename = "Bnfcry"))]
    pub bnfcry: Vec<PartyIdentification43>,

    #[yaserde(rename = "AdvsgPty")]
    #[cfg_attr(feature = "serde", serde(rename = "AdvsgPty"))]
    pub advsg_pty: PartyIdentification43,

    #[yaserde(rename = "ScndAdvsgPty")]
    #[cfg_attr(feature = "serde", serde(rename = "ScndAdvsgPty"))]
    pub scnd_advsg_pty: PartyIdentification43,

    #[yaserde(rename = "Cnfrmr")]
    #[cfg_attr(feature = "serde", serde(rename = "Cnfrmr"))]
    pub cnfrmr: PartyIdentification43,

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

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

    #[yaserde(rename = "CntrUdrtkg")]
    #[cfg_attr(feature = "serde", serde(rename = "CntrUdrtkg"))]
    pub cntr_udrtkg: Undertaking2,

    #[yaserde(rename = "UdrtkgAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "UdrtkgAmt"))]
    pub udrtkg_amt: UndertakingAmount1,

    #[yaserde(rename = "XpryDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "XpryDtls"))]
    pub xpry_dtls: ExpiryDetails2,

    #[yaserde(rename = "AddtlPty")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlPty"))]
    pub addtl_pty: Vec<PartyAndType1>,

    #[yaserde(rename = "GovncRulesAndLaw")]
    #[cfg_attr(feature = "serde", serde(rename = "GovncRulesAndLaw"))]
    pub govnc_rules_and_law: GovernanceRules1,

    #[yaserde(rename = "UndrlygTx")]
    #[cfg_attr(feature = "serde", serde(rename = "UndrlygTx"))]
    pub undrlyg_tx: Vec<UnderlyingTradeTransaction1>,

    #[yaserde(rename = "PresntnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "PresntnDtls"))]
    pub presntn_dtls: Presentation4,

    #[yaserde(rename = "UdrtkgWrdg")]
    #[cfg_attr(feature = "serde", serde(rename = "UdrtkgWrdg"))]
    pub udrtkg_wrdg: UndertakingWording1,

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

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

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

    #[yaserde(rename = "TrfChrgsPyblBy")]
    #[cfg_attr(feature = "serde", serde(rename = "TrfChrgsPyblBy"))]
    pub trf_chrgs_pybl_by: ExternalTypeOfParty1Code,

    #[yaserde(rename = "ConfChrgsPyblBy")]
    #[cfg_attr(feature = "serde", serde(rename = "ConfChrgsPyblBy"))]
    pub conf_chrgs_pybl_by: ExternalTypeOfParty1Code,

    #[yaserde(rename = "AutomtcAmtVartn")]
    #[cfg_attr(feature = "serde", serde(rename = "AutomtcAmtVartn"))]
    pub automtc_amt_vartn: Vec<AutomaticVariation1>,

    #[yaserde(rename = "DlvryChanl")]
    #[cfg_attr(feature = "serde", serde(rename = "DlvryChanl"))]
    pub dlvry_chanl: CommunicationChannel1,

    #[yaserde(rename = "OblgrLbltyAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "OblgrLbltyAcct"))]
    pub oblgr_lblty_acct: CashAccount28,

    #[yaserde(rename = "OblgrChrgAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "OblgrChrgAcct"))]
    pub oblgr_chrg_acct: CashAccount28,

    #[yaserde(rename = "OblgrSttlmAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "OblgrSttlmAcct"))]
    pub oblgr_sttlm_acct: CashAccount28,

    #[yaserde(rename = "NclsdFile")]
    #[cfg_attr(feature = "serde", serde(rename = "NclsdFile"))]
    pub nclsd_file: Vec<Document9>,

    #[yaserde(rename = "AddtlApplInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlApplInf"))]
    pub addtl_appl_inf: Vec<Max2000Text>,
}

impl Validate for Undertaking1 {}


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

    #[yaserde(rename = "Bnfcry")]
    #[cfg_attr(feature = "serde", serde(rename = "Bnfcry"))]
    pub bnfcry: PartyIdentification43,

    #[yaserde(rename = "XpryDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "XpryDtls"))]
    pub xpry_dtls: ExpiryDetails2,

    #[yaserde(rename = "CntrUdrtkgAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "CntrUdrtkgAmt"))]
    pub cntr_udrtkg_amt: UndertakingAmount1,

    #[yaserde(rename = "ConfChrgsPyblBy")]
    #[cfg_attr(feature = "serde", serde(rename = "ConfChrgsPyblBy"))]
    pub conf_chrgs_pybl_by: ExternalTypeOfParty1Code,

    #[yaserde(rename = "GovncRulesAndLaw")]
    #[cfg_attr(feature = "serde", serde(rename = "GovncRulesAndLaw"))]
    pub govnc_rules_and_law: GovernanceRules1,

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

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

impl Validate for Undertaking2 {}


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

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

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

impl Validate for UndertakingAmount1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsin.005.001.01")]
pub struct UndertakingAmount4 {
    #[yaserde(rename = "VartnAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "VartnAmt"))]
    pub vartn_amt: ActiveCurrencyAndAmount,

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

impl Validate for UndertakingAmount4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsin.005.001.01")]
pub struct UndertakingApplicationV01 {
    #[yaserde(rename = "UdrtkgApplDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "UdrtkgApplDtls"))]
    pub udrtkg_appl_dtls: Undertaking1,

    #[yaserde(rename = "InstrsToBk")]
    #[cfg_attr(feature = "serde", serde(rename = "InstrsToBk"))]
    pub instrs_to_bk: Vec<Max2000Text>,

    #[yaserde(rename = "DgtlSgntr")]
    #[cfg_attr(feature = "serde", serde(rename = "DgtlSgntr"))]
    pub dgtl_sgntr: PartyAndSignature2,
}

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

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

impl Validate for UndertakingDocumentType2Choice {}




#[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:tsin.005.001.01")]

pub enum UndertakingName1Code {
    #[yaserde(rename = "STBY")]
    #[cfg_attr(feature = "serde", serde(rename = "STBY"))]
    Stby,
    #[yaserde(rename = "DGAR")]
    #[cfg_attr(feature = "serde", serde(rename = "DGAR"))]
    Dgar,
    __Unknown__(String),
}

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

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

impl Validate for UndertakingType1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsin.005.001.01")]
pub struct UndertakingWording1 {
    #[yaserde(rename = "MdlForm")]
    #[cfg_attr(feature = "serde", serde(rename = "MdlForm"))]
    pub mdl_form: ModelFormIdentification1,

    #[yaserde(rename = "ReqdWrdgLang")]
    #[cfg_attr(feature = "serde", serde(rename = "ReqdWrdgLang"))]
    pub reqd_wrdg_lang: Iso2AlanguageCode,

    #[yaserde(rename = "UdrtkgTermsAndConds")]
    #[cfg_attr(feature = "serde", serde(rename = "UdrtkgTermsAndConds"))]
    pub udrtkg_terms_and_conds: Vec<Narrative1>,
}

impl Validate for UndertakingWording1 {}


#[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:tsin.005.001.01")]

pub enum VariationType1Code {
    #[yaserde(rename = "DECR")]
    #[cfg_attr(feature = "serde", serde(rename = "DECR"))]
    Decr,
    #[yaserde(rename = "INCR")]
    #[cfg_attr(feature = "serde", serde(rename = "INCR"))]
    Incr,
    __Unknown__(String),
}

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

impl Validate for VariationType1Code {}



#[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::tsin;
    const FUNCTIONALITY: &'static str = "005";
    const VARIANT: &'static str = "001";
    const VERSION: &'static str = "01";
    const MESSAGE_NAME: &'static str = "tsin.005.001.01";
    const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:tsin.005.001.01";
}