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

pub enum AgreementItemAction1Code {
    #[yaserde(rename = "DEAC")]
    #[cfg_attr(feature = "serde", serde(rename = "DEAC"))]
    Deac,
    #[yaserde(rename = "HOLD")]
    #[cfg_attr(feature = "serde", serde(rename = "HOLD"))]
    Hold,
    #[yaserde(rename = "MDFY")]
    #[cfg_attr(feature = "serde", serde(rename = "MDFY"))]
    Mdfy,
    #[yaserde(rename = "REAC")]
    #[cfg_attr(feature = "serde", serde(rename = "REAC"))]
    Reac,
    #[yaserde(rename = "OPEN")]
    #[cfg_attr(feature = "serde", serde(rename = "OPEN"))]
    Open,
    #[yaserde(rename = "SYNC")]
    #[cfg_attr(feature = "serde", serde(rename = "SYNC"))]
    Sync,
    #[yaserde(rename = "VRFY")]
    #[cfg_attr(feature = "serde", serde(rename = "VRFY"))]
    Vrfy,
    __Unknown__(String),
}

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

impl Validate for AgreementItemAction1Code {}



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

pub enum Algorithm5Code {
    #[yaserde(rename = "HS25")]
    #[cfg_attr(feature = "serde", serde(rename = "HS25"))]
    Hs25,
    #[yaserde(rename = "HS38")]
    #[cfg_attr(feature = "serde", serde(rename = "HS38"))]
    Hs38,
    #[yaserde(rename = "HS51")]
    #[cfg_attr(feature = "serde", serde(rename = "HS51"))]
    Hs51,
    __Unknown__(String),
}

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

impl Validate for Algorithm5Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.009.001.01")]
pub struct AlgorithmAndDigest1 {
    #[yaserde(rename = "DgstAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "DgstAlgo"))]
    pub dgst_algo: Algorithm5Code,

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

impl Validate for AlgorithmAndDigest1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.009.001.01")]
pub struct AmountAndPeriod1 {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: ActiveCurrencyAndAmount,

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

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

impl Validate for AmountAndPeriod1 {}


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

impl Validate for Bicfiidentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.009.001.01")]
pub struct BinaryFile1 {
    #[yaserde(rename = "MIMETp")]
    #[cfg_attr(feature = "serde", serde(rename = "MIMETp"))]
    pub mime_tp: Max35Text,

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

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

    #[yaserde(rename = "InclBinryObjct")]
    #[cfg_attr(feature = "serde", serde(rename = "InclBinryObjct"))]
    pub incl_binry_objct: Max100KBinary,
}

impl Validate for BinaryFile1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.009.001.01")]
pub struct BranchAndFinancialInstitutionIdentification5 {
    #[yaserde(rename = "FinInstnId")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstnId"))]
    pub fin_instn_id: FinancialInstitutionIdentification8,

    #[yaserde(rename = "BrnchId")]
    #[cfg_attr(feature = "serde", serde(rename = "BrnchId"))]
    pub brnch_id: BranchData2,
}

impl Validate for BranchAndFinancialInstitutionIdentification5 {}


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

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

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

impl Validate for BranchData2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.009.001.01")]
pub struct BusinessApplicationHeader1 {
    #[yaserde(rename = "CharSet")]
    #[cfg_attr(feature = "serde", serde(rename = "CharSet"))]
    pub char_set: UnicodeChartsCode,

    #[yaserde(rename = "Fr")]
    #[cfg_attr(feature = "serde", serde(rename = "Fr"))]
    pub fr: Party9Choice,

    #[yaserde(rename = "To")]
    #[cfg_attr(feature = "serde", serde(rename = "To"))]
    pub to: Party9Choice,

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

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

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

    #[yaserde(rename = "CreDt")]
    #[cfg_attr(feature = "serde", serde(rename = "CreDt"))]
    pub cre_dt: IsonormalisedDateTime,

    #[yaserde(rename = "CpyDplct")]
    #[cfg_attr(feature = "serde", serde(rename = "CpyDplct"))]
    pub cpy_dplct: CopyDuplicate1Code,

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

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

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

impl Validate for BusinessApplicationHeader1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.009.001.01")]
pub struct BusinessLetter1 {
    #[yaserde(rename = "ApplCntxt")]
    #[cfg_attr(feature = "serde", serde(rename = "ApplCntxt"))]
    pub appl_cntxt: Max35Text,

    #[yaserde(rename = "LttrIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "LttrIdr"))]
    pub lttr_idr: QualifiedDocumentInformation1,

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

