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.002.001.01")]
pub struct AccountIdentification3Choice {
    #[yaserde(rename = "IBAN")]
    #[cfg_attr(feature = "serde", serde(rename = "IBAN"))]
    pub iban: Option<Ibanidentifier>,
    #[yaserde(rename = "BBAN")]
    #[cfg_attr(feature = "serde", serde(rename = "BBAN"))]
    pub bban: Option<Bbanidentifier>,
    #[yaserde(rename = "UPIC")]
    #[cfg_attr(feature = "serde", serde(rename = "UPIC"))]
    pub upic: Option<Upicidentifier>,
    #[yaserde(rename = "PrtryAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryAcct"))]
    pub prtry_acct: Option<SimpleIdentificationInformation2>,
}

impl Validate for AccountIdentification3Choice {}




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

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

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

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

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

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

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

impl Validate for CanadianPaymentsARNIdentifier {}
#[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.002.001.01")]

pub enum CancellationStatus4Code {
    #[yaserde(rename = "PACK")]
    #[cfg_attr(feature = "serde", serde(rename = "PACK"))]
    Pack,
    #[yaserde(rename = "REJT")]
    #[cfg_attr(feature = "serde", serde(rename = "REJT"))]
    Rejt,
    __Unknown__(String),
}

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

impl Validate for CancellationStatus4Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.001.01")]
pub struct CancellationStatusInformation1 {
    #[yaserde(rename = "Sts")]
    #[cfg_attr(feature = "serde", serde(rename = "Sts"))]
    pub sts: CancellationStatus4Code,

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


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

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

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

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

impl Validate for CashAccount7 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.001.01")]
pub struct CashAccountType2 {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<CashAccountType4Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max35Text>,
}

impl Validate for CashAccountType2 {}

pub mod cash_account_type_2 {
    use super::*;
}

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

pub enum CashAccountType4Code {
    #[yaserde(rename = "CASH")]
    #[cfg_attr(feature = "serde", serde(rename = "CASH"))]
    Cash,
    #[yaserde(rename = "CHAR")]
    #[cfg_attr(feature = "serde", serde(rename = "CHAR"))]
    Char,
    #[yaserde(rename = "COMM")]
    #[cfg_attr(feature = "serde", serde(rename = "COMM"))]
    Comm,
    #[yaserde(rename = "TAXE")]
    #[cfg_attr(feature = "serde", serde(rename = "TAXE"))]
    Taxe,
    #[yaserde(rename = "CISH")]
    #[cfg_attr(feature = "serde", serde(rename = "CISH"))]
    Cish,
    #[yaserde(rename = "TRAS")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAS"))]
    Tras,
    #[yaserde(rename = "SACC")]
    #[cfg_attr(feature = "serde", serde(rename = "SACC"))]
    Sacc,
    #[yaserde(rename = "CACC")]
    #[cfg_attr(feature = "serde", serde(rename = "CACC"))]
    Cacc,
    #[yaserde(rename = "SVGS")]
    #[cfg_attr(feature = "serde", serde(rename = "SVGS"))]
    Svgs,
    #[yaserde(rename = "ONDP")]
    #[cfg_attr(feature = "serde", serde(rename = "ONDP"))]
    Ondp,
    #[yaserde(rename = "MGLD")]
    #[cfg_attr(feature = "serde", serde(rename = "MGLD"))]
    Mgld,
    #[yaserde(rename = "NREX")]
    #[cfg_attr(feature = "serde", serde(rename = "NREX"))]
    Nrex,
    #[yaserde(rename = "MOMA")]
    #[cfg_attr(feature = "serde", serde(rename = "MOMA"))]
    Moma,
    #[yaserde(rename = "LOAN")]
    #[cfg_attr(feature = "serde", serde(rename = "LOAN"))]
    Loan,
    #[yaserde(rename = "SLRY")]
    #[cfg_attr(feature = "serde", serde(rename = "SLRY"))]
    Slry,
    #[yaserde(rename = "ODFT")]
    #[cfg_attr(feature = "serde", serde(rename = "ODFT"))]
    Odft,
    __Unknown__(String),
}

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

impl Validate for CashAccountType4Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.001.01")]
pub struct ClearingSystemMemberIdentification2Choice {
    #[yaserde(rename = "USCHU")]
    #[cfg_attr(feature = "serde", serde(rename = "USCHU"))]
    pub uschu: Option<ChipsuniversalIdentifier>,
    #[yaserde(rename = "NZNCC")]
    #[cfg_attr(feature = "serde", serde(rename = "NZNCC"))]
    pub nzncc: Option<NewZealandNCCIdentifier>,
    #[yaserde(rename = "IENSC")]
    #[cfg_attr(feature = "serde", serde(rename = "IENSC"))]
    pub iensc: Option<IrishNSCIdentifier>,
    #[yaserde(rename = "GBSC")]
    #[cfg_attr(feature = "serde", serde(rename = "GBSC"))]
    pub gbsc: Option<UkdomesticSortCodeIdentifier>,
    #[yaserde(rename = "USCH")]
    #[cfg_attr(feature = "serde", serde(rename = "USCH"))]
    pub usch: Option<ChipsparticipantIdentifier>,
    #[yaserde(rename = "CHBC")]
    #[cfg_attr(feature = "serde", serde(rename = "CHBC"))]
    pub chbc: Option<SwissBCIdentifier>,
    #[yaserde(rename = "USFW")]
    #[cfg_attr(feature = "serde", serde(rename = "USFW"))]
    pub usfw: Option<FedwireRoutingNumberIdentifier>,
    #[yaserde(rename = "PTNCC")]
    #[cfg_attr(feature = "serde", serde(rename = "PTNCC"))]
    pub ptncc: Option<PortugueseNCCIdentifier>,
    #[yaserde(rename = "RUCB")]
    #[cfg_attr(feature = "serde", serde(rename = "RUCB"))]
    pub rucb: Option<RussianCentralBankIdentificationCodeIdentifier>,
    #[yaserde(rename = "ITNCC")]
    #[cfg_attr(feature = "serde", serde(rename = "ITNCC"))]
    pub itncc: Option<ItalianDomesticIdentifier>,
    #[yaserde(rename = "ATBLZ")]
    #[cfg_attr(feature = "serde", serde(rename = "ATBLZ"))]
    pub atblz: Option<AustrianBankleitzahlIdentifier>,
    #[yaserde(rename = "CACPA")]
    #[cfg_attr(feature = "serde", serde(rename = "CACPA"))]
    pub cacpa: Option<CanadianPaymentsARNIdentifier>,
    #[yaserde(rename = "CHSIC")]
    #[cfg_attr(feature = "serde", serde(rename = "CHSIC"))]
    pub chsic: Option<SwissSICIdentifier>,
    #[yaserde(rename = "DEBLZ")]
    #[cfg_attr(feature = "serde", serde(rename = "DEBLZ"))]
    pub deblz: Option<GermanBankleitzahlIdentifier>,
    #[yaserde(rename = "ESNCC")]
    #[cfg_attr(feature = "serde", serde(rename = "ESNCC"))]
    pub esncc: Option<SpanishDomesticInterbankingIdentifier>,
    #[yaserde(rename = "ZANCC")]
    #[cfg_attr(feature = "serde", serde(rename = "ZANCC"))]
    pub zancc: Option<SouthAfricanNCCIdentifier>,
    #[yaserde(rename = "HKNCC")]
    #[cfg_attr(feature = "serde", serde(rename = "HKNCC"))]
    pub hkncc: Option<HongKongBankIdentifier>,
    #[yaserde(rename = "AUBSBx")]
    #[cfg_attr(feature = "serde", serde(rename = "AUBSBx"))]
    pub aubsbx: Option<ExtensiveBranchNetworkIdentifier>,
    #[yaserde(rename = "AUBSBs")]
    #[cfg_attr(feature = "serde", serde(rename = "AUBSBs"))]
    pub aubsbs: Option<SmallNetworkIdentifier>,
    #[yaserde(rename = "INIFSC")]
    #[cfg_attr(feature = "serde", serde(rename = "INIFSC"))]
    pub inifsc: Option<IndianFinancialSystemCodeIdentifier>,
    #[yaserde(rename = "GRHEBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "GRHEBIC"))]
    pub grhebic: Option<HellenicBankIdentificationCodeIdentifier>,
    #[yaserde(rename = "PLKNR")]
    #[cfg_attr(feature = "serde", serde(rename = "PLKNR"))]
    pub plknr: Option<PolishNationalClearingCodeIdentifier>,
    #[yaserde(rename = "OthrClrCdId")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrClrCdId"))]
    pub othr_clr_cd_id: Option<Max35Text>,
}

impl Validate for ClearingSystemMemberIdentification2Choice {}




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

impl Validate for CountryCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct 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.002.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.002.001.01")]
pub struct Document {
    #[yaserde(rename = "InvcFincgReqSts")]
    #[cfg_attr(feature = "serde", serde(rename = "InvcFincgReqSts"))]
    pub invc_fincg_req_sts: InvoiceFinancingRequestStatusV01,
}

impl Validate for Document {}


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

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

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

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

impl Validate for FedwireRoutingNumberIdentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.001.01")]
pub struct FinancialInstitutionIdentification6 {
    #[yaserde(rename = "ClrSysMmbId")]
    #[cfg_attr(feature = "serde", serde(rename = "ClrSysMmbId"))]
    pub clr_sys_mmb_id: ClearingSystemMemberIdentification2Choice,

