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

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

impl Validate for AccountSchemeName1Choice {}




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

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

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

impl Validate for ActiveCurrencyAndAmount {}


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

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

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

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:auth.022.001.04")]
pub struct AddressType3Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<AddressType2Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification30>,
}

impl Validate for AddressType3Choice {}




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

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

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

impl Validate for BaseOneRate {}
#[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:auth.022.001.04")]

pub enum BenchmarkCurveName2Code {
    #[yaserde(rename = "WIBO")]
    #[cfg_attr(feature = "serde", serde(rename = "WIBO"))]
    Wibo,
    #[yaserde(rename = "TREA")]
    #[cfg_attr(feature = "serde", serde(rename = "TREA"))]
    Trea,
    #[yaserde(rename = "TIBO")]
    #[cfg_attr(feature = "serde", serde(rename = "TIBO"))]
    Tibo,
    #[yaserde(rename = "TLBO")]
    #[cfg_attr(feature = "serde", serde(rename = "TLBO"))]
    Tlbo,
    #[yaserde(rename = "SWAP")]
    #[cfg_attr(feature = "serde", serde(rename = "SWAP"))]
    Swap,
    #[yaserde(rename = "STBO")]
    #[cfg_attr(feature = "serde", serde(rename = "STBO"))]
    Stbo,
    #[yaserde(rename = "PRBO")]
    #[cfg_attr(feature = "serde", serde(rename = "PRBO"))]
    Prbo,
    #[yaserde(rename = "PFAN")]
    #[cfg_attr(feature = "serde", serde(rename = "PFAN"))]
    Pfan,
    #[yaserde(rename = "NIBO")]
    #[cfg_attr(feature = "serde", serde(rename = "NIBO"))]
    Nibo,
    #[yaserde(rename = "MAAA")]
    #[cfg_attr(feature = "serde", serde(rename = "MAAA"))]
    Maaa,
    #[yaserde(rename = "MOSP")]
    #[cfg_attr(feature = "serde", serde(rename = "MOSP"))]
    Mosp,
    #[yaserde(rename = "LIBO")]
    #[cfg_attr(feature = "serde", serde(rename = "LIBO"))]
    Libo,
    #[yaserde(rename = "LIBI")]
    #[cfg_attr(feature = "serde", serde(rename = "LIBI"))]
    Libi,
    #[yaserde(rename = "JIBA")]
    #[cfg_attr(feature = "serde", serde(rename = "JIBA"))]
    Jiba,
    #[yaserde(rename = "ISDA")]
    #[cfg_attr(feature = "serde", serde(rename = "ISDA"))]
    Isda,
    #[yaserde(rename = "GCFR")]
    #[cfg_attr(feature = "serde", serde(rename = "GCFR"))]
    Gcfr,
    #[yaserde(rename = "FUSW")]
    #[cfg_attr(feature = "serde", serde(rename = "FUSW"))]
    Fusw,
    #[yaserde(rename = "EUCH")]
    #[cfg_attr(feature = "serde", serde(rename = "EUCH"))]
    Euch,
    #[yaserde(rename = "EUUS")]
    #[cfg_attr(feature = "serde", serde(rename = "EUUS"))]
    Euus,
    #[yaserde(rename = "EURI")]
    #[cfg_attr(feature = "serde", serde(rename = "EURI"))]
    Euri,
    #[yaserde(rename = "EONS")]
    #[cfg_attr(feature = "serde", serde(rename = "EONS"))]
    Eons,
    #[yaserde(rename = "EONA")]
    #[cfg_attr(feature = "serde", serde(rename = "EONA"))]
    Eona,
    #[yaserde(rename = "CIBO")]
    #[cfg_attr(feature = "serde", serde(rename = "CIBO"))]
    Cibo,
    #[yaserde(rename = "CDOR")]
    #[cfg_attr(feature = "serde", serde(rename = "CDOR"))]
    Cdor,
    #[yaserde(rename = "BUBO")]
    #[cfg_attr(feature = "serde", serde(rename = "BUBO"))]
    Bubo,
    #[yaserde(rename = "BBSW")]
    #[cfg_attr(feature = "serde", serde(rename = "BBSW"))]
    Bbsw,
    __Unknown__(String),
}

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

impl Validate for BenchmarkCurveName2Code {}
#[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:auth.022.001.04")]
pub struct BenchmarkCurveName4Choice {
    #[yaserde(rename = "ISIN")]
    #[cfg_attr(feature = "serde", serde(rename = "ISIN"))]
    pub isin: Option<Isinoct2015Identifier>,
    #[yaserde(rename = "Indx")]
    #[cfg_attr(feature = "serde", serde(rename = "Indx"))]
    pub indx: Option<BenchmarkCurveName2Code>,
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Option<Max25Text>,
}

impl Validate for BenchmarkCurveName4Choice {}




#[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:auth.022.001.04")]
pub struct BinaryFile1 {
    #[yaserde(rename = "MIMETp")]
    #[cfg_attr(feature = "serde", serde(rename = "MIMETp"))]
    pub mime_tp: Max35Text,

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

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

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

impl Validate for BinaryFile1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.022.001.04")]
pub struct BranchAndFinancialInstitutionIdentification8 {
    #[yaserde(rename = "FinInstnId")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstnId"))]
    pub fin_instn_id: FinancialInstitutionIdentification23,

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

impl Validate for BranchAndFinancialInstitutionIdentification8 {}


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

    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Leiidentifier,

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

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

impl Validate for BranchData5 {}


#[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:auth.022.001.04")]
pub struct CashAccount40 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: AccountIdentification4Choice,

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

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

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