    #[yaserde(rename = "RltdLttr")]
    #[cfg_attr(feature = "serde", serde(rename = "RltdLttr"))]
    pub rltd_lttr: Vec<QualifiedDocumentInformation1>,

    #[yaserde(rename = "RltdMsg")]
    #[cfg_attr(feature = "serde", serde(rename = "RltdMsg"))]
    pub rltd_msg: Vec<QualifiedDocumentInformation1>,

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

    #[yaserde(rename = "InstrPrty")]
    #[cfg_attr(feature = "serde", serde(rename = "InstrPrty"))]
    pub instr_prty: Priority3Code,

    #[yaserde(rename = "Orgtr")]
    #[cfg_attr(feature = "serde", serde(rename = "Orgtr"))]
    pub orgtr: QualifiedPartyIdentification1,

    #[yaserde(rename = "PmryRcpt")]
    #[cfg_attr(feature = "serde", serde(rename = "PmryRcpt"))]
    pub pmry_rcpt: Vec<QualifiedPartyIdentification1>,

    #[yaserde(rename = "Sndr")]
    #[cfg_attr(feature = "serde", serde(rename = "Sndr"))]
    pub sndr: Vec<QualifiedPartyIdentification1>,

    #[yaserde(rename = "AuthstnUsr")]
    #[cfg_attr(feature = "serde", serde(rename = "AuthstnUsr"))]
    pub authstn_usr: Vec<QualifiedPartyIdentification1>,

    #[yaserde(rename = "RspnRcpt")]
    #[cfg_attr(feature = "serde", serde(rename = "RspnRcpt"))]
    pub rspn_rcpt: Vec<QualifiedPartyIdentification1>,

    #[yaserde(rename = "CpyRcpt")]
    #[cfg_attr(feature = "serde", serde(rename = "CpyRcpt"))]
    pub cpy_rcpt: Vec<QualifiedPartyIdentification1>,

    #[yaserde(rename = "OthrPty")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrPty"))]
    pub othr_pty: Vec<QualifiedPartyIdentification1>,

    #[yaserde(rename = "AssoctdDoc")]
    #[cfg_attr(feature = "serde", serde(rename = "AssoctdDoc"))]
    pub assoctd_doc: Vec<QualifiedDocumentInformation1>,

    #[yaserde(rename = "GovngCtrct")]
    #[cfg_attr(feature = "serde", serde(rename = "GovngCtrct"))]
    pub govng_ctrct: Vec<QualifiedDocumentInformation1>,

    #[yaserde(rename = "LglCntxt")]
    #[cfg_attr(feature = "serde", serde(rename = "LglCntxt"))]
    pub lgl_cntxt: Vec<GovernanceRules2>,

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

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

    #[yaserde(rename = "VldtnStsInf")]
    #[cfg_attr(feature = "serde", serde(rename = "VldtnStsInf"))]
    pub vldtn_sts_inf: ValidationStatusInformation1,

    #[yaserde(rename = "DgtlSgntr")]
    #[cfg_attr(feature = "serde", serde(rename = "DgtlSgntr"))]
    pub dgtl_sgntr: Vec<QualifiedPartyAndXMLSignature1>,
}

impl Validate for BusinessLetter1 {}


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

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

impl Validate for ClearingSystemIdentification2Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.009.001.01")]
pub struct ClearingSystemMemberIdentification2 {
    #[yaserde(rename = "ClrSysId")]
    #[cfg_attr(feature = "serde", serde(rename = "ClrSysId"))]
    pub clr_sys_id: ClearingSystemIdentification2Choice,

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

impl Validate for ClearingSystemMemberIdentification2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.009.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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsin.009.001.01")]
pub struct Contacts3 {
    #[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,

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

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

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

impl Validate for Contacts3 {}


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

pub enum CopyDuplicate1Code {
    #[yaserde(rename = "CODU")]
    #[cfg_attr(feature = "serde", serde(rename = "CODU"))]
    Codu,
    #[yaserde(rename = "COPY")]
    #[cfg_attr(feature = "serde", serde(rename = "COPY"))]
    Copy,
    #[yaserde(rename = "DUPL")]
    #[cfg_attr(feature = "serde", serde(rename = "DUPL"))]
    Dupl,
    __Unknown__(String),
}

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

impl Validate for CopyDuplicate1Code {}



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

impl Validate for CurrencyCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.009.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)]
pub struct DecimalNumber (pub String);
crate::simple_type!(DecimalNumber);

impl Validate for DecimalNumber {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.009.001.01")]
pub struct Document {
    #[yaserde(rename = "PtyRegnAndGrntReq")]
    #[cfg_attr(feature = "serde", serde(rename = "PtyRegnAndGrntReq"))]
    pub pty_regn_and_grnt_req: PartyRegistrationAndGuaranteeRequestV01,
}

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.009.001.01")]
pub struct EncapsulatedBusinessMessage1 {
    #[yaserde(rename = "Hdr")]
    #[cfg_attr(feature = "serde", serde(rename = "Hdr"))]
    pub hdr: BusinessApplicationHeader1,