    #[yaserde(rename = "PrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
    pub prtry_id: GenericIdentification4,

    #[yaserde(rename = "BIC")]
    #[cfg_attr(feature = "serde", serde(rename = "BIC"))]
    pub bic: Bicidentifier,
}

impl Validate for FinancialInstitutionIdentification6 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.001.01")]
pub struct FinancingAllowedSummary1 {
    #[yaserde(rename = "FincdItmNb")]
    #[cfg_attr(feature = "serde", serde(rename = "FincdItmNb"))]
    pub fincd_itm_nb: Number,

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

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

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

    #[yaserde(rename = "FincgDtDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "FincgDtDtls"))]
    pub fincg_dt_dtls: FinancingDateDetails1,

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

    #[yaserde(rename = "FincgAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "FincgAcct"))]
    pub fincg_acct: CashAccount7,
}

impl Validate for FinancingAllowedSummary1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.001.01")]
pub struct FinancingDateDetails1 {
    #[yaserde(rename = "BookDt")]
    #[cfg_attr(feature = "serde", serde(rename = "BookDt"))]
    pub book_dt: Vec<Isodate>,

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

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

impl Validate for FinancingDateDetails1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.001.01")]
pub struct FinancingInformationAndStatus1 {
    #[yaserde(rename = "FincgAllwdSummry")]
    #[cfg_attr(feature = "serde", serde(rename = "FincgAllwdSummry"))]
    pub fincg_allwd_summry: FinancingAllowedSummary1,