    #[yaserde(rename = "Prxy")]
    #[cfg_attr(feature = "serde", serde(rename = "Prxy"))]
    pub prxy: ProxyAccountIdentification1,
}

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

impl Validate for CashAccountType2Choice {}




#[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:auth.022.001.04")]
pub struct CashCollateral5 {
    #[yaserde(rename = "CollId")]
    #[cfg_attr(feature = "serde", serde(rename = "CollId"))]
    pub coll_id: Max35Text,

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

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

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

    #[yaserde(rename = "DpstTp")]
    #[cfg_attr(feature = "serde", serde(rename = "DpstTp"))]
    pub dpst_tp: DepositType1Code,

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

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

    #[yaserde(rename = "XchgRate")]
    #[cfg_attr(feature = "serde", serde(rename = "XchgRate"))]
    pub xchg_rate: BaseOneRate,

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

    #[yaserde(rename = "Hrcut")]
    #[cfg_attr(feature = "serde", serde(rename = "Hrcut"))]
    pub hrcut: PercentageRate,
}

impl Validate for CashCollateral5 {}


#[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:auth.022.001.04")]
pub struct CertificateIdentification1 {
    #[yaserde(rename = "MsgId")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgId"))]
    pub msg_id: Max35Text,

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

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

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

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

    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: ProprietaryReference1,
}

impl Validate for CertificateIdentification1 {}


#[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:auth.022.001.04")]
pub struct CertificateReference2 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: CertificateIdentification1,

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

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

impl Validate for ClearingSystemIdentification2Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.022.001.04")]
pub struct ClearingSystemMemberIdentification2 {
    #[yaserde(rename = "ClrSysId")]
    #[cfg_attr(feature = "serde", serde(rename = "ClrSysId"))]
    pub clr_sys_id: ClearingSystemIdentification2Choice,

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

impl Validate for ClearingSystemMemberIdentification2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.022.001.04")]

pub enum CommunicationMethod4Code {
    #[yaserde(rename = "EMAL")]
    #[cfg_attr(feature = "serde", serde(rename = "EMAL"))]
    Emal,
    #[yaserde(rename = "FAXI")]
    #[cfg_attr(feature = "serde", serde(rename = "FAXI"))]
    Faxi,
    #[yaserde(rename = "FILE")]
    #[cfg_attr(feature = "serde", serde(rename = "FILE"))]
    File,
    #[yaserde(rename = "ONLI")]
    #[cfg_attr(feature = "serde", serde(rename = "ONLI"))]
    Onli,
    #[yaserde(rename = "PHON")]
    #[cfg_attr(feature = "serde", serde(rename = "PHON"))]
    Phon,
    #[yaserde(rename = "POST")]
    #[cfg_attr(feature = "serde", serde(rename = "POST"))]
    Post,
    #[yaserde(rename = "PROP")]
    #[cfg_attr(feature = "serde", serde(rename = "PROP"))]
    Prop,
    #[yaserde(rename = "SWMT")]
    #[cfg_attr(feature = "serde", serde(rename = "SWMT"))]
    Swmt,
    #[yaserde(rename = "SWMX")]
    #[cfg_attr(feature = "serde", serde(rename = "SWMX"))]
    Swmx,
    __Unknown__(String),
}

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

impl Validate for CommunicationMethod4Code {}



#[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:auth.022.001.04")]
pub struct Contact13 {
    #[yaserde(rename = "NmPrfx")]
    #[cfg_attr(feature = "serde", serde(rename = "NmPrfx"))]
    pub nm_prfx: NamePrefix2Code,

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

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

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

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

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

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

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

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

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

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

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

    #[yaserde(rename = "PrefrdMtd")]
    #[cfg_attr(feature = "serde", serde(rename = "PrefrdMtd"))]
    pub prefrd_mtd: PreferredContactMethod2Code,
}

impl Validate for Contact13 {}


#[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:auth.022.001.04")]
pub struct ContractBalance1 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: ContractBalanceType1Choice,

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

    #[yaserde(rename = "CdtDbtInd")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtDbtInd"))]
    pub cdt_dbt_ind: CreditDebit3Code,
}

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

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

impl Validate for ContractClosureReason1Choice {}




#[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:auth.022.001.04")]
pub struct ContractCollateral1 {
    #[yaserde(rename = "TtlAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlAmt"))]
    pub ttl_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "CollDesc")]
    #[cfg_attr(feature = "serde", serde(rename = "CollDesc"))]
    pub coll_desc: Vec<CashCollateral5>,

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

impl Validate for ContractCollateral1 {}
#[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:auth.022.001.04")]
pub struct ContractRegistrationReference2Choice {
    #[yaserde(rename = "RegdCtrctId")]
    #[cfg_attr(feature = "serde", serde(rename = "RegdCtrctId"))]
    pub regd_ctrct_id: Option<Max35Text>,
    #[yaserde(rename = "Ctrct")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctrct"))]
    pub ctrct: Option<DocumentIdentification35>,
}

impl Validate for ContractRegistrationReference2Choice {}




#[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:auth.022.001.04")]
pub struct ContractRegistrationStatement4 {
    #[yaserde(rename = "StmtId")]
    #[cfg_attr(feature = "serde", serde(rename = "StmtId"))]
    pub stmt_id: Max35Text,

    #[yaserde(rename = "RptgPty")]
    #[cfg_attr(feature = "serde", serde(rename = "RptgPty"))]
    pub rptg_pty: TradeParty6,

    #[yaserde(rename = "RegnAgt")]
    #[cfg_attr(feature = "serde", serde(rename = "RegnAgt"))]
    pub regn_agt: BranchAndFinancialInstitutionIdentification8,

    #[yaserde(rename = "RptgPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "RptgPrd"))]
    pub rptg_prd: ReportingPeriod4,

    #[yaserde(rename = "RegdCtrct")]
    #[cfg_attr(feature = "serde", serde(rename = "RegdCtrct"))]
    pub regd_ctrct: RegisteredContract18,