    #[yaserde(rename = "Prfx")]
    #[cfg_attr(feature = "serde", serde(rename = "Prfx"))]
    pub prfx: String,

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

    #[yaserde(rename = "Msg")]
    #[cfg_attr(feature = "serde", serde(rename = "Msg"))]
    pub msg: StrictPayload,
}

impl Validate for EncapsulatedBusinessMessage1 {}


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

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

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

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

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

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

impl Validate for ExternalTradeMarket1Code {
    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.009.001.01")]
pub struct FinancialIdentificationSchemeName1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ExternalFinancialInstitutionIdentification1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max35Text>,
}

impl Validate for FinancialIdentificationSchemeName1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.009.001.01")]
pub struct FinancialInstitutionIdentification8 {
    #[yaserde(rename = "BICFI")]
    #[cfg_attr(feature = "serde", serde(rename = "BICFI"))]
    pub bicfi: Bicfiidentifier,

    #[yaserde(rename = "ClrSysMmbId")]
    #[cfg_attr(feature = "serde", serde(rename = "ClrSysMmbId"))]
    pub clr_sys_mmb_id: ClearingSystemMemberIdentification2,

    #[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 = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: GenericFinancialIdentification1,
}

impl Validate for FinancialInstitutionIdentification8 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.009.001.01")]
pub struct FinancialItemParameters1 {
    #[yaserde(rename = "Idr")]
    #[cfg_attr(feature = "serde", serde(rename = "Idr"))]
    pub idr: Max35Text,

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

    #[yaserde(rename = "RltdItm")]
    #[cfg_attr(feature = "serde", serde(rename = "RltdItm"))]
    pub rltd_itm: Vec<String>,

    #[yaserde(rename = "DocPurp")]
    #[cfg_attr(feature = "serde", serde(rename = "DocPurp"))]
    pub doc_purp: ExternalDocumentPurpose1Code,

    #[yaserde(rename = "LangCd")]
    #[cfg_attr(feature = "serde", serde(rename = "LangCd"))]
    pub lang_cd: LanguageCode,

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

    #[yaserde(rename = "Rcpt")]
    #[cfg_attr(feature = "serde", serde(rename = "Rcpt"))]
    pub rcpt: String,

    #[yaserde(rename = "Buyr")]
    #[cfg_attr(feature = "serde", serde(rename = "Buyr"))]
    pub buyr: String,

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

    #[yaserde(rename = "SellrFinAgt")]
    #[cfg_attr(feature = "serde", serde(rename = "SellrFinAgt"))]
    pub sellr_fin_agt: String,

    #[yaserde(rename = "BuyrFinAgt")]
    #[cfg_attr(feature = "serde", serde(rename = "BuyrFinAgt"))]
    pub buyr_fin_agt: String,

    #[yaserde(rename = "GovngCtrct")]
    #[cfg_attr(feature = "serde", serde(rename = "GovngCtrct"))]
    pub govng_ctrct: Vec<String>,

    #[yaserde(rename = "LglCntxt")]
    #[cfg_attr(feature = "serde", serde(rename = "LglCntxt"))]
    pub lgl_cntxt: String,

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

    #[yaserde(rename = "DbtAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "DbtAcct"))]
    pub dbt_acct: AccountIdentification4Choice,

    #[yaserde(rename = "CdtAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtAcct"))]
    pub cdt_acct: AccountIdentification4Choice,

    #[yaserde(rename = "TradMkt")]
    #[cfg_attr(feature = "serde", serde(rename = "TradMkt"))]
    pub trad_mkt: TradeMarket1Choice,
}

impl Validate for FinancialItemParameters1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.009.001.01")]
pub struct FinancingAgreementItem1 {
    #[yaserde(rename = "ItmCntxt")]
    #[cfg_attr(feature = "serde", serde(rename = "ItmCntxt"))]
    pub itm_cntxt: FinancialItemParameters1,

    #[yaserde(rename = "ItmActn")]
    #[cfg_attr(feature = "serde", serde(rename = "ItmActn"))]
    pub itm_actn: AgreementItemAction1Code,

    #[yaserde(rename = "PmtInstrm")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtInstrm"))]
    pub pmt_instrm: PaymentInstrumentCode,

    #[yaserde(rename = "VldtnStsInf")]
    #[cfg_attr(feature = "serde", serde(rename = "VldtnStsInf"))]
    pub vldtn_sts_inf: ValidationStatusInformation1,

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

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

    #[yaserde(rename = "Grnt")]
    #[cfg_attr(feature = "serde", serde(rename = "Grnt"))]
    pub grnt: Vec<GuaranteeDetails1>,

    #[yaserde(rename = "GrntSts")]
    #[cfg_attr(feature = "serde", serde(rename = "GrntSts"))]
    pub grnt_sts: ValidationStatusInformation1,

    #[yaserde(rename = "RltdGrntLttr")]
    #[cfg_attr(feature = "serde", serde(rename = "RltdGrntLttr"))]
    pub rltd_grnt_lttr: String,

    #[yaserde(rename = "AssoctdDoc")]
    #[cfg_attr(feature = "serde", serde(rename = "AssoctdDoc"))]
    pub assoctd_doc: Vec<String>,

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

impl Validate for FinancingAgreementItem1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.009.001.01")]
pub struct FinancingAgreementList1 {
    #[yaserde(rename = "Idr")]
    #[cfg_attr(feature = "serde", serde(rename = "Idr"))]
    pub idr: Max35Text,

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

    #[yaserde(rename = "RltdDoc")]
    #[cfg_attr(feature = "serde", serde(rename = "RltdDoc"))]
    pub rltd_doc: Vec<String>,

    #[yaserde(rename = "AgrmtRqstr")]
    #[cfg_attr(feature = "serde", serde(rename = "AgrmtRqstr"))]
    pub agrmt_rqstr: String,

    #[yaserde(rename = "AgrmtRspndr")]
    #[cfg_attr(feature = "serde", serde(rename = "AgrmtRspndr"))]
    pub agrmt_rspndr: String,

    #[yaserde(rename = "GrntApplcnt")]
    #[cfg_attr(feature = "serde", serde(rename = "GrntApplcnt"))]
    pub grnt_applcnt: String,

    #[yaserde(rename = "GrntNbfcry")]
    #[cfg_attr(feature = "serde", serde(rename = "GrntNbfcry"))]
    pub grnt_nbfcry: String,

    #[yaserde(rename = "GrntIssr")]
    #[cfg_attr(feature = "serde", serde(rename = "GrntIssr"))]
    pub grnt_issr: String,

    #[yaserde(rename = "NtfctnInf")]
    #[cfg_attr(feature = "serde", serde(rename = "NtfctnInf"))]
    pub ntfctn_inf: Vec<FinancingNotificationParties1>,

    #[yaserde(rename = "Itm")]
    #[cfg_attr(feature = "serde", serde(rename = "Itm"))]
    pub itm: Vec<FinancingAgreementItem1>,

    #[yaserde(rename = "ItmCnt")]
    #[cfg_attr(feature = "serde", serde(rename = "ItmCnt"))]
    pub itm_cnt: Max15NumericText,

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

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

    #[yaserde(rename = "VldtnStsInf")]
    #[cfg_attr(feature = "serde", serde(rename = "VldtnStsInf"))]
    pub vldtn_sts_inf: ValidationStatusInformation1,
}

impl Validate for FinancingAgreementList1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.009.001.01")]
pub struct FinancingNotificationParties1 {
    #[yaserde(rename = "NtifngPty")]
    #[cfg_attr(feature = "serde", serde(rename = "NtifngPty"))]
    pub ntifng_pty: String,

    #[yaserde(rename = "NtfctnRcvr")]
    #[cfg_attr(feature = "serde", serde(rename = "NtfctnRcvr"))]
    pub ntfctn_rcvr: String,