    #[yaserde(rename = "InvcFincgDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "InvcFincgDtls"))]
    pub invc_fincg_dtls: Vec<InvoiceFinancingDetails1>,
}

impl Validate for FinancingInformationAndStatus1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.001.01")]
pub struct FinancingRateOrAmountChoice {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<ActiveCurrencyAndAmount>,
    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: Option<PercentageRate>,
}

impl Validate for FinancingRateOrAmountChoice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.001.01")]
pub struct FinancingResult1 {
    #[yaserde(rename = "FincgReqSts")]
    #[cfg_attr(feature = "serde", serde(rename = "FincgReqSts"))]
    pub fincg_req_sts: RequestStatus1Code,

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

    #[yaserde(rename = "FincdAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "FincdAmt"))]
    pub fincd_amt: FinancingRateOrAmountChoice,
}

impl Validate for FinancingResult1 {}


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

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

impl Validate for GenericIdentification3 {}


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

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

impl Validate for GenericIdentification4 {}


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

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

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

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

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

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

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

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

impl Validate for IndianFinancialSystemCodeIdentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.001.01")]
pub struct InstalmentFinancingInformation1 {
    #[yaserde(rename = "InstlmtSeqId")]
    #[cfg_attr(feature = "serde", serde(rename = "InstlmtSeqId"))]
    pub instlmt_seq_id: Max70Text,

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

    #[yaserde(rename = "InstlmtFincgRslt")]
    #[cfg_attr(feature = "serde", serde(rename = "InstlmtFincgRslt"))]
    pub instlmt_fincg_rslt: FinancingResult1,
}

impl Validate for InstalmentFinancingInformation1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.001.01")]
pub struct InvoiceFinancingDetails1 {
    #[yaserde(rename = "OrgnlInvcInf")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlInvcInf"))]
    pub orgnl_invc_inf: OriginalInvoiceInformation1,

    #[yaserde(rename = "Spplr")]
    #[cfg_attr(feature = "serde", serde(rename = "Spplr"))]
    pub spplr: PartyIdentification8,

    #[yaserde(rename = "InvcFincgRslt")]
    #[cfg_attr(feature = "serde", serde(rename = "InvcFincgRslt"))]
    pub invc_fincg_rslt: FinancingResult1,

    #[yaserde(rename = "InstlmtFincgInf")]
    #[cfg_attr(feature = "serde", serde(rename = "InstlmtFincgInf"))]
    pub instlmt_fincg_inf: Vec<InstalmentFinancingInformation1>,
}

impl Validate for InvoiceFinancingDetails1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.001.01")]
pub struct InvoiceFinancingRequestStatusV01 {
    #[yaserde(rename = "StsId")]
    #[cfg_attr(feature = "serde", serde(rename = "StsId"))]
    pub sts_id: MessageIdentification1,

    #[yaserde(rename = "OrgnlReqInfAndSts")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlReqInfAndSts"))]
    pub orgnl_req_inf_and_sts: OriginalRequestInformation1,

    #[yaserde(rename = "FincgInfAndSts")]
    #[cfg_attr(feature = "serde", serde(rename = "FincgInfAndSts"))]
    pub fincg_inf_and_sts: FinancingInformationAndStatus1,
}

impl Validate for InvoiceFinancingRequestStatusV01 {}


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

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

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

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

impl Validate for MessageIdentification1 {}


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

impl Validate for NewZealandNCCIdentifier {}
#[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.002.001.01")]
pub struct OrganisationIdentification2 {
    #[yaserde(rename = "BIC")]
    #[cfg_attr(feature = "serde", serde(rename = "BIC"))]
    pub bic: Bicidentifier,

    #[yaserde(rename = "IBEI")]
    #[cfg_attr(feature = "serde", serde(rename = "IBEI"))]
    pub ibei: Ibeiidentifier,

    #[yaserde(rename = "BEI")]
    #[cfg_attr(feature = "serde", serde(rename = "BEI"))]
    pub bei: Beiidentifier,

    #[yaserde(rename = "EANGLN")]
    #[cfg_attr(feature = "serde", serde(rename = "EANGLN"))]
    pub eangln: Eanglnidentifier,

    #[yaserde(rename = "USCHU")]
    #[cfg_attr(feature = "serde", serde(rename = "USCHU"))]
    pub uschu: ChipsuniversalIdentifier,

    #[yaserde(rename = "DUNS")]
    #[cfg_attr(feature = "serde", serde(rename = "DUNS"))]
    pub duns: DunsIdentifier,

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

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

    #[yaserde(rename = "PrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
    pub prtry_id: GenericIdentification3,
}

impl Validate for OrganisationIdentification2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.001.01")]
pub struct OriginalInvoiceInformation1 {
    #[yaserde(rename = "DocNb")]
    #[cfg_attr(feature = "serde", serde(rename = "DocNb"))]
    pub doc_nb: Max35Text,

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

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

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

impl Validate for OriginalInvoiceInformation1 {}


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

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

    #[yaserde(rename = "FincgRqstr")]
    #[cfg_attr(feature = "serde", serde(rename = "FincgRqstr"))]
    pub fincg_rqstr: PartyIdentificationAndAccount6,

    #[yaserde(rename = "IntrmyAgt")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrmyAgt"))]
    pub intrmy_agt: FinancialInstitutionIdentification6,

    #[yaserde(rename = "FrstAgt")]
    #[cfg_attr(feature = "serde", serde(rename = "FrstAgt"))]
    pub frst_agt: FinancialInstitutionIdentification6,

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

    #[yaserde(rename = "CxlStsInf")]
    #[cfg_attr(feature = "serde", serde(rename = "CxlStsInf"))]
    pub cxl_sts_inf: CancellationStatusInformation1,
}

impl Validate for OriginalRequestInformation1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.001.01")]
pub struct Party2Choice {
    #[yaserde(rename = "OrgId")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgId"))]
    pub org_id: Option<OrganisationIdentification2>,
    #[yaserde(rename = "PrvtId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvtId"))]
    pub prvt_id: Vec<PersonIdentification3>,
}

impl Validate for Party2Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.001.01")]
pub struct PartyIdentification25 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max70Text,

    #[yaserde(rename = "PrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
    pub prtry_id: GenericIdentification4,

    #[yaserde(rename = "BEI")]
    #[cfg_attr(feature = "serde", serde(rename = "BEI"))]
    pub bei: Beiidentifier,
}

impl Validate for PartyIdentification25 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.001.01")]
pub struct PartyIdentification8 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max70Text,

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

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

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

impl Validate for PartyIdentification8 {}


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

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

    #[yaserde(rename = "FincgAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "FincgAcct"))]
    pub fincg_acct: CashAccount7,
}

impl Validate for PartyIdentificationAndAccount6 {}


#[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.002.001.01")]
pub struct PersonIdentification3 {
    #[yaserde(rename = "DrvrsLicNb")]
    #[cfg_attr(feature = "serde", serde(rename = "DrvrsLicNb"))]
    pub drvrs_lic_nb: Option<Max35Text>,
    #[yaserde(rename = "CstmrNb")]
    #[cfg_attr(feature = "serde", serde(rename = "CstmrNb"))]
    pub cstmr_nb: Option<Max35Text>,
    #[yaserde(rename = "SclSctyNb")]
    #[cfg_attr(feature = "serde", serde(rename = "SclSctyNb"))]
    pub scl_scty_nb: Option<Max35Text>,
    #[yaserde(rename = "AlnRegnNb")]
    #[cfg_attr(feature = "serde", serde(rename = "AlnRegnNb"))]
    pub aln_regn_nb: Option<Max35Text>,
    #[yaserde(rename = "PsptNb")]
    #[cfg_attr(feature = "serde", serde(rename = "PsptNb"))]
    pub pspt_nb: Option<Max35Text>,
    #[yaserde(rename = "TaxIdNb")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxIdNb"))]
    pub tax_id_nb: Option<Max35Text>,
    #[yaserde(rename = "IdntyCardNb")]
    #[cfg_attr(feature = "serde", serde(rename = "IdntyCardNb"))]
    pub idnty_card_nb: Option<Max35Text>,
    #[yaserde(rename = "MplyrIdNb")]
    #[cfg_attr(feature = "serde", serde(rename = "MplyrIdNb"))]
    pub mplyr_id_nb: Option<Max35Text>,
    #[yaserde(rename = "DtAndPlcOfBirth")]
    #[cfg_attr(feature = "serde", serde(rename = "DtAndPlcOfBirth"))]
    pub dt_and_plc_of_birth: Option<DateAndPlaceOfBirth>,
    #[yaserde(rename = "OthrId")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrId"))]
    pub othr_id: Option<GenericIdentification4>,

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

impl Validate for PersonIdentification3 {}

pub mod person_identification_3 {
    use super::*;
}

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

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

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

pub enum RequestStatus1Code {
    #[yaserde(rename = "FNCD")]
    #[cfg_attr(feature = "serde", serde(rename = "FNCD"))]
    Fncd,
    #[yaserde(rename = "PDNG")]
    #[cfg_attr(feature = "serde", serde(rename = "PDNG"))]
    Pdng,
    #[yaserde(rename = "NTFD")]
    #[cfg_attr(feature = "serde", serde(rename = "NTFD"))]
    Ntfd,
    __Unknown__(String),
}

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

impl Validate for RequestStatus1Code {}



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

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

impl Validate for SimpleIdentificationInformation2 {}


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

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

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

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

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

impl Validate for SwissSICIdentifier {}
#[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.002.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)]
pub struct UkdomesticSortCodeIdentifier (pub String);
crate::simple_type!(UkdomesticSortCodeIdentifier);

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

impl Validate for Upicidentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.002.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 {}

impl crate::MxMessage for Document {
    const BUSINESS_AREA: crate::BusinessArea = crate::BusinessArea::tsin;
    const FUNCTIONALITY: &'static str = "002";
    const VARIANT: &'static str = "001";
    const VERSION: &'static str = "01";
    const MESSAGE_NAME: &'static str = "tsin.002.001.01";
    const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:tsin.002.001.01";
}