    #[yaserde(rename = "TxJrnl")]
    #[cfg_attr(feature = "serde", serde(rename = "TxJrnl"))]
    pub tx_jrnl: Vec<TransactionCertificate4>,

    #[yaserde(rename = "SpprtgDocJrnl")]
    #[cfg_attr(feature = "serde", serde(rename = "SpprtgDocJrnl"))]
    pub spprtg_doc_jrnl: Vec<SupportingDocument4>,

    #[yaserde(rename = "AddtlSpprtgDocJrnl")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlSpprtgDocJrnl"))]
    pub addtl_spprtg_doc_jrnl: Vec<SupportingDocument4>,

    #[yaserde(rename = "RgltryRuleVldtn")]
    #[cfg_attr(feature = "serde", serde(rename = "RgltryRuleVldtn"))]
    pub rgltry_rule_vldtn: Vec<GenericValidationRuleIdentification1>,

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

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

impl Validate for ContractRegistrationStatement4 {}


#[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:auth.022.001.04")]
pub struct ContractRegistrationStatementV04 {
    #[yaserde(rename = "GrpHdr")]
    #[cfg_attr(feature = "serde", serde(rename = "GrpHdr"))]
    pub grp_hdr: CurrencyControlHeader7,

    #[yaserde(rename = "Stmt")]
    #[cfg_attr(feature = "serde", serde(rename = "Stmt"))]
    pub stmt: Vec<ContractRegistrationStatement4>,

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

impl Validate for ContractRegistrationStatementV04 {}


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

pub enum CreditDebit3Code {
    #[yaserde(rename = "CRDT")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDT"))]
    Crdt,
    #[yaserde(rename = "DBIT")]
    #[cfg_attr(feature = "serde", serde(rename = "DBIT"))]
    Dbit,
    __Unknown__(String),
}

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

impl Validate for CreditDebit3Code {}



#[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:auth.022.001.04")]
pub struct CurrencyControlHeader7 {
    #[yaserde(rename = "MsgId")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgId"))]
    pub msg_id: Max35Text,

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

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

    #[yaserde(rename = "RcvgPty")]
    #[cfg_attr(feature = "serde", serde(rename = "RcvgPty"))]
    pub rcvg_pty: PartyIdentification272,

    #[yaserde(rename = "RegnAgt")]
    #[cfg_attr(feature = "serde", serde(rename = "RegnAgt"))]
    pub regn_agt: BranchAndFinancialInstitutionIdentification8,
}

impl Validate for CurrencyControlHeader7 {}


#[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:auth.022.001.04")]
pub struct DateAndPlaceOfBirth1 {
    #[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 DateAndPlaceOfBirth1 {}


#[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:auth.022.001.04")]
pub struct DatePeriod3 {
    #[yaserde(rename = "FrDt")]
    #[cfg_attr(feature = "serde", serde(rename = "FrDt"))]
    pub fr_dt: Isodate,

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

impl Validate for DatePeriod3 {}


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

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

pub enum DepositType1Code {
    #[yaserde(rename = "FITE")]
    #[cfg_attr(feature = "serde", serde(rename = "FITE"))]
    Fite,
    #[yaserde(rename = "CALL")]
    #[cfg_attr(feature = "serde", serde(rename = "CALL"))]
    Call,
    __Unknown__(String),
}

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

impl Validate for DepositType1Code {}



#[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:auth.022.001.04")]
pub struct Document {
    #[yaserde(rename = "CtrctRegnStmt")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrctRegnStmt"))]
    pub ctrct_regn_stmt: ContractRegistrationStatementV04,
}

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:auth.022.001.04")]
pub struct DocumentAmendment1 {
    #[yaserde(rename = "CrrctnId")]
    #[cfg_attr(feature = "serde", serde(rename = "CrrctnId"))]
    pub crrctn_id: Number,

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

impl Validate for DocumentAmendment1 {}


#[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:auth.022.001.04")]
pub struct DocumentEntryAmendment1 {
    #[yaserde(rename = "CrrctgNtryNb")]
    #[cfg_attr(feature = "serde", serde(rename = "CrrctgNtryNb"))]
    pub crrctg_ntry_nb: Number,

    #[yaserde(rename = "OrgnlDoc")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlDoc"))]
    pub orgnl_doc: DocumentIdentification28,
}

impl Validate for DocumentEntryAmendment1 {}


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

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

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

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

    #[yaserde(rename = "LkFileHash")]
    #[cfg_attr(feature = "serde", serde(rename = "LkFileHash"))]
    pub lk_file_hash: SignatureEnvelopeReference,

    #[yaserde(rename = "AttchdBinryFile")]
    #[cfg_attr(feature = "serde", serde(rename = "AttchdBinryFile"))]
    pub attchd_binry_file: BinaryFile1,
}

impl Validate for DocumentGeneralInformation5 {}


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

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

impl Validate for DocumentIdentification22 {}


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

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

impl Validate for DocumentIdentification28 {}


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

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

impl Validate for DocumentIdentification29 {}


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

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

impl Validate for DocumentIdentification35 {}


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

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

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

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

impl Validate for Exact5NumericText {}
#[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:auth.022.001.04")]
pub struct ExchangeRate1 {
    #[yaserde(rename = "UnitCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitCcy"))]
    pub unit_ccy: ActiveOrHistoricCurrencyCode,

    #[yaserde(rename = "XchgRate")]
    #[cfg_attr(feature = "serde", serde(rename = "XchgRate"))]
    pub xchg_rate: BaseOneRate,

    #[yaserde(rename = "RateTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RateTp"))]
    pub rate_tp: ExchangeRateType1Code,

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

impl Validate for ExchangeRate1 {}


#[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:auth.022.001.04")]

pub enum ExchangeRateType1Code {
    #[yaserde(rename = "SPOT")]
    #[cfg_attr(feature = "serde", serde(rename = "SPOT"))]
    Spot,
    #[yaserde(rename = "SALE")]
    #[cfg_attr(feature = "serde", serde(rename = "SALE"))]
    Sale,
    #[yaserde(rename = "AGRD")]
    #[cfg_attr(feature = "serde", serde(rename = "AGRD"))]
    Agrd,
    __Unknown__(String),
}

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

impl Validate for ExchangeRateType1Code {}



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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Validate for ExternalValidationRuleIdentification1Code {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 4 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 4 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.022.001.04")]
pub struct FinancialIdentificationSchemeName1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ExternalFinancialInstitutionIdentification1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max35Text>,
}

impl Validate for FinancialIdentificationSchemeName1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.022.001.04")]
pub struct FinancialInstitutionIdentification23 {
    #[yaserde(rename = "BICFI")]
    #[cfg_attr(feature = "serde", serde(rename = "BICFI"))]
    pub bicfi: Bicfidec2014Identifier,

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

    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Leiidentifier,

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

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

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

impl Validate for FinancialInstitutionIdentification23 {}


#[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:auth.022.001.04")]
pub struct FloatingInterestRate4 {
    #[yaserde(rename = "RefRate")]
    #[cfg_attr(feature = "serde", serde(rename = "RefRate"))]
    pub ref_rate: BenchmarkCurveName4Choice,

    #[yaserde(rename = "Term")]
    #[cfg_attr(feature = "serde", serde(rename = "Term"))]
    pub term: InterestRateContractTerm1,

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

impl Validate for FloatingInterestRate4 {}


#[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:auth.022.001.04")]
pub struct GenericAccountIdentification1 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max34Text,

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

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

impl Validate for GenericAccountIdentification1 {}


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

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

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

impl Validate for GenericFinancialIdentification1 {}


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

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

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

impl Validate for GenericIdentification30 {}


#[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:auth.022.001.04")]
pub struct GenericOrganisationIdentification3 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max256Text,

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

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

impl Validate for GenericOrganisationIdentification3 {}


#[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:auth.022.001.04")]
pub struct GenericPersonIdentification2 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max256Text,

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

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

impl Validate for GenericPersonIdentification2 {}


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

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

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

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

impl Validate for GenericValidationRuleIdentification1 {}


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

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

impl Validate for Isinoct2015Identifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct 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 Isotime (pub String);
crate::simple_type!(Isotime);

impl Validate for Isotime {}
#[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:auth.022.001.04")]
pub struct InterestPaymentDateRange1 {
    #[yaserde(rename = "IntrstSchdlId")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstSchdlId"))]
    pub intrst_schdl_id: Max35Text,

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

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

impl Validate for InterestPaymentDateRange1 {}


#[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:auth.022.001.04")]
pub struct InterestPaymentSchedule1 {
    #[yaserde(rename = "IntrstSchdlId")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstSchdlId"))]
    pub intrst_schdl_id: Max35Text,

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

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

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

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

impl Validate for InterestPaymentSchedule1 {}
#[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:auth.022.001.04")]
pub struct InterestRate2Choice {
    #[yaserde(rename = "Fxd")]
    #[cfg_attr(feature = "serde", serde(rename = "Fxd"))]
    pub fxd: Option<PercentageRate>,
    #[yaserde(rename = "Fltg")]
    #[cfg_attr(feature = "serde", serde(rename = "Fltg"))]
    pub fltg: Option<FloatingInterestRate4>,
}

impl Validate for InterestRate2Choice {}




#[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:auth.022.001.04")]
pub struct InterestRateContractTerm1 {
    #[yaserde(rename = "Unit")]
    #[cfg_attr(feature = "serde", serde(rename = "Unit"))]
    pub unit: RateBasis1Code,

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

impl Validate for InterestRateContractTerm1 {}


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

impl Validate for Leiidentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.022.001.04")]
pub struct LegalOrganisation2 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

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

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

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

impl Validate for LegalOrganisation2 {}


#[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:auth.022.001.04")]
pub struct LoanContract4 {
    #[yaserde(rename = "CtrctDocId")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrctDocId"))]
    pub ctrct_doc_id: DocumentIdentification22,

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

    #[yaserde(rename = "Buyr")]
    #[cfg_attr(feature = "serde", serde(rename = "Buyr"))]
    pub buyr: Vec<TradeParty6>,

    #[yaserde(rename = "Sellr")]
    #[cfg_attr(feature = "serde", serde(rename = "Sellr"))]
    pub sellr: Vec<TradeParty6>,

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

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

    #[yaserde(rename = "PrlngtnFlg")]
    #[cfg_attr(feature = "serde", serde(rename = "PrlngtnFlg"))]
    pub prlngtn_flg: TrueFalseIndicator,

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

    #[yaserde(rename = "SttlmCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmCcy"))]
    pub sttlm_ccy: ActiveCurrencyCode,

    #[yaserde(rename = "SpclConds")]
    #[cfg_attr(feature = "serde", serde(rename = "SpclConds"))]
    pub spcl_conds: SpecialCondition1,

    #[yaserde(rename = "DrtnCd")]
    #[cfg_attr(feature = "serde", serde(rename = "DrtnCd"))]
    pub drtn_cd: Exact1NumericText,

    #[yaserde(rename = "IntrstRate")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstRate"))]
    pub intrst_rate: InterestRate2Choice,

    #[yaserde(rename = "Trch")]
    #[cfg_attr(feature = "serde", serde(rename = "Trch"))]
    pub trch: Vec<LoanContractTranche1>,