    #[yaserde(rename = "AckRcvr")]
    #[cfg_attr(feature = "serde", serde(rename = "AckRcvr"))]
    pub ack_rcvr: Vec<String>,
}

impl Validate for FinancingNotificationParties1 {}


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

pub enum FinancingStatusReason1Code {
    #[yaserde(rename = "CA01")]
    #[cfg_attr(feature = "serde", serde(rename = "CA01"))]
    Ca01,
    #[yaserde(rename = "CA02")]
    #[cfg_attr(feature = "serde", serde(rename = "CA02"))]
    Ca02,
    #[yaserde(rename = "AC01")]
    #[cfg_attr(feature = "serde", serde(rename = "AC01"))]
    Ac01,
    #[yaserde(rename = "AC04")]
    #[cfg_attr(feature = "serde", serde(rename = "AC04"))]
    Ac04,
    #[yaserde(rename = "AC06")]
    #[cfg_attr(feature = "serde", serde(rename = "AC06"))]
    Ac06,
    #[yaserde(rename = "BE08")]
    #[cfg_attr(feature = "serde", serde(rename = "BE08"))]
    Be08,
    #[yaserde(rename = "BE09")]
    #[cfg_attr(feature = "serde", serde(rename = "BE09"))]
    Be09,
    #[yaserde(rename = "BE10")]
    #[cfg_attr(feature = "serde", serde(rename = "BE10"))]
    Be10,
    #[yaserde(rename = "BE11")]
    #[cfg_attr(feature = "serde", serde(rename = "BE11"))]
    Be11,
    #[yaserde(rename = "DT02")]
    #[cfg_attr(feature = "serde", serde(rename = "DT02"))]
    Dt02,
    #[yaserde(rename = "ID01")]
    #[cfg_attr(feature = "serde", serde(rename = "ID01"))]
    Id01,
    #[yaserde(rename = "ID02")]
    #[cfg_attr(feature = "serde", serde(rename = "ID02"))]
    Id02,
    #[yaserde(rename = "ID03")]
    #[cfg_attr(feature = "serde", serde(rename = "ID03"))]
    Id03,
    #[yaserde(rename = "MI01")]
    #[cfg_attr(feature = "serde", serde(rename = "MI01"))]
    Mi01,
    #[yaserde(rename = "NA01")]
    #[cfg_attr(feature = "serde", serde(rename = "NA01"))]
    Na01,
    #[yaserde(rename = "CA03")]
    #[cfg_attr(feature = "serde", serde(rename = "CA03"))]
    Ca03,
    __Unknown__(String),
}

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

impl Validate for FinancingStatusReason1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.009.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.009.001.01")]
pub struct GenericFinancialIdentification1 {
    #[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: FinancialIdentificationSchemeName1Choice,

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

impl Validate for GenericFinancialIdentification1 {}


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

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

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

impl Validate for GenericIdentification20 {}


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

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


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.009.001.01")]
pub struct GuaranteeDetails1 {
    #[yaserde(rename = "Issr")]
    #[cfg_attr(feature = "serde", serde(rename = "Issr"))]
    pub issr: String,

    #[yaserde(rename = "Pos")]
    #[cfg_attr(feature = "serde", serde(rename = "Pos"))]
    pub pos: String,

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

    #[yaserde(rename = "GrntedAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "GrntedAmt"))]
    pub grnted_amt: Vec<AmountAndPeriod1>,

    #[yaserde(rename = "Xcss")]
    #[cfg_attr(feature = "serde", serde(rename = "Xcss"))]
    pub xcss: Vec<AmountAndPeriod1>,

    #[yaserde(rename = "CvrdPctg")]
    #[cfg_attr(feature = "serde", serde(rename = "CvrdPctg"))]
    pub cvrd_pctg: Vec<PercentageAndPeriod1>,

    #[yaserde(rename = "AssoctdDoc")]
    #[cfg_attr(feature = "serde", serde(rename = "AssoctdDoc"))]
    pub assoctd_doc: Vec<String>,

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

impl Validate for GuaranteeDetails1 {}


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

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

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

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

impl Validate for LegalOrganisation1 {}


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

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

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

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

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

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

impl Validate for Max6Text {
    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() > 6 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 6 \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.009.001.01")]
pub struct NameAndAddress5 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max350Text,

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

impl Validate for NameAndAddress5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsin.009.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.009.001.01")]
pub struct OrganisationIdentification6 {
    #[yaserde(rename = "BIC")]
    #[cfg_attr(feature = "serde", serde(rename = "BIC"))]
    pub bic: AnyBICIdentifier,

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

impl Validate for OrganisationIdentification6 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.009.001.01")]
pub struct OrganisationIdentification7 {
    #[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 OrganisationIdentification7 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.009.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.009.001.01")]
pub struct Party10Choice {
    #[yaserde(rename = "OrgId")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgId"))]
    pub org_id: Option<OrganisationIdentification7>,
    #[yaserde(rename = "PrvtId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvtId"))]
    pub prvt_id: Option<PersonIdentification5>,
}

impl Validate for Party10Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.009.001.01")]
pub struct Party8Choice {
    #[yaserde(rename = "OrgId")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgId"))]
    pub org_id: Option<OrganisationIdentification6>,
    #[yaserde(rename = "PrvtId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvtId"))]
    pub prvt_id: Option<PersonIdentification5>,
}

impl Validate for Party8Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.009.001.01")]
pub struct Party9Choice {
    #[yaserde(rename = "OrgId")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgId"))]
    pub org_id: Option<PartyIdentification42>,
    #[yaserde(rename = "FIId")]
    #[cfg_attr(feature = "serde", serde(rename = "FIId"))]
    pub fiid: Option<BranchAndFinancialInstitutionIdentification5>,
}

impl Validate for Party9Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.009.001.01")]
pub struct PartyIdentification2Choice {
    #[yaserde(rename = "BICOrBEI")]
    #[cfg_attr(feature = "serde", serde(rename = "BICOrBEI"))]
    pub bicor_b_e_i: Option<AnyBICIdentifier>,
    #[yaserde(rename = "PrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
    pub prtry_id: Option<GenericIdentification1>,
    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: Option<NameAndAddress5>,
}

impl Validate for PartyIdentification2Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.009.001.01")]
pub struct PartyIdentification42 {
    #[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: Party10Choice,

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


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

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

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

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

impl Validate for PartyIdentification45 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.009.001.01")]
pub struct PartyRegistrationAndGuaranteeRequestV01 {
    #[yaserde(rename = "Hdr")]
    #[cfg_attr(feature = "serde", serde(rename = "Hdr"))]
    pub hdr: BusinessLetter1,

    #[yaserde(rename = "AgrmtList")]
    #[cfg_attr(feature = "serde", serde(rename = "AgrmtList"))]
    pub agrmt_list: Vec<FinancingAgreementList1>,

    #[yaserde(rename = "AgrmtCnt")]
    #[cfg_attr(feature = "serde", serde(rename = "AgrmtCnt"))]
    pub agrmt_cnt: Max15NumericText,

    #[yaserde(rename = "ItmCnt")]
    #[cfg_attr(feature = "serde", serde(rename = "ItmCnt"))]
    pub itm_cnt: Max15NumericText,

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

    #[yaserde(rename = "AttchdMsg")]
    #[cfg_attr(feature = "serde", serde(rename = "AttchdMsg"))]
    pub attchd_msg: Vec<EncapsulatedBusinessMessage1>,
}

impl Validate for PartyRegistrationAndGuaranteeRequestV01 {}


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

pub enum PaymentInstrumentCode {
    #[yaserde(rename = "BDT")]
    #[cfg_attr(feature = "serde", serde(rename = "BDT"))]
    Bdt,
    #[yaserde(rename = "BCT")]
    #[cfg_attr(feature = "serde", serde(rename = "BCT"))]
    Bct,
    #[yaserde(rename = "CDT")]
    #[cfg_attr(feature = "serde", serde(rename = "CDT"))]
    Cdt,
    #[yaserde(rename = "CCT")]
    #[cfg_attr(feature = "serde", serde(rename = "CCT"))]
    Cct,
    #[yaserde(rename = "CHK")]
    #[cfg_attr(feature = "serde", serde(rename = "CHK"))]
    Chk,
    #[yaserde(rename = "BKT")]
    #[cfg_attr(feature = "serde", serde(rename = "BKT"))]
    Bkt,
    #[yaserde(rename = "DCP")]
    #[cfg_attr(feature = "serde", serde(rename = "DCP"))]
    Dcp,
    #[yaserde(rename = "CCP")]
    #[cfg_attr(feature = "serde", serde(rename = "CCP"))]
    Ccp,
    #[yaserde(rename = "RTI")]
    #[cfg_attr(feature = "serde", serde(rename = "RTI"))]
    Rti,
    #[yaserde(rename = "CAN")]
    #[cfg_attr(feature = "serde", serde(rename = "CAN"))]
    Can,
    __Unknown__(String),
}

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

impl Validate for PaymentInstrumentCode {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.009.001.01")]
pub struct PercentageAndPeriod1 {
    #[yaserde(rename = "Pctg")]
    #[cfg_attr(feature = "serde", serde(rename = "Pctg"))]
    pub pctg: PercentageBoundedRate,

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

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

impl Validate for PercentageAndPeriod1 {}


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

impl Validate for PercentageBoundedRate {
    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));
        }
        if self.0 > "100".parse::<String>().unwrap() {
            return Err(format!("MaxInclusive validation error: invalid value of 0! \nExpected: 0 <= 100.\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.009.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.009.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.009.001.01")]
pub struct PostalAddress1 {
    #[yaserde(rename = "AdrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "AdrTp"))]
    pub adr_tp: AddressType2Code,

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

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

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

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

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

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

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

impl Validate for PostalAddress1 {}


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

pub enum Priority3Code {
    #[yaserde(rename = "URGT")]
    #[cfg_attr(feature = "serde", serde(rename = "URGT"))]
    Urgt,
    #[yaserde(rename = "HIGH")]
    #[cfg_attr(feature = "serde", serde(rename = "HIGH"))]
    High,
    #[yaserde(rename = "NORM")]
    #[cfg_attr(feature = "serde", serde(rename = "NORM"))]
    Norm,
    __Unknown__(String),
}

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

impl Validate for Priority3Code {}



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

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

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

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

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

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

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

    #[yaserde(rename = "Dgst")]
    #[cfg_attr(feature = "serde", serde(rename = "Dgst"))]
    pub dgst: Vec<AlgorithmAndDigest1>,

    #[yaserde(rename = "DocTp")]
    #[cfg_attr(feature = "serde", serde(rename = "DocTp"))]
    pub doc_tp: ExternalDocumentType1Code,

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

    #[yaserde(rename = "AttchdFile")]
    #[cfg_attr(feature = "serde", serde(rename = "AttchdFile"))]
    pub attchd_file: Vec<BinaryFile1>,
}

impl Validate for QualifiedDocumentInformation1 {}


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

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

impl Validate for QualifiedPartyAndXMLSignature1 {}


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

    #[yaserde(rename = "Pty")]
    #[cfg_attr(feature = "serde", serde(rename = "Pty"))]
    pub pty: Vec<SingleQualifiedPartyIdentification1>,

    #[yaserde(rename = "ShrtId")]
    #[cfg_attr(feature = "serde", serde(rename = "ShrtId"))]
    pub shrt_id: PartyIdentification2Choice,

    #[yaserde(rename = "Role")]
    #[cfg_attr(feature = "serde", serde(rename = "Role"))]
    pub role: GenericIdentification1,

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

impl Validate for QualifiedPartyIdentification1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.009.001.01")]
pub struct SignatureEnvelope {}

impl Validate for SignatureEnvelope {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.009.001.01")]
pub struct SingleQualifiedPartyIdentification1 {
    #[yaserde(rename = "BasePty")]
    #[cfg_attr(feature = "serde", serde(rename = "BasePty"))]
    pub base_pty: TradeParty1,

    #[yaserde(rename = "RltvIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "RltvIdr"))]
    pub rltv_idr: Vec<Max35Text>,
}

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

impl Validate for StatusReason4Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.009.001.01")]
pub struct StrictPayload {}

impl Validate for StrictPayload {}


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

pub enum TaxExemptReason1Code {
    #[yaserde(rename = "NONE")]
    #[cfg_attr(feature = "serde", serde(rename = "NONE"))]
    None,
    #[yaserde(rename = "MASA")]
    #[cfg_attr(feature = "serde", serde(rename = "MASA"))]
    Masa,
    #[yaserde(rename = "MISA")]
    #[cfg_attr(feature = "serde", serde(rename = "MISA"))]
    Misa,
    #[yaserde(rename = "SISA")]
    #[cfg_attr(feature = "serde", serde(rename = "SISA"))]
    Sisa,
    #[yaserde(rename = "IISA")]
    #[cfg_attr(feature = "serde", serde(rename = "IISA"))]
    Iisa,
    #[yaserde(rename = "CUYP")]
    #[cfg_attr(feature = "serde", serde(rename = "CUYP"))]
    Cuyp,
    #[yaserde(rename = "PRYP")]
    #[cfg_attr(feature = "serde", serde(rename = "PRYP"))]
    Pryp,
    #[yaserde(rename = "ASTR")]
    #[cfg_attr(feature = "serde", serde(rename = "ASTR"))]
    Astr,
    #[yaserde(rename = "EMPY")]
    #[cfg_attr(feature = "serde", serde(rename = "EMPY"))]
    Empy,
    #[yaserde(rename = "EMCY")]
    #[cfg_attr(feature = "serde", serde(rename = "EMCY"))]
    Emcy,
    #[yaserde(rename = "EPRY")]
    #[cfg_attr(feature = "serde", serde(rename = "EPRY"))]
    Epry,
    #[yaserde(rename = "ECYE")]
    #[cfg_attr(feature = "serde", serde(rename = "ECYE"))]
    Ecye,
    #[yaserde(rename = "NFPI")]
    #[cfg_attr(feature = "serde", serde(rename = "NFPI"))]
    Nfpi,
    #[yaserde(rename = "NFQP")]
    #[cfg_attr(feature = "serde", serde(rename = "NFQP"))]
    Nfqp,
    #[yaserde(rename = "DECP")]
    #[cfg_attr(feature = "serde", serde(rename = "DECP"))]
    Decp,
    #[yaserde(rename = "IRAC")]
    #[cfg_attr(feature = "serde", serde(rename = "IRAC"))]
    Irac,
    #[yaserde(rename = "IRAR")]
    #[cfg_attr(feature = "serde", serde(rename = "IRAR"))]
    Irar,
    #[yaserde(rename = "KEOG")]
    #[cfg_attr(feature = "serde", serde(rename = "KEOG"))]
    Keog,
    #[yaserde(rename = "PFSP")]
    #[cfg_attr(feature = "serde", serde(rename = "PFSP"))]
    Pfsp,
    #[yaserde(rename = "401K")]
    #[cfg_attr(feature = "serde", serde(rename = "401K"))]
    _401K,
    #[yaserde(rename = "SIRA")]
    #[cfg_attr(feature = "serde", serde(rename = "SIRA"))]
    Sira,
    #[yaserde(rename = "403B")]
    #[cfg_attr(feature = "serde", serde(rename = "403B"))]
    _403B,
    #[yaserde(rename = "457X")]
    #[cfg_attr(feature = "serde", serde(rename = "457X"))]
    _457X,
    #[yaserde(rename = "RIRA")]
    #[cfg_attr(feature = "serde", serde(rename = "RIRA"))]
    Rira,
    #[yaserde(rename = "RIAN")]
    #[cfg_attr(feature = "serde", serde(rename = "RIAN"))]
    Rian,
    #[yaserde(rename = "RCRF")]
    #[cfg_attr(feature = "serde", serde(rename = "RCRF"))]
    Rcrf,
    #[yaserde(rename = "RCIP")]
    #[cfg_attr(feature = "serde", serde(rename = "RCIP"))]
    Rcip,
    #[yaserde(rename = "EIFP")]
    #[cfg_attr(feature = "serde", serde(rename = "EIFP"))]
    Eifp,
    #[yaserde(rename = "EIOP")]
    #[cfg_attr(feature = "serde", serde(rename = "EIOP"))]
    Eiop,
    __Unknown__(String),
}

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

impl Validate for TaxExemptReason1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.009.001.01")]
pub struct TaxExemptionReasonFormatChoice {
    #[yaserde(rename = "Ustrd")]
    #[cfg_attr(feature = "serde", serde(rename = "Ustrd"))]
    pub ustrd: Option<Max140Text>,
    #[yaserde(rename = "Strd")]
    #[cfg_attr(feature = "serde", serde(rename = "Strd"))]
    pub strd: Option<TaxExemptReason1Code>,
}

impl Validate for TaxExemptionReasonFormatChoice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.009.001.01")]
pub struct TaxParty3 {
    #[yaserde(rename = "TaxId")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxId"))]
    pub tax_id: Max35Text,

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

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

    #[yaserde(rename = "TaxXmptnRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxXmptnRsn"))]
    pub tax_xmptn_rsn: Vec<TaxExemptionReasonFormatChoice>,
}

impl Validate for TaxParty3 {}


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

pub enum TechnicalValidationStatus1Code {
    #[yaserde(rename = "RCCF")]
    #[cfg_attr(feature = "serde", serde(rename = "RCCF"))]
    Rccf,
    #[yaserde(rename = "RCER")]
    #[cfg_attr(feature = "serde", serde(rename = "RCER"))]
    Rcer,
    __Unknown__(String),
}

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

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

impl Validate for TradeMarket1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.009.001.01")]
pub struct TradeParty1 {
    #[yaserde(rename = "PtyId")]
    #[cfg_attr(feature = "serde", serde(rename = "PtyId"))]
    pub pty_id: PartyIdentification45,

    #[yaserde(rename = "LglOrg")]
    #[cfg_attr(feature = "serde", serde(rename = "LglOrg"))]
    pub lgl_org: LegalOrganisation1,

    #[yaserde(rename = "TaxPty")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxPty"))]
    pub tax_pty: Vec<TaxParty3>,
}

impl Validate for TradeParty1 {}


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

impl Validate for UnicodeChartsCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.009.001.01")]
pub struct ValidationStatusInformation1 {
    #[yaserde(rename = "Sts")]
    #[cfg_attr(feature = "serde", serde(rename = "Sts"))]
    pub sts: TechnicalValidationStatus1Code,

    #[yaserde(rename = "StsRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "StsRsn"))]
    pub sts_rsn: StatusReason4Choice,

    #[yaserde(rename = "AddtlStsRsnInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlStsRsnInf"))]
    pub addtl_sts_rsn_inf: Vec<Max105Text>,
}

impl Validate for ValidationStatusInformation1 {}


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