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.001.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.001.001.01")]
pub struct ActiveCurrencyAndAmount {
    #[yaserde(text)]
    pub value: String,
    #[yaserde(attribute, rename = "Ccy")]
    #[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
    pub ccy: ActiveCurrencyCode,
}

impl Validate for ActiveCurrencyAndAmount {}


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

impl Validate for ActiveCurrencyCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsin.001.001.01")]
pub struct AdditionalInformation1 {
    #[yaserde(rename = "InfTp")]
    #[cfg_attr(feature = "serde", serde(rename = "InfTp"))]
    pub inf_tp: InformationType1Choice,

    #[yaserde(rename = "InfVal")]
    #[cfg_attr(feature = "serde", serde(rename = "InfVal"))]
    pub inf_val: Max350Text,
}

impl Validate for AdditionalInformation1 {}


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

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

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

impl Validate for AddressType2Code {}



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

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

impl Validate for Adjustment5 {}


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

pub enum AdjustmentDirection1Code {
    #[yaserde(rename = "ADDD")]
    #[cfg_attr(feature = "serde", serde(rename = "ADDD"))]
    Addd,
    #[yaserde(rename = "SUBS")]
    #[cfg_attr(feature = "serde", serde(rename = "SUBS"))]
    Subs,
    __Unknown__(String),
}

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

impl Validate for AdjustmentDirection1Code {}



#[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.001.001.01")]
pub struct AgreementClauses1 {
    #[yaserde(rename = "Desc")]
    #[cfg_attr(feature = "serde", serde(rename = "Desc"))]
    pub desc: Max256Text,

    #[yaserde(rename = "DocURL")]
    #[cfg_attr(feature = "serde", serde(rename = "DocURL"))]
    pub doc_url: Max350Text,
}

impl Validate for AgreementClauses1 {}


#[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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsin.001.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.001.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.001.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.001.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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsin.001.001.01")]
pub struct ContactIdentification1 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max35Text,

    #[yaserde(rename = "NmPrfx")]
    #[cfg_attr(feature = "serde", serde(rename = "NmPrfx"))]
    pub nm_prfx: NamePrefix1Code,

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

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

    #[yaserde(rename = "PhneNb")]
    #[cfg_attr(feature = "serde", serde(rename = "PhneNb"))]
    pub phne_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: Max256Text,
}

impl Validate for ContactIdentification1 {}


#[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.001.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.001.001.01")]
pub struct Document {
    #[yaserde(rename = "InvcFincgReq")]
    #[cfg_attr(feature = "serde", serde(rename = "InvcFincgReq"))]
    pub invc_fincg_req: InvoiceFinancingRequestV01,
}

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

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

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

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

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

impl Validate for DocumentGeneralInformation1 {}


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

pub enum DocumentType2Code {
    #[yaserde(rename = "MSIN")]
    #[cfg_attr(feature = "serde", serde(rename = "MSIN"))]
    Msin,
    #[yaserde(rename = "CNFA")]
    #[cfg_attr(feature = "serde", serde(rename = "CNFA"))]
    Cnfa,
    #[yaserde(rename = "DNFA")]
    #[cfg_attr(feature = "serde", serde(rename = "DNFA"))]
    Dnfa,
    #[yaserde(rename = "CINV")]
    #[cfg_attr(feature = "serde", serde(rename = "CINV"))]
    Cinv,
    #[yaserde(rename = "CREN")]
    #[cfg_attr(feature = "serde", serde(rename = "CREN"))]
    Cren,
    #[yaserde(rename = "DEBN")]
    #[cfg_attr(feature = "serde", serde(rename = "DEBN"))]
    Debn,
    #[yaserde(rename = "HIRI")]
    #[cfg_attr(feature = "serde", serde(rename = "HIRI"))]
    Hiri,
    #[yaserde(rename = "SBIN")]
    #[cfg_attr(feature = "serde", serde(rename = "SBIN"))]
    Sbin,
    #[yaserde(rename = "CMCN")]
    #[cfg_attr(feature = "serde", serde(rename = "CMCN"))]
    Cmcn,
    #[yaserde(rename = "SOAC")]
    #[cfg_attr(feature = "serde", serde(rename = "SOAC"))]
    Soac,
    #[yaserde(rename = "DISP")]
    #[cfg_attr(feature = "serde", serde(rename = "DISP"))]
    Disp,
    __Unknown__(String),
}

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

impl Validate for DocumentType2Code {}



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

pub enum DocumentType4Code {
    #[yaserde(rename = "CINV")]
    #[cfg_attr(feature = "serde", serde(rename = "CINV"))]
    Cinv,
    __Unknown__(String),
}

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

impl Validate for DocumentType4Code {}



#[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.001.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.001.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.001.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.001.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.001.001.01")]
pub struct InformationType1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<InformationType1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max140Text>,
}

impl Validate for InformationType1Choice {}




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

pub enum InformationType1Code {
    #[yaserde(rename = "INST")]
    #[cfg_attr(feature = "serde", serde(rename = "INST"))]
    Inst,
    #[yaserde(rename = "RELY")]
    #[cfg_attr(feature = "serde", serde(rename = "RELY"))]
    Rely,
    __Unknown__(String),
}

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

impl Validate for InformationType1Code {}



#[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.001.001.01")]
pub struct Instalment1 {
    #[yaserde(rename = "SeqId")]
    #[cfg_attr(feature = "serde", serde(rename = "SeqId"))]
    pub seq_id: Max70Text,

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

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

impl Validate for Instalment1 {}


#[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.001.001.01")]
pub struct InvoiceFinancingRequestV01 {
    #[yaserde(rename = "ReqGrpInf")]
    #[cfg_attr(feature = "serde", serde(rename = "ReqGrpInf"))]
    pub req_grp_inf: RequestGroupInformation1,