    #[yaserde(rename = "PmtSchdl")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtSchdl"))]
    pub pmt_schdl: Vec<PaymentSchedule1>,

    #[yaserde(rename = "IntrstSchdl")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstSchdl"))]
    pub intrst_schdl: Vec<InterestPaymentSchedule1>,

    #[yaserde(rename = "IntraCpnyLn")]
    #[cfg_attr(feature = "serde", serde(rename = "IntraCpnyLn"))]
    pub intra_cpny_ln: TrueFalseIndicator,

    #[yaserde(rename = "Coll")]
    #[cfg_attr(feature = "serde", serde(rename = "Coll"))]
    pub coll: ContractCollateral1,

    #[yaserde(rename = "SndctdLn")]
    #[cfg_attr(feature = "serde", serde(rename = "SndctdLn"))]
    pub sndctd_ln: Vec<SyndicatedLoan3>,

    #[yaserde(rename = "Attchmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "Attchmnt"))]
    pub attchmnt: Vec<DocumentGeneralInformation5>,
}

impl Validate for LoanContract4 {}


#[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:auth.022.001.04")]
pub struct LoanContractTranche1 {
    #[yaserde(rename = "TrchNb")]
    #[cfg_attr(feature = "serde", serde(rename = "TrchNb"))]
    pub trch_nb: Number,

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

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

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

    #[yaserde(rename = "DrtnCd")]
    #[cfg_attr(feature = "serde", serde(rename = "DrtnCd"))]
    pub drtn_cd: Exact1NumericText,

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

impl Validate for LoanContractTranche1 {}


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

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

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

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

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

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

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

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

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

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

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

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

impl Validate for Max500Text {
    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() > 500 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 500 \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:auth.022.001.04")]

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

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

impl Validate for NamePrefix2Code {}



#[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:auth.022.001.04")]
pub struct OrganisationIdentification39 {
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_bic: AnyBICDec2014Identifier,

    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Leiidentifier,

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

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

impl Validate for OrganisationIdentificationSchemeName1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.022.001.04")]
pub struct OtherContact1 {
    #[yaserde(rename = "ChanlTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ChanlTp"))]
    pub chanl_tp: Max4Text,

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

impl Validate for OtherContact1 {}
#[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:auth.022.001.04")]
pub struct Party52Choice {
    #[yaserde(rename = "OrgId")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgId"))]
    pub org_id: Option<OrganisationIdentification39>,
    #[yaserde(rename = "PrvtId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvtId"))]
    pub prvt_id: Option<PersonIdentification18>,
}

impl Validate for Party52Choice {}




#[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:auth.022.001.04")]
pub struct PartyIdentification272 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max140Text,

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

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

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

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

impl Validate for PartyIdentification272 {}


#[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:auth.022.001.04")]
pub struct PaymentSchedule1 {
    #[yaserde(rename = "PmtSchdlId")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtSchdlId"))]
    pub pmt_schdl_id: Max35Text,

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

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

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

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

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

impl Validate for PaymentScheduleType2Choice {}




#[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:auth.022.001.04")]

pub enum PaymentScheduleType2Code {
    #[yaserde(rename = "CNTR")]
    #[cfg_attr(feature = "serde", serde(rename = "CNTR"))]
    Cntr,
    #[yaserde(rename = "ESTM")]
    #[cfg_attr(feature = "serde", serde(rename = "ESTM"))]
    Estm,
    #[yaserde(rename = "BOTH")]
    #[cfg_attr(feature = "serde", serde(rename = "BOTH"))]
    Both,
    __Unknown__(String),
}

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

impl Validate for PaymentScheduleType2Code {}



#[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:auth.022.001.04")]
pub struct PersonIdentification18 {
    #[yaserde(rename = "DtAndPlcOfBirth")]
    #[cfg_attr(feature = "serde", serde(rename = "DtAndPlcOfBirth"))]
    pub dt_and_plc_of_birth: DateAndPlaceOfBirth1,

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

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

impl Validate for PersonIdentificationSchemeName1Choice {}




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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Validate for PostalAddress27 {}


#[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:auth.022.001.04")]

pub enum PreferredContactMethod2Code {
    #[yaserde(rename = "MAIL")]
    #[cfg_attr(feature = "serde", serde(rename = "MAIL"))]
    Mail,
    #[yaserde(rename = "FAXX")]
    #[cfg_attr(feature = "serde", serde(rename = "FAXX"))]
    Faxx,
    #[yaserde(rename = "LETT")]
    #[cfg_attr(feature = "serde", serde(rename = "LETT"))]
    Lett,
    #[yaserde(rename = "CELL")]
    #[cfg_attr(feature = "serde", serde(rename = "CELL"))]
    Cell,
    #[yaserde(rename = "ONLI")]
    #[cfg_attr(feature = "serde", serde(rename = "ONLI"))]
    Onli,
    #[yaserde(rename = "PHON")]
    #[cfg_attr(feature = "serde", serde(rename = "PHON"))]
    Phon,
    __Unknown__(String),
}

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

impl Validate for PreferredContactMethod2Code {}



#[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:auth.022.001.04")]
pub struct ProprietaryReference1 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: Max35Text,

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

impl Validate for ProprietaryReference1 {}


#[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:auth.022.001.04")]
pub struct ProxyAccountIdentification1 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: ProxyAccountType1Choice,

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

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

impl Validate for ProxyAccountType1Choice {}




#[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:auth.022.001.04")]

pub enum QueryType3Code {
    #[yaserde(rename = "ALLL")]
    #[cfg_attr(feature = "serde", serde(rename = "ALLL"))]
    Alll,
    #[yaserde(rename = "CHNG")]
    #[cfg_attr(feature = "serde", serde(rename = "CHNG"))]
    Chng,
    #[yaserde(rename = "MODF")]
    #[cfg_attr(feature = "serde", serde(rename = "MODF"))]
    Modf,
    __Unknown__(String),
}

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

impl Validate for QueryType3Code {}



#[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:auth.022.001.04")]

pub enum RateBasis1Code {
    #[yaserde(rename = "DAYS")]
    #[cfg_attr(feature = "serde", serde(rename = "DAYS"))]
    Days,
    #[yaserde(rename = "MNTH")]
    #[cfg_attr(feature = "serde", serde(rename = "MNTH"))]
    Mnth,
    #[yaserde(rename = "WEEK")]
    #[cfg_attr(feature = "serde", serde(rename = "WEEK"))]
    Week,
    #[yaserde(rename = "YEAR")]
    #[cfg_attr(feature = "serde", serde(rename = "YEAR"))]
    Year,
    __Unknown__(String),
}

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

impl Validate for RateBasis1Code {}



#[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:auth.022.001.04")]
pub struct RegisteredContract18 {
    #[yaserde(rename = "OrgnlCtrctRegnReq")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlCtrctRegnReq"))]
    pub orgnl_ctrct_regn_req: Max35Text,

    #[yaserde(rename = "IssrFI")]
    #[cfg_attr(feature = "serde", serde(rename = "IssrFI"))]
    pub issr_fi: BranchAndFinancialInstitutionIdentification8,

    #[yaserde(rename = "Ctrct")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctrct"))]
    pub ctrct: UnderlyingContract4Choice,

    #[yaserde(rename = "CtrctBal")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrctBal"))]
    pub ctrct_bal: Vec<ContractBalance1>,

    #[yaserde(rename = "PmtSchdlTp")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtSchdlTp"))]
    pub pmt_schdl_tp: PaymentScheduleType2Choice,

    #[yaserde(rename = "RegdCtrctId")]
    #[cfg_attr(feature = "serde", serde(rename = "RegdCtrctId"))]
    pub regd_ctrct_id: DocumentIdentification29,

    #[yaserde(rename = "PrvsRegdCtrctId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvsRegdCtrctId"))]
    pub prvs_regd_ctrct_id: DocumentIdentification22,

    #[yaserde(rename = "RegdCtrctJrnl")]
    #[cfg_attr(feature = "serde", serde(rename = "RegdCtrctJrnl"))]
    pub regd_ctrct_jrnl: Vec<RegisteredContractJournal3>,

    #[yaserde(rename = "Amdmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amdmnt"))]
    pub amdmnt: Vec<RegisteredContractAmendment1>,

    #[yaserde(rename = "Submissn")]
    #[cfg_attr(feature = "serde", serde(rename = "Submissn"))]
    pub submissn: RegisteredContractCommunication1,

    #[yaserde(rename = "Dlvry")]
    #[cfg_attr(feature = "serde", serde(rename = "Dlvry"))]
    pub dlvry: RegisteredContractCommunication1,

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

    #[yaserde(rename = "EstmtdDtInd")]
    #[cfg_attr(feature = "serde", serde(rename = "EstmtdDtInd"))]
    pub estmtd_dt_ind: TrueFalseIndicator,

    #[yaserde(rename = "IntrCpnyLn")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrCpnyLn"))]
    pub intr_cpny_ln: TrueFalseIndicator,

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

impl Validate for RegisteredContract18 {}


#[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:auth.022.001.04")]
pub struct RegisteredContractAmendment1 {
    #[yaserde(rename = "AmdmntDt")]
    #[cfg_attr(feature = "serde", serde(rename = "AmdmntDt"))]
    pub amdmnt_dt: Isodate,

    #[yaserde(rename = "Doc")]
    #[cfg_attr(feature = "serde", serde(rename = "Doc"))]
    pub doc: DocumentIdentification28,

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

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

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

impl Validate for RegisteredContractAmendment1 {}


#[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:auth.022.001.04")]
pub struct RegisteredContractCommunication1 {
    #[yaserde(rename = "Mtd")]
    #[cfg_attr(feature = "serde", serde(rename = "Mtd"))]
    pub mtd: CommunicationMethod4Code,

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

impl Validate for RegisteredContractCommunication1 {}


#[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:auth.022.001.04")]
pub struct RegisteredContractJournal3 {
    #[yaserde(rename = "RegnAgt")]
    #[cfg_attr(feature = "serde", serde(rename = "RegnAgt"))]
    pub regn_agt: BranchAndFinancialInstitutionIdentification8,

    #[yaserde(rename = "UnqId")]
    #[cfg_attr(feature = "serde", serde(rename = "UnqId"))]
    pub unq_id: DocumentIdentification28,

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

    #[yaserde(rename = "ClsrRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "ClsrRsn"))]
    pub clsr_rsn: ContractClosureReason1Choice,
}

impl Validate for RegisteredContractJournal3 {}


#[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:auth.022.001.04")]
pub struct ReportingPeriod4 {
    #[yaserde(rename = "FrToDt")]
    #[cfg_attr(feature = "serde", serde(rename = "FrToDt"))]
    pub fr_to_dt: DatePeriod3,

    #[yaserde(rename = "FrToTm")]
    #[cfg_attr(feature = "serde", serde(rename = "FrToTm"))]
    pub fr_to_tm: TimePeriod2,

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

impl Validate for ReportingPeriod4 {}


#[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:auth.022.001.04")]
pub struct ShipmentAttribute2 {
    #[yaserde(rename = "Conds")]
    #[cfg_attr(feature = "serde", serde(rename = "Conds"))]
    pub conds: ShipmentCondition1Choice,

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

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

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

impl Validate for ShipmentCondition1Choice {}




#[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:auth.022.001.04")]
pub struct ShipmentDateRange1 {
    #[yaserde(rename = "EarlstShipmntDt")]
    #[cfg_attr(feature = "serde", serde(rename = "EarlstShipmntDt"))]
    pub earlst_shipmnt_dt: Isodate,

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

impl Validate for ShipmentDateRange1 {}


#[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:auth.022.001.04")]
pub struct ShipmentDateRange2 {
    #[yaserde(rename = "SubQtyVal")]
    #[cfg_attr(feature = "serde", serde(rename = "SubQtyVal"))]
    pub sub_qty_val: DecimalNumber,

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

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

impl Validate for ShipmentDateRange2 {}
#[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:auth.022.001.04")]
pub struct ShipmentSchedule2Choice {
    #[yaserde(rename = "ShipmntDtRg")]
    #[cfg_attr(feature = "serde", serde(rename = "ShipmntDtRg"))]
    pub shipmnt_dt_rg: Option<ShipmentDateRange1>,
    #[yaserde(rename = "ShipmntSubSchdl")]
    #[cfg_attr(feature = "serde", serde(rename = "ShipmntSubSchdl"))]
    pub shipmnt_sub_schdl: Vec<ShipmentDateRange2>,
}

impl Validate for ShipmentSchedule2Choice {}




#[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:auth.022.001.04")]
pub struct SignatureEnvelopeReference {}

impl Validate for SignatureEnvelopeReference {}


#[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:auth.022.001.04")]
pub struct SpecialCondition1 {
    #[yaserde(rename = "IncmgAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "IncmgAmt"))]
    pub incmg_amt: ActiveCurrencyAndAmount,

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

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

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

impl Validate for SpecialCondition1 {}


#[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:auth.022.001.04")]
pub struct SupplementaryData1 {
    #[yaserde(rename = "PlcAndNm")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcAndNm"))]
    pub plc_and_nm: Max350Text,

    #[yaserde(rename = "Envlp")]
    #[cfg_attr(feature = "serde", serde(rename = "Envlp"))]
    pub envlp: SupplementaryDataEnvelope1,
}

impl Validate for SupplementaryData1 {}


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

impl Validate for SupplementaryDataEnvelope1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.022.001.04")]
pub struct SupportingDocument4 {
    #[yaserde(rename = "SpprtgDocId")]
    #[cfg_attr(feature = "serde", serde(rename = "SpprtgDocId"))]
    pub spprtg_doc_id: Max35Text,

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

    #[yaserde(rename = "Cert")]
    #[cfg_attr(feature = "serde", serde(rename = "Cert"))]
    pub cert: DocumentIdentification28,

    #[yaserde(rename = "AcctOwnr")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctOwnr"))]
    pub acct_ownr: PartyIdentification272,

    #[yaserde(rename = "AcctSvcr")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctSvcr"))]
    pub acct_svcr: BranchAndFinancialInstitutionIdentification8,

    #[yaserde(rename = "Amdmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amdmnt"))]
    pub amdmnt: DocumentAmendment1,

    #[yaserde(rename = "CtrctRef")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrctRef"))]
    pub ctrct_ref: ContractRegistrationReference2Choice,

    #[yaserde(rename = "Ntry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ntry"))]
    pub ntry: Vec<SupportingDocumentEntry2>,

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

impl Validate for SupportingDocument4 {}


#[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:auth.022.001.04")]
pub struct SupportingDocumentEntry2 {
    #[yaserde(rename = "NtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "NtryId"))]
    pub ntry_id: Max35Text,

    #[yaserde(rename = "OrgnlDoc")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlDoc"))]
    pub orgnl_doc: DocumentIdentification22,

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

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

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

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

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

    #[yaserde(rename = "ShipmntAttrbts")]
    #[cfg_attr(feature = "serde", serde(rename = "ShipmntAttrbts"))]
    pub shipmnt_attrbts: ShipmentAttribute2,

    #[yaserde(rename = "NtryAmdmntId")]
    #[cfg_attr(feature = "serde", serde(rename = "NtryAmdmntId"))]
    pub ntry_amdmnt_id: DocumentEntryAmendment1,

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

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

    #[yaserde(rename = "Attchmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "Attchmnt"))]
    pub attchmnt: Vec<DocumentGeneralInformation5>,
}

impl Validate for SupportingDocumentEntry2 {}


#[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:auth.022.001.04")]
pub struct SyndicatedLoan3 {
    #[yaserde(rename = "Brrwr")]
    #[cfg_attr(feature = "serde", serde(rename = "Brrwr"))]
    pub brrwr: TradeParty6,

    #[yaserde(rename = "Lndr")]
    #[cfg_attr(feature = "serde", serde(rename = "Lndr"))]
    pub lndr: TradeParty6,

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

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

    #[yaserde(rename = "XchgRateInf")]
    #[cfg_attr(feature = "serde", serde(rename = "XchgRateInf"))]
    pub xchg_rate_inf: ExchangeRate1,
}

impl Validate for SyndicatedLoan3 {}


#[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:auth.022.001.04")]

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

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

impl Validate for TaxExemptReason1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.022.001.04")]
pub struct TaxExemptionReasonFormat1Choice {
    #[yaserde(rename = "Ustrd")]
    #[cfg_attr(feature = "serde", serde(rename = "Ustrd"))]
    pub ustrd: Option<Max140Text>,
    #[yaserde(rename = "Strd")]
    #[cfg_attr(feature = "serde", serde(rename = "Strd"))]
    pub strd: Option<TaxExemptReason1Code>,
}

impl Validate for TaxExemptionReasonFormat1Choice {}




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

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

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

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

impl Validate for TaxParty4 {}


#[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:auth.022.001.04")]
pub struct TimePeriod2 {
    #[yaserde(rename = "FrTm")]
    #[cfg_attr(feature = "serde", serde(rename = "FrTm"))]
    pub fr_tm: Isotime,

    #[yaserde(rename = "ToTm")]
    #[cfg_attr(feature = "serde", serde(rename = "ToTm"))]
    pub to_tm: Isotime,
}

impl Validate for TimePeriod2 {}


#[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:auth.022.001.04")]
pub struct TradeContract4 {
    #[yaserde(rename = "CtrctDocId")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrctDocId"))]
    pub ctrct_doc_id: DocumentIdentification22,

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

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

    #[yaserde(rename = "Buyr")]
    #[cfg_attr(feature = "serde", serde(rename = "Buyr"))]
    pub buyr: Vec<TradeParty6>,

    #[yaserde(rename = "Sellr")]
    #[cfg_attr(feature = "serde", serde(rename = "Sellr"))]
    pub sellr: Vec<TradeParty6>,

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

    #[yaserde(rename = "PrlngtnFlg")]
    #[cfg_attr(feature = "serde", serde(rename = "PrlngtnFlg"))]
    pub prlngtn_flg: TrueFalseIndicator,

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

    #[yaserde(rename = "SttlmCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmCcy"))]
    pub sttlm_ccy: ActiveCurrencyCode,

    #[yaserde(rename = "XchgRateInf")]
    #[cfg_attr(feature = "serde", serde(rename = "XchgRateInf"))]
    pub xchg_rate_inf: ExchangeRate1,

    #[yaserde(rename = "PmtSchdl")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtSchdl"))]
    pub pmt_schdl: InterestPaymentDateRange1,

    #[yaserde(rename = "ShipmntSchdl")]
    #[cfg_attr(feature = "serde", serde(rename = "ShipmntSchdl"))]
    pub shipmnt_schdl: ShipmentSchedule2Choice,

    #[yaserde(rename = "Attchmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "Attchmnt"))]
    pub attchmnt: Vec<DocumentGeneralInformation5>,
}

impl Validate for TradeContract4 {}


#[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:auth.022.001.04")]
pub struct TradeParty6 {
    #[yaserde(rename = "PtyId")]
    #[cfg_attr(feature = "serde", serde(rename = "PtyId"))]
    pub pty_id: PartyIdentification272,

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

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

impl Validate for TradeParty6 {}


#[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:auth.022.001.04")]
pub struct TransactionCertificate4 {
    #[yaserde(rename = "TxId")]
    #[cfg_attr(feature = "serde", serde(rename = "TxId"))]
    pub tx_id: Max35Text,

    #[yaserde(rename = "Cert")]
    #[cfg_attr(feature = "serde", serde(rename = "Cert"))]
    pub cert: DocumentIdentification28,

    #[yaserde(rename = "Acct")]
    #[cfg_attr(feature = "serde", serde(rename = "Acct"))]
    pub acct: CashAccount40,

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

    #[yaserde(rename = "Amdmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amdmnt"))]
    pub amdmnt: DocumentAmendment1,

    #[yaserde(rename = "CertRcrd")]
    #[cfg_attr(feature = "serde", serde(rename = "CertRcrd"))]
    pub cert_rcrd: Vec<TransactionCertificateRecord2>,

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

impl Validate for TransactionCertificate4 {}


#[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:auth.022.001.04")]
pub struct TransactionCertificate5 {
    #[yaserde(rename = "RfrdDoc")]
    #[cfg_attr(feature = "serde", serde(rename = "RfrdDoc"))]
    pub rfrd_doc: CertificateReference2,

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

    #[yaserde(rename = "TxTp")]
    #[cfg_attr(feature = "serde", serde(rename = "TxTp"))]
    pub tx_tp: Exact1NumericText,

    #[yaserde(rename = "LclInstrm")]
    #[cfg_attr(feature = "serde", serde(rename = "LclInstrm"))]
    pub lcl_instrm: Exact5NumericText,

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

impl Validate for TransactionCertificate5 {}


#[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:auth.022.001.04")]
pub struct TransactionCertificateContract2 {
    #[yaserde(rename = "CtrctRef")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrctRef"))]
    pub ctrct_ref: ContractRegistrationReference2Choice,

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

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

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

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

impl Validate for TransactionCertificateContract2 {}


#[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:auth.022.001.04")]
pub struct TransactionCertificateRecord2 {
    #[yaserde(rename = "CertRcrdId")]
    #[cfg_attr(feature = "serde", serde(rename = "CertRcrdId"))]
    pub cert_rcrd_id: Max35Text,

    #[yaserde(rename = "DocSubmitgPrcdr")]
    #[cfg_attr(feature = "serde", serde(rename = "DocSubmitgPrcdr"))]
    pub doc_submitg_prcdr: Exact1NumericText,

    #[yaserde(rename = "Tx")]
    #[cfg_attr(feature = "serde", serde(rename = "Tx"))]
    pub tx: TransactionCertificate5,

    #[yaserde(rename = "Ctrct")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctrct"))]
    pub ctrct: TransactionCertificateContract2,

    #[yaserde(rename = "Attchmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "Attchmnt"))]
    pub attchmnt: Vec<DocumentGeneralInformation5>,
}

impl Validate for TransactionCertificateRecord2 {}


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

impl Validate for TrueFalseIndicator {}
#[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:auth.022.001.04")]
pub struct UnderlyingContract4Choice {
    #[yaserde(rename = "Ln")]
    #[cfg_attr(feature = "serde", serde(rename = "Ln"))]
    pub ln: Option<LoanContract4>,
    #[yaserde(rename = "Trad")]
    #[cfg_attr(feature = "serde", serde(rename = "Trad"))]
    pub trad: Option<TradeContract4>,
}

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

impl Validate for ValidationRuleSchemeName1Choice {}




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

impl Validate for YesNoIndicator {}

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