    #[yaserde(rename = "InvcReqInf")]
    #[cfg_attr(feature = "serde", serde(rename = "InvcReqInf"))]
    pub invc_req_inf: Vec<InvoiceRequestInformation1>,
}

impl Validate for InvoiceFinancingRequestV01 {}


#[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.001.001.01")]
pub struct InvoiceRequestInformation1 {
    #[yaserde(rename = "InvcGnlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "InvcGnlInf"))]
    pub invc_gnl_inf: DocumentGeneralInformation1,

    #[yaserde(rename = "InvcTtlsInf")]
    #[cfg_attr(feature = "serde", serde(rename = "InvcTtlsInf"))]
    pub invc_ttls_inf: InvoiceTotals1,

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

    #[yaserde(rename = "InstlmtInf")]
    #[cfg_attr(feature = "serde", serde(rename = "InstlmtInf"))]
    pub instlmt_inf: Vec<Instalment1>,

    #[yaserde(rename = "ReqdAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "ReqdAmt"))]
    pub reqd_amt: FinancingRateOrAmountChoice,

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

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

    #[yaserde(rename = "InvcPmtInf")]
    #[cfg_attr(feature = "serde", serde(rename = "InvcPmtInf"))]
    pub invc_pmt_inf: PaymentInformation15,

    #[yaserde(rename = "RfrdDoc")]
    #[cfg_attr(feature = "serde", serde(rename = "RfrdDoc"))]
    pub rfrd_doc: Vec<ReferredDocumentInformation2>,
}

impl Validate for InvoiceRequestInformation1 {}


#[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.001.001.01")]
pub struct InvoiceTotals1 {
    #[yaserde(rename = "TtlTaxblAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlTaxblAmt"))]
    pub ttl_taxbl_amt: ActiveCurrencyAndAmount,

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

    #[yaserde(rename = "Adjstmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "Adjstmnt"))]
    pub adjstmnt: Adjustment5,

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

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

impl Validate for InvoiceTotals1 {}


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

impl Validate for Max128Text {
    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() > 128 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 128 \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 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 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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsin.001.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)]
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsin.001.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.001.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.001.001.01")]
pub struct PartyAndAccountIdentificationAndContactInformation1 {
    #[yaserde(rename = "PtyId")]
    #[cfg_attr(feature = "serde", serde(rename = "PtyId"))]
    pub pty_id: PartyIdentification8,

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

    #[yaserde(rename = "CtctInf")]
    #[cfg_attr(feature = "serde", serde(rename = "CtctInf"))]
    pub ctct_inf: ContactIdentification1,
}

impl Validate for PartyAndAccountIdentificationAndContactInformation1 {}


#[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.001.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.001.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.001.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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsin.001.001.01")]
pub struct PartyIdentificationAndContactInformation1 {
    #[yaserde(rename = "PtyId")]
    #[cfg_attr(feature = "serde", serde(rename = "PtyId"))]
    pub pty_id: PartyIdentification8,

    #[yaserde(rename = "CtctInf")]
    #[cfg_attr(feature = "serde", serde(rename = "CtctInf"))]
    pub ctct_inf: ContactIdentification1,
}

impl Validate for PartyIdentificationAndContactInformation1 {}


#[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.001.001.01")]
pub struct PaymentInformation15 {
    #[yaserde(rename = "PmtMtd")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtMtd"))]
    pub pmt_mtd: PaymentMethod4Code,

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

impl Validate for PaymentInformation15 {}


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

pub enum PaymentMethod4Code {
    #[yaserde(rename = "CHK")]
    #[cfg_attr(feature = "serde", serde(rename = "CHK"))]
    Chk,
    #[yaserde(rename = "TRF")]
    #[cfg_attr(feature = "serde", serde(rename = "TRF"))]
    Trf,
    #[yaserde(rename = "DD")]
    #[cfg_attr(feature = "serde", serde(rename = "DD"))]
    Dd,
    #[yaserde(rename = "TRA")]
    #[cfg_attr(feature = "serde", serde(rename = "TRA"))]
    Tra,
    __Unknown__(String),
}

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

impl Validate for PaymentMethod4Code {}



#[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.001.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 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)]
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.001.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.001.001.01")]
pub struct ReferredDocumentInformation2 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: ReferredDocumentType1,

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

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

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

impl Validate for ReferredDocumentInformation2 {}


#[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.001.001.01")]
pub struct ReferredDocumentType1 {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<DocumentType2Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max35Text>,

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

impl Validate for ReferredDocumentType1 {}

pub mod referred_document_type_1 {
    use super::*;
}

#[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.001.001.01")]
pub struct RequestGroupInformation1 {
    #[yaserde(rename = "GrpId")]
    #[cfg_attr(feature = "serde", serde(rename = "GrpId"))]
    pub grp_id: Max35Text,

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

    #[yaserde(rename = "Authstn")]
    #[cfg_attr(feature = "serde", serde(rename = "Authstn"))]
    pub authstn: Vec<Max128Text>,

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

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

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

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

    #[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 = "AgrmtClauses")]
    #[cfg_attr(feature = "serde", serde(rename = "AgrmtClauses"))]
    pub agrmt_clauses: Vec<AgreementClauses1>,

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

impl Validate for RequestGroupInformation1 {}


#[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.001.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)]
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(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 {}

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