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:catp.016.001.01")]
pub struct AtmconfigurationParameter1 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: DataSetCategory7Code,

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

impl Validate for AtmconfigurationParameter1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct Atmcontext18 {
    #[yaserde(rename = "SsnRef")]
    #[cfg_attr(feature = "serde", serde(rename = "SsnRef"))]
    pub ssn_ref: Max35Text,

    #[yaserde(rename = "Svc")]
    #[cfg_attr(feature = "serde", serde(rename = "Svc"))]
    pub svc: Atmservice22,
}

impl Validate for Atmcontext18 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct Atmcustomer4 {
    #[yaserde(rename = "Prfl")]
    #[cfg_attr(feature = "serde", serde(rename = "Prfl"))]
    pub prfl: AtmcustomerProfile4,

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

    #[yaserde(rename = "Authntcn")]
    #[cfg_attr(feature = "serde", serde(rename = "Authntcn"))]
    pub authntcn: Vec<CardholderAuthentication8>,

    #[yaserde(rename = "AuthntcnRslt")]
    #[cfg_attr(feature = "serde", serde(rename = "AuthntcnRslt"))]
    pub authntcn_rslt: Vec<TransactionVerificationResult5>,
}

impl Validate for Atmcustomer4 {}


#[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:catp.016.001.01")]

pub enum AtmcustomerProfile1Code {
    #[yaserde(rename = "CRDF")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDF"))]
    Crdf,
    #[yaserde(rename = "OREQ")]
    #[cfg_attr(feature = "serde", serde(rename = "OREQ"))]
    Oreq,
    #[yaserde(rename = "PREQ")]
    #[cfg_attr(feature = "serde", serde(rename = "PREQ"))]
    Preq,
    __Unknown__(String),
}

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

impl Validate for AtmcustomerProfile1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct AtmcustomerProfile4 {
    #[yaserde(rename = "RtrvlMd")]
    #[cfg_attr(feature = "serde", serde(rename = "RtrvlMd"))]
    pub rtrvl_md: AtmcustomerProfile1Code,

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

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

impl Validate for AtmcustomerProfile4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct Atmenvironment11 {
    #[yaserde(rename = "Acqrr")]
    #[cfg_attr(feature = "serde", serde(rename = "Acqrr"))]
    pub acqrr: Acquirer7,

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

    #[yaserde(rename = "HstgNtty")]
    #[cfg_attr(feature = "serde", serde(rename = "HstgNtty"))]
    pub hstg_ntty: TerminalHosting1,

    #[yaserde(rename = "ATM")]
    #[cfg_attr(feature = "serde", serde(rename = "ATM"))]
    pub atm: AutomatedTellerMachine9,

    #[yaserde(rename = "Cstmr")]
    #[cfg_attr(feature = "serde", serde(rename = "Cstmr"))]
    pub cstmr: Atmcustomer4,

    #[yaserde(rename = "Card")]
    #[cfg_attr(feature = "serde", serde(rename = "Card"))]
    pub card: PaymentCard22,
}

impl Validate for Atmenvironment11 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct Atmequipment1 {
    #[yaserde(rename = "Manfctr")]
    #[cfg_attr(feature = "serde", serde(rename = "Manfctr"))]
    pub manfctr: Max35Text,

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

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

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

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

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

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

    #[yaserde(rename = "CfgtnParam")]
    #[cfg_attr(feature = "serde", serde(rename = "CfgtnParam"))]
    pub cfgtn_param: Vec<AtmconfigurationParameter1>,
}

impl Validate for Atmequipment1 {}


#[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:catp.016.001.01")]

pub enum AtmmediaType1Code {
    #[yaserde(rename = "CARD")]
    #[cfg_attr(feature = "serde", serde(rename = "CARD"))]
    Card,
    #[yaserde(rename = "COIN")]
    #[cfg_attr(feature = "serde", serde(rename = "COIN"))]
    Coin,
    #[yaserde(rename = "CMDT")]
    #[cfg_attr(feature = "serde", serde(rename = "CMDT"))]
    Cmdt,
    #[yaserde(rename = "CPNS")]
    #[cfg_attr(feature = "serde", serde(rename = "CPNS"))]
    Cpns,
    #[yaserde(rename = "NOTE")]
    #[cfg_attr(feature = "serde", serde(rename = "NOTE"))]
    Note,
    #[yaserde(rename = "STMP")]
    #[cfg_attr(feature = "serde", serde(rename = "STMP"))]
    Stmp,
    #[yaserde(rename = "UDTM")]
    #[cfg_attr(feature = "serde", serde(rename = "UDTM"))]
    Udtm,
    __Unknown__(String),
}

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

impl Validate for AtmmediaType1Code {}



#[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:catp.016.001.01")]

pub enum AtmmediaType2Code {
    #[yaserde(rename = "CARD")]
    #[cfg_attr(feature = "serde", serde(rename = "CARD"))]
    Card,
    #[yaserde(rename = "COIN")]
    #[cfg_attr(feature = "serde", serde(rename = "COIN"))]
    Coin,
    #[yaserde(rename = "CMDT")]
    #[cfg_attr(feature = "serde", serde(rename = "CMDT"))]
    Cmdt,
    #[yaserde(rename = "CPNS")]
    #[cfg_attr(feature = "serde", serde(rename = "CPNS"))]
    Cpns,
    #[yaserde(rename = "NOTE")]
    #[cfg_attr(feature = "serde", serde(rename = "NOTE"))]
    Note,
    #[yaserde(rename = "STMP")]
    #[cfg_attr(feature = "serde", serde(rename = "STMP"))]
    Stmp,
    #[yaserde(rename = "UDTM")]
    #[cfg_attr(feature = "serde", serde(rename = "UDTM"))]
    Udtm,
    #[yaserde(rename = "CHCK")]
    #[cfg_attr(feature = "serde", serde(rename = "CHCK"))]
    Chck,
    __Unknown__(String),
}

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

impl Validate for AtmmediaType2Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct AtmmessageFunction2 {
    #[yaserde(rename = "Fctn")]
    #[cfg_attr(feature = "serde", serde(rename = "Fctn"))]
    pub fctn: MessageFunction11Code,

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

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

impl Validate for AtmmessageFunction2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct Atmservice22 {
    #[yaserde(rename = "SvcRef")]
    #[cfg_attr(feature = "serde", serde(rename = "SvcRef"))]
    pub svc_ref: Max35Text,

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

    #[yaserde(rename = "SvcTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SvcTp"))]
    pub svc_tp: AtmserviceType9Code,

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

impl Validate for Atmservice22 {}


#[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:catp.016.001.01")]

pub enum AtmserviceType9Code {
    #[yaserde(rename = "TRFC")]
    #[cfg_attr(feature = "serde", serde(rename = "TRFC"))]
    Trfc,
    #[yaserde(rename = "TRFI")]
    #[cfg_attr(feature = "serde", serde(rename = "TRFI"))]
    Trfi,
    #[yaserde(rename = "TRFP")]
    #[cfg_attr(feature = "serde", serde(rename = "TRFP"))]
    Trfp,
    __Unknown__(String),
}

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

impl Validate for AtmserviceType9Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct Atmtransaction23 {
    #[yaserde(rename = "TxId")]
    #[cfg_attr(feature = "serde", serde(rename = "TxId"))]
    pub tx_id: TransactionIdentifier1,

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

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

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

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

    #[yaserde(rename = "AcctFr")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctFr"))]
    pub acct_fr: CardAccount7,

    #[yaserde(rename = "PrtctdAcctFr")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtctdAcctFr"))]
    pub prtctd_acct_fr: ContentInformationType10,

    #[yaserde(rename = "AcctTo")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctTo"))]
    pub acct_to: Vec<CardAccount7>,

    #[yaserde(rename = "PrtctdAcctTo")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtctdAcctTo"))]
    pub prtctd_acct_to: ContentInformationType10,

    #[yaserde(rename = "TtlReqdAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlReqdAmt"))]
    pub ttl_reqd_amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "DtldReqdAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "DtldReqdAmt"))]
    pub dtld_reqd_amt: DetailedAmount17,

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

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

    #[yaserde(rename = "RcrngTrf")]
    #[cfg_attr(feature = "serde", serde(rename = "RcrngTrf"))]
    pub rcrng_trf: RecurringTransaction3,

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

    #[yaserde(rename = "ICCRltdData")]
    #[cfg_attr(feature = "serde", serde(rename = "ICCRltdData"))]
    pub icc_rltd_data: Max10000Binary,
}

impl Validate for Atmtransaction23 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct AtmtransferRequest1 {
    #[yaserde(rename = "Envt")]
    #[cfg_attr(feature = "serde", serde(rename = "Envt"))]
    pub envt: Atmenvironment11,

    #[yaserde(rename = "Cntxt")]
    #[cfg_attr(feature = "serde", serde(rename = "Cntxt"))]
    pub cntxt: Atmcontext18,

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

impl Validate for AtmtransferRequest1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct AtmtransferRequestV01 {
    #[yaserde(rename = "Hdr")]
    #[cfg_attr(feature = "serde", serde(rename = "Hdr"))]
    pub hdr: Header31,

    #[yaserde(rename = "PrtctdATMTrfReq")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtctdATMTrfReq"))]
    pub prtctd_atm_trf_req: ContentInformationType10,

    #[yaserde(rename = "ATMTrfReq")]
    #[cfg_attr(feature = "serde", serde(rename = "ATMTrfReq"))]
    pub atm_trf_req: AtmtransferRequest1,

    #[yaserde(rename = "SctyTrlr")]
    #[cfg_attr(feature = "serde", serde(rename = "SctyTrlr"))]
    pub scty_trlr: ContentInformationType15,
}

impl Validate for AtmtransferRequestV01 {}


#[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:catp.016.001.01")]

pub enum AccountChoiceMethod1Code {
    #[yaserde(rename = "ACSL")]
    #[cfg_attr(feature = "serde", serde(rename = "ACSL"))]
    Acsl,
    #[yaserde(rename = "ENTR")]
    #[cfg_attr(feature = "serde", serde(rename = "ENTR"))]
    Entr,
    #[yaserde(rename = "IMAC")]
    #[cfg_attr(feature = "serde", serde(rename = "IMAC"))]
    Imac,
    #[yaserde(rename = "IMPL")]
    #[cfg_attr(feature = "serde", serde(rename = "IMPL"))]
    Impl,
    #[yaserde(rename = "NOSL")]
    #[cfg_attr(feature = "serde", serde(rename = "NOSL"))]
    Nosl,
    #[yaserde(rename = "TPSL")]
    #[cfg_attr(feature = "serde", serde(rename = "TPSL"))]
    Tpsl,
    __Unknown__(String),
}

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

impl Validate for AccountChoiceMethod1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct AccountIdentification31Choice {
    #[yaserde(rename = "IBAN")]
    #[cfg_attr(feature = "serde", serde(rename = "IBAN"))]
    pub iban: Option<Ibanidentifier>,
    #[yaserde(rename = "BBAN")]
    #[cfg_attr(feature = "serde", serde(rename = "BBAN"))]
    pub bban: Option<Bbanidentifier>,
    #[yaserde(rename = "UPIC")]
    #[cfg_attr(feature = "serde", serde(rename = "UPIC"))]
    pub upic: Option<Upicidentifier>,
    #[yaserde(rename = "DmstAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "DmstAcct"))]
    pub dmst_acct: Option<SimpleIdentificationInformation4>,
}

impl Validate for AccountIdentification31Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct Acquirer7 {
    #[yaserde(rename = "AcqrgInstn")]
    #[cfg_attr(feature = "serde", serde(rename = "AcqrgInstn"))]
    pub acqrg_instn: Max35Text,

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

impl Validate for Acquirer7 {}


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

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

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

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

impl Validate for AddressType2Code {}



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

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

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

impl Validate for Algorithm11Code {}



#[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:catp.016.001.01")]

pub enum Algorithm12Code {
    #[yaserde(rename = "MACC")]
    #[cfg_attr(feature = "serde", serde(rename = "MACC"))]
    Macc,
    #[yaserde(rename = "MCCS")]
    #[cfg_attr(feature = "serde", serde(rename = "MCCS"))]
    Mccs,
    #[yaserde(rename = "CMA1")]
    #[cfg_attr(feature = "serde", serde(rename = "CMA1"))]
    Cma1,
    #[yaserde(rename = "MCC1")]
    #[cfg_attr(feature = "serde", serde(rename = "MCC1"))]
    Mcc1,
    #[yaserde(rename = "CMA9")]
    #[cfg_attr(feature = "serde", serde(rename = "CMA9"))]
    Cma9,
    #[yaserde(rename = "CMA5")]
    #[cfg_attr(feature = "serde", serde(rename = "CMA5"))]
    Cma5,
    __Unknown__(String),
}

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

impl Validate for Algorithm12Code {}



#[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:catp.016.001.01")]

pub enum Algorithm13Code {
    #[yaserde(rename = "EA2C")]
    #[cfg_attr(feature = "serde", serde(rename = "EA2C"))]
    Ea2C,
    #[yaserde(rename = "E3DC")]
    #[cfg_attr(feature = "serde", serde(rename = "E3DC"))]
    E3Dc,
    #[yaserde(rename = "DKP9")]
    #[cfg_attr(feature = "serde", serde(rename = "DKP9"))]
    Dkp9,
    #[yaserde(rename = "UKPT")]
    #[cfg_attr(feature = "serde", serde(rename = "UKPT"))]
    Ukpt,
    #[yaserde(rename = "UKA1")]
    #[cfg_attr(feature = "serde", serde(rename = "UKA1"))]
    Uka1,
    #[yaserde(rename = "EA9C")]
    #[cfg_attr(feature = "serde", serde(rename = "EA9C"))]
    Ea9C,
    #[yaserde(rename = "EA5C")]
    #[cfg_attr(feature = "serde", serde(rename = "EA5C"))]
    Ea5C,
    __Unknown__(String),
}

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

impl Validate for Algorithm13Code {}



#[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:catp.016.001.01")]

pub enum Algorithm15Code {
    #[yaserde(rename = "EA2C")]
    #[cfg_attr(feature = "serde", serde(rename = "EA2C"))]
    Ea2C,
    #[yaserde(rename = "E3DC")]
    #[cfg_attr(feature = "serde", serde(rename = "E3DC"))]
    E3Dc,
    #[yaserde(rename = "EA9C")]
    #[cfg_attr(feature = "serde", serde(rename = "EA9C"))]
    Ea9C,
    #[yaserde(rename = "EA5C")]
    #[cfg_attr(feature = "serde", serde(rename = "EA5C"))]
    Ea5C,
    __Unknown__(String),
}

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

impl Validate for Algorithm15Code {}



#[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:catp.016.001.01")]

pub enum Algorithm7Code {
    #[yaserde(rename = "ERSA")]
    #[cfg_attr(feature = "serde", serde(rename = "ERSA"))]
    Ersa,
    #[yaserde(rename = "RSAO")]
    #[cfg_attr(feature = "serde", serde(rename = "RSAO"))]
    Rsao,
    __Unknown__(String),
}

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

impl Validate for Algorithm7Code {}



#[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:catp.016.001.01")]

pub enum Algorithm8Code {
    #[yaserde(rename = "MGF1")]
    #[cfg_attr(feature = "serde", serde(rename = "MGF1"))]
    Mgf1,
    __Unknown__(String),
}

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

impl Validate for Algorithm8Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct AlgorithmIdentification11 {
    #[yaserde(rename = "Algo")]
    #[cfg_attr(feature = "serde", serde(rename = "Algo"))]
    pub algo: Algorithm7Code,

    #[yaserde(rename = "Param")]
    #[cfg_attr(feature = "serde", serde(rename = "Param"))]
    pub param: Parameter4,
}

impl Validate for AlgorithmIdentification11 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct AlgorithmIdentification12 {
    #[yaserde(rename = "Algo")]
    #[cfg_attr(feature = "serde", serde(rename = "Algo"))]
    pub algo: Algorithm8Code,

    #[yaserde(rename = "Param")]
    #[cfg_attr(feature = "serde", serde(rename = "Param"))]
    pub param: Parameter5,
}

impl Validate for AlgorithmIdentification12 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct AlgorithmIdentification13 {
    #[yaserde(rename = "Algo")]
    #[cfg_attr(feature = "serde", serde(rename = "Algo"))]
    pub algo: Algorithm13Code,

    #[yaserde(rename = "Param")]
    #[cfg_attr(feature = "serde", serde(rename = "Param"))]
    pub param: Parameter6,
}

impl Validate for AlgorithmIdentification13 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct AlgorithmIdentification14 {
    #[yaserde(rename = "Algo")]
    #[cfg_attr(feature = "serde", serde(rename = "Algo"))]
    pub algo: Algorithm15Code,

    #[yaserde(rename = "Param")]
    #[cfg_attr(feature = "serde", serde(rename = "Param"))]
    pub param: Parameter6,
}

impl Validate for AlgorithmIdentification14 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct AlgorithmIdentification15 {
    #[yaserde(rename = "Algo")]
    #[cfg_attr(feature = "serde", serde(rename = "Algo"))]
    pub algo: Algorithm12Code,

    #[yaserde(rename = "Param")]
    #[cfg_attr(feature = "serde", serde(rename = "Param"))]
    pub param: Parameter7,
}

impl Validate for AlgorithmIdentification15 {}


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

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

pub enum AttributeType1Code {
    #[yaserde(rename = "CNAT")]
    #[cfg_attr(feature = "serde", serde(rename = "CNAT"))]
    Cnat,
    #[yaserde(rename = "LATT")]
    #[cfg_attr(feature = "serde", serde(rename = "LATT"))]
    Latt,
    #[yaserde(rename = "OATT")]
    #[cfg_attr(feature = "serde", serde(rename = "OATT"))]
    Oatt,
    #[yaserde(rename = "OUAT")]
    #[cfg_attr(feature = "serde", serde(rename = "OUAT"))]
    Ouat,
    #[yaserde(rename = "CATT")]
    #[cfg_attr(feature = "serde", serde(rename = "CATT"))]
    Catt,
    __Unknown__(String),
}

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

impl Validate for AttributeType1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct AuthenticatedData4 {
    #[yaserde(rename = "Vrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Vrsn"))]
    pub vrsn: Number,

    #[yaserde(rename = "Rcpt")]
    #[cfg_attr(feature = "serde", serde(rename = "Rcpt"))]
    pub rcpt: Vec<Recipient4Choice>,

    #[yaserde(rename = "MACAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "MACAlgo"))]
    pub mac_algo: AlgorithmIdentification15,

    #[yaserde(rename = "NcpsltdCntt")]
    #[cfg_attr(feature = "serde", serde(rename = "NcpsltdCntt"))]
    pub ncpsltd_cntt: EncapsulatedContent3,

    #[yaserde(rename = "MAC")]
    #[cfg_attr(feature = "serde", serde(rename = "MAC"))]
    pub mac: Max140Binary,
}

impl Validate for AuthenticatedData4 {}


#[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:catp.016.001.01")]

pub enum AuthenticationEntity2Code {
    #[yaserde(rename = "ICCD")]
    #[cfg_attr(feature = "serde", serde(rename = "ICCD"))]
    Iccd,
    #[yaserde(rename = "AGNT")]
    #[cfg_attr(feature = "serde", serde(rename = "AGNT"))]
    Agnt,
    #[yaserde(rename = "MERC")]
    #[cfg_attr(feature = "serde", serde(rename = "MERC"))]
    Merc,
    #[yaserde(rename = "ACQR")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
    Acqr,
    #[yaserde(rename = "ISSR")]
    #[cfg_attr(feature = "serde", serde(rename = "ISSR"))]
    Issr,
    #[yaserde(rename = "TRML")]
    #[cfg_attr(feature = "serde", serde(rename = "TRML"))]
    Trml,
    __Unknown__(String),
}

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

impl Validate for AuthenticationEntity2Code {}



#[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:catp.016.001.01")]

pub enum AuthenticationMethod7Code {
    #[yaserde(rename = "TOKA")]
    #[cfg_attr(feature = "serde", serde(rename = "TOKA"))]
    Toka,
    #[yaserde(rename = "BIOM")]
    #[cfg_attr(feature = "serde", serde(rename = "BIOM"))]
    Biom,
    #[yaserde(rename = "MOBL")]
    #[cfg_attr(feature = "serde", serde(rename = "MOBL"))]
    Mobl,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "FPIN")]
    #[cfg_attr(feature = "serde", serde(rename = "FPIN"))]
    Fpin,
    #[yaserde(rename = "NPIN")]
    #[cfg_attr(feature = "serde", serde(rename = "NPIN"))]
    Npin,
    #[yaserde(rename = "PSWD")]
    #[cfg_attr(feature = "serde", serde(rename = "PSWD"))]
    Pswd,
    #[yaserde(rename = "SCRT")]
    #[cfg_attr(feature = "serde", serde(rename = "SCRT"))]
    Scrt,
    #[yaserde(rename = "SCNL")]
    #[cfg_attr(feature = "serde", serde(rename = "SCNL"))]
    Scnl,
    __Unknown__(String),
}

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

impl Validate for AuthenticationMethod7Code {}



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

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

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

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

    #[yaserde(rename = "Lctn")]
    #[cfg_attr(feature = "serde", serde(rename = "Lctn"))]
    pub lctn: PostalAddress17,

    #[yaserde(rename = "LctnCtgy")]
    #[cfg_attr(feature = "serde", serde(rename = "LctnCtgy"))]
    pub lctn_ctgy: TransactionEnvironment2Code,

    #[yaserde(rename = "Cpblties")]
    #[cfg_attr(feature = "serde", serde(rename = "Cpblties"))]
    pub cpblties: PointOfInteractionCapabilities7,

    #[yaserde(rename = "Eqpmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "Eqpmnt"))]
    pub eqpmnt: Atmequipment1,
}

impl Validate for AutomatedTellerMachine9 {}


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

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

pub enum BytePadding1Code {
    #[yaserde(rename = "LNGT")]
    #[cfg_attr(feature = "serde", serde(rename = "LNGT"))]
    Lngt,
    #[yaserde(rename = "NUL8")]
    #[cfg_attr(feature = "serde", serde(rename = "NUL8"))]
    Nul8,
    #[yaserde(rename = "NULG")]
    #[cfg_attr(feature = "serde", serde(rename = "NULG"))]
    Nulg,
    #[yaserde(rename = "NULL")]
    #[cfg_attr(feature = "serde", serde(rename = "NULL"))]
    Null,
    #[yaserde(rename = "RAND")]
    #[cfg_attr(feature = "serde", serde(rename = "RAND"))]
    Rand,
    __Unknown__(String),
}

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

impl Validate for BytePadding1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct CardAccount7 {
    #[yaserde(rename = "SelctnMtd")]
    #[cfg_attr(feature = "serde", serde(rename = "SelctnMtd"))]
    pub selctn_mtd: AccountChoiceMethod1Code,

    #[yaserde(rename = "SelctdAcctTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SelctdAcctTp"))]
    pub selctd_acct_tp: CardAccountType3Code,

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

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

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

    #[yaserde(rename = "AcctIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctIdr"))]
    pub acct_idr: AccountIdentification31Choice,

    #[yaserde(rename = "Svcr")]
    #[cfg_attr(feature = "serde", serde(rename = "Svcr"))]
    pub svcr: PartyIdentification72Choice,
}

impl Validate for CardAccount7 {}


#[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:catp.016.001.01")]

pub enum CardAccountType3Code {
    #[yaserde(rename = "CTDP")]
    #[cfg_attr(feature = "serde", serde(rename = "CTDP"))]
    Ctdp,
    #[yaserde(rename = "CHCK")]
    #[cfg_attr(feature = "serde", serde(rename = "CHCK"))]
    Chck,
    #[yaserde(rename = "CRDT")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDT"))]
    Crdt,
    #[yaserde(rename = "CURR")]
    #[cfg_attr(feature = "serde", serde(rename = "CURR"))]
    Curr,
    #[yaserde(rename = "CDBT")]
    #[cfg_attr(feature = "serde", serde(rename = "CDBT"))]
    Cdbt,
    #[yaserde(rename = "DFLT")]
    #[cfg_attr(feature = "serde", serde(rename = "DFLT"))]
    Dflt,
    #[yaserde(rename = "EPRS")]
    #[cfg_attr(feature = "serde", serde(rename = "EPRS"))]
    Eprs,
    #[yaserde(rename = "HEQL")]
    #[cfg_attr(feature = "serde", serde(rename = "HEQL"))]
    Heql,
    #[yaserde(rename = "ISTL")]
    #[cfg_attr(feature = "serde", serde(rename = "ISTL"))]
    Istl,
    #[yaserde(rename = "INVS")]
    #[cfg_attr(feature = "serde", serde(rename = "INVS"))]
    Invs,
    #[yaserde(rename = "LCDT")]
    #[cfg_attr(feature = "serde", serde(rename = "LCDT"))]
    Lcdt,
    #[yaserde(rename = "MBNW")]
    #[cfg_attr(feature = "serde", serde(rename = "MBNW"))]
    Mbnw,
    #[yaserde(rename = "MNMK")]
    #[cfg_attr(feature = "serde", serde(rename = "MNMK"))]
    Mnmk,
    #[yaserde(rename = "MNMC")]
    #[cfg_attr(feature = "serde", serde(rename = "MNMC"))]
    Mnmc,
    #[yaserde(rename = "MTGL")]
    #[cfg_attr(feature = "serde", serde(rename = "MTGL"))]
    Mtgl,
    #[yaserde(rename = "RTRM")]
    #[cfg_attr(feature = "serde", serde(rename = "RTRM"))]
    Rtrm,
    #[yaserde(rename = "RVLV")]
    #[cfg_attr(feature = "serde", serde(rename = "RVLV"))]
    Rvlv,
    #[yaserde(rename = "SVNG")]
    #[cfg_attr(feature = "serde", serde(rename = "SVNG"))]
    Svng,
    #[yaserde(rename = "STBD")]
    #[cfg_attr(feature = "serde", serde(rename = "STBD"))]
    Stbd,
    #[yaserde(rename = "UVRL")]
    #[cfg_attr(feature = "serde", serde(rename = "UVRL"))]
    Uvrl,
    #[yaserde(rename = "PRPD")]
    #[cfg_attr(feature = "serde", serde(rename = "PRPD"))]
    Prpd,
    #[yaserde(rename = "FLTC")]
    #[cfg_attr(feature = "serde", serde(rename = "FLTC"))]
    Fltc,
    __Unknown__(String),
}

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

impl Validate for CardAccountType3Code {}



#[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:catp.016.001.01")]

pub enum CardDataReading1Code {
    #[yaserde(rename = "TAGC")]
    #[cfg_attr(feature = "serde", serde(rename = "TAGC"))]
    Tagc,
    #[yaserde(rename = "PHYS")]
    #[cfg_attr(feature = "serde", serde(rename = "PHYS"))]
    Phys,
    #[yaserde(rename = "BRCD")]
    #[cfg_attr(feature = "serde", serde(rename = "BRCD"))]
    Brcd,
    #[yaserde(rename = "MGST")]
    #[cfg_attr(feature = "serde", serde(rename = "MGST"))]
    Mgst,
    #[yaserde(rename = "CICC")]
    #[cfg_attr(feature = "serde", serde(rename = "CICC"))]
    Cicc,
    #[yaserde(rename = "DFLE")]
    #[cfg_attr(feature = "serde", serde(rename = "DFLE"))]
    Dfle,
    #[yaserde(rename = "CTLS")]
    #[cfg_attr(feature = "serde", serde(rename = "CTLS"))]
    Ctls,
    #[yaserde(rename = "ECTL")]
    #[cfg_attr(feature = "serde", serde(rename = "ECTL"))]
    Ectl,
    __Unknown__(String),
}

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

impl Validate for CardDataReading1Code {}



#[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:catp.016.001.01")]

pub enum CardDataReading4Code {
    #[yaserde(rename = "ECTL")]
    #[cfg_attr(feature = "serde", serde(rename = "ECTL"))]
    Ectl,
    #[yaserde(rename = "CICC")]
    #[cfg_attr(feature = "serde", serde(rename = "CICC"))]
    Cicc,
    #[yaserde(rename = "MGST")]
    #[cfg_attr(feature = "serde", serde(rename = "MGST"))]
    Mgst,
    #[yaserde(rename = "CTLS")]
    #[cfg_attr(feature = "serde", serde(rename = "CTLS"))]
    Ctls,
    __Unknown__(String),
}

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

impl Validate for CardDataReading4Code {}



#[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:catp.016.001.01")]

pub enum CardFallback1Code {
    #[yaserde(rename = "FFLB")]
    #[cfg_attr(feature = "serde", serde(rename = "FFLB"))]
    Fflb,
    #[yaserde(rename = "SFLB")]
    #[cfg_attr(feature = "serde", serde(rename = "SFLB"))]
    Sflb,
    #[yaserde(rename = "NFLB")]
    #[cfg_attr(feature = "serde", serde(rename = "NFLB"))]
    Nflb,
    __Unknown__(String),
}

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

impl Validate for CardFallback1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct CardholderAuthentication8 {
    #[yaserde(rename = "AuthntcnMtd")]
    #[cfg_attr(feature = "serde", serde(rename = "AuthntcnMtd"))]
    pub authntcn_mtd: AuthenticationMethod7Code,

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

    #[yaserde(rename = "AuthntcnVal")]
    #[cfg_attr(feature = "serde", serde(rename = "AuthntcnVal"))]
    pub authntcn_val: Max5000Binary,

    #[yaserde(rename = "PrtctdAuthntcnVal")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtctdAuthntcnVal"))]
    pub prtctd_authntcn_val: ContentInformationType10,

    #[yaserde(rename = "CrdhldrOnLinePIN")]
    #[cfg_attr(feature = "serde", serde(rename = "CrdhldrOnLinePIN"))]
    pub crdhldr_on_line_pin: OnLinePIN5,
}

impl Validate for CardholderAuthentication8 {}


#[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:catp.016.001.01")]

pub enum CardholderVerificationCapability3Code {
    #[yaserde(rename = "NPIN")]
    #[cfg_attr(feature = "serde", serde(rename = "NPIN"))]
    Npin,
    #[yaserde(rename = "FCPN")]
    #[cfg_attr(feature = "serde", serde(rename = "FCPN"))]
    Fcpn,
    #[yaserde(rename = "FEPN")]
    #[cfg_attr(feature = "serde", serde(rename = "FEPN"))]
    Fepn,
    #[yaserde(rename = "FDSG")]
    #[cfg_attr(feature = "serde", serde(rename = "FDSG"))]
    Fdsg,
    #[yaserde(rename = "FBIO")]
    #[cfg_attr(feature = "serde", serde(rename = "FBIO"))]
    Fbio,
    #[yaserde(rename = "FBIG")]
    #[cfg_attr(feature = "serde", serde(rename = "FBIG"))]
    Fbig,
    #[yaserde(rename = "PKIS")]
    #[cfg_attr(feature = "serde", serde(rename = "PKIS"))]
    Pkis,
    #[yaserde(rename = "PCOD")]
    #[cfg_attr(feature = "serde", serde(rename = "PCOD"))]
    Pcod,
    __Unknown__(String),
}

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

impl Validate for CardholderVerificationCapability3Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct CertificateIssuer1 {
    #[yaserde(rename = "RltvDstngshdNm")]
    #[cfg_attr(feature = "serde", serde(rename = "RltvDstngshdNm"))]
    pub rltv_dstngshd_nm: Vec<RelativeDistinguishedName1>,
}

impl Validate for CertificateIssuer1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct ContentInformationType10 {
    #[yaserde(rename = "CnttTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CnttTp"))]
    pub cntt_tp: ContentType2Code,

    #[yaserde(rename = "EnvlpdData")]
    #[cfg_attr(feature = "serde", serde(rename = "EnvlpdData"))]
    pub envlpd_data: EnvelopedData4,
}

impl Validate for ContentInformationType10 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct ContentInformationType15 {
    #[yaserde(rename = "CnttTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CnttTp"))]
    pub cntt_tp: ContentType2Code,

    #[yaserde(rename = "AuthntcdData")]
    #[cfg_attr(feature = "serde", serde(rename = "AuthntcdData"))]
    pub authntcd_data: AuthenticatedData4,
}

impl Validate for ContentInformationType15 {}


#[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:catp.016.001.01")]

pub enum ContentType2Code {
    #[yaserde(rename = "DATA")]
    #[cfg_attr(feature = "serde", serde(rename = "DATA"))]
    Data,
    #[yaserde(rename = "SIGN")]
    #[cfg_attr(feature = "serde", serde(rename = "SIGN"))]
    Sign,
    #[yaserde(rename = "EVLP")]
    #[cfg_attr(feature = "serde", serde(rename = "EVLP"))]
    Evlp,
    #[yaserde(rename = "DGST")]
    #[cfg_attr(feature = "serde", serde(rename = "DGST"))]
    Dgst,
    #[yaserde(rename = "AUTH")]
    #[cfg_attr(feature = "serde", serde(rename = "AUTH"))]
    Auth,
    __Unknown__(String),
}

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

impl Validate for ContentType2Code {}



#[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:catp.016.001.01")]

pub enum DataSetCategory7Code {
    #[yaserde(rename = "ATMC")]
    #[cfg_attr(feature = "serde", serde(rename = "ATMC"))]
    Atmc,
    #[yaserde(rename = "ATMP")]
    #[cfg_attr(feature = "serde", serde(rename = "ATMP"))]
    Atmp,
    #[yaserde(rename = "APPR")]
    #[cfg_attr(feature = "serde", serde(rename = "APPR"))]
    Appr,
    #[yaserde(rename = "CRAP")]
    #[cfg_attr(feature = "serde", serde(rename = "CRAP"))]
    Crap,
    #[yaserde(rename = "CPRC")]
    #[cfg_attr(feature = "serde", serde(rename = "CPRC"))]
    Cprc,
    #[yaserde(rename = "OEXR")]
    #[cfg_attr(feature = "serde", serde(rename = "OEXR"))]
    Oexr,
    #[yaserde(rename = "AMNT")]
    #[cfg_attr(feature = "serde", serde(rename = "AMNT"))]
    Amnt,
    #[yaserde(rename = "LOCC")]
    #[cfg_attr(feature = "serde", serde(rename = "LOCC"))]
    Locc,
    #[yaserde(rename = "MNOC")]
    #[cfg_attr(feature = "serde", serde(rename = "MNOC"))]
    Mnoc,
    __Unknown__(String),
}

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

impl Validate for DataSetCategory7Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct DetailedAmount17 {
    #[yaserde(rename = "AmtToTrf")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtToTrf"))]
    pub amt_to_trf: ImpliedCurrencyAndAmount,

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

    #[yaserde(rename = "Fees")]
    #[cfg_attr(feature = "serde", serde(rename = "Fees"))]
    pub fees: Vec<DetailedAmount18>,

    #[yaserde(rename = "Dontn")]
    #[cfg_attr(feature = "serde", serde(rename = "Dontn"))]
    pub dontn: Vec<DetailedAmount18>,
}

impl Validate for DetailedAmount17 {}


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

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

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

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

impl Validate for DetailedAmount18 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct DisplayCapabilities5 {
    #[yaserde(rename = "Dstn")]
    #[cfg_attr(feature = "serde", serde(rename = "Dstn"))]
    pub dstn: Vec<UserInterface5Code>,

    #[yaserde(rename = "AvlblFrmt")]
    #[cfg_attr(feature = "serde", serde(rename = "AvlblFrmt"))]
    pub avlbl_frmt: Vec<OutputFormat1Code>,

    #[yaserde(rename = "NbOfLines")]
    #[cfg_attr(feature = "serde", serde(rename = "NbOfLines"))]
    pub nb_of_lines: Number,

    #[yaserde(rename = "LineWidth")]
    #[cfg_attr(feature = "serde", serde(rename = "LineWidth"))]
    pub line_width: Number,

    #[yaserde(rename = "AvlblLang")]
    #[cfg_attr(feature = "serde", serde(rename = "AvlblLang"))]
    pub avlbl_lang: Vec<LanguageCode>,
}

impl Validate for DisplayCapabilities5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct Document {
    #[yaserde(rename = "ATMTrfReq")]
    #[cfg_attr(feature = "serde", serde(rename = "ATMTrfReq"))]
    pub atm_trf_req: AtmtransferRequestV01,
}

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:catp.016.001.01")]
pub struct EncapsulatedContent3 {
    #[yaserde(rename = "CnttTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CnttTp"))]
    pub cntt_tp: ContentType2Code,

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

impl Validate for EncapsulatedContent3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct EncryptedContent3 {
    #[yaserde(rename = "CnttTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CnttTp"))]
    pub cntt_tp: ContentType2Code,

    #[yaserde(rename = "CnttNcrptnAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "CnttNcrptnAlgo"))]
    pub cntt_ncrptn_algo: AlgorithmIdentification14,

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

impl Validate for EncryptedContent3 {}


#[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:catp.016.001.01")]

pub enum EncryptionFormat1Code {
    #[yaserde(rename = "TR31")]
    #[cfg_attr(feature = "serde", serde(rename = "TR31"))]
    Tr31,
    #[yaserde(rename = "TR34")]
    #[cfg_attr(feature = "serde", serde(rename = "TR34"))]
    Tr34,
    __Unknown__(String),
}

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

impl Validate for EncryptionFormat1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct EnvelopedData4 {
    #[yaserde(rename = "Vrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Vrsn"))]
    pub vrsn: Number,

    #[yaserde(rename = "Rcpt")]
    #[cfg_attr(feature = "serde", serde(rename = "Rcpt"))]
    pub rcpt: Vec<Recipient4Choice>,

    #[yaserde(rename = "NcrptdCntt")]
    #[cfg_attr(feature = "serde", serde(rename = "NcrptdCntt"))]
    pub ncrptd_cntt: EncryptedContent3,
}

impl Validate for EnvelopedData4 {}


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

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

impl Validate for Exact3NumericText {}
#[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:catp.016.001.01")]

pub enum Frequency3Code {
    #[yaserde(rename = "YEAR")]
    #[cfg_attr(feature = "serde", serde(rename = "YEAR"))]
    Year,
    #[yaserde(rename = "MNTH")]
    #[cfg_attr(feature = "serde", serde(rename = "MNTH"))]
    Mnth,
    #[yaserde(rename = "QURT")]
    #[cfg_attr(feature = "serde", serde(rename = "QURT"))]
    Qurt,
    #[yaserde(rename = "MIAN")]
    #[cfg_attr(feature = "serde", serde(rename = "MIAN"))]
    Mian,
    #[yaserde(rename = "WEEK")]
    #[cfg_attr(feature = "serde", serde(rename = "WEEK"))]
    Week,
    #[yaserde(rename = "DAIL")]
    #[cfg_attr(feature = "serde", serde(rename = "DAIL"))]
    Dail,
    #[yaserde(rename = "TEND")]
    #[cfg_attr(feature = "serde", serde(rename = "TEND"))]
    Tend,
    __Unknown__(String),
}

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

impl Validate for Frequency3Code {}



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

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

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

impl Validate for GenericIdentification1 {}


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

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

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

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

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

impl Validate for GenericIdentification77 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct GeographicCoordinates1 {
    #[yaserde(rename = "Lat")]
    #[cfg_attr(feature = "serde", serde(rename = "Lat"))]
    pub lat: Max16Text,

    #[yaserde(rename = "Long")]
    #[cfg_attr(feature = "serde", serde(rename = "Long"))]
    pub long: Max16Text,
}

impl Validate for GeographicCoordinates1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct GeographicLocation1Choice {
    #[yaserde(rename = "GeogcCordints")]
    #[cfg_attr(feature = "serde", serde(rename = "GeogcCordints"))]
    pub geogc_cordints: Option<GeographicCoordinates1>,
    #[yaserde(rename = "UTMCordints")]
    #[cfg_attr(feature = "serde", serde(rename = "UTMCordints"))]
    pub utmcordints: Option<Utmcoordinates1>,
}

impl Validate for GeographicLocation1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct Header31 {
    #[yaserde(rename = "MsgFctn")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgFctn"))]
    pub msg_fctn: AtmmessageFunction2,

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

    #[yaserde(rename = "XchgId")]
    #[cfg_attr(feature = "serde", serde(rename = "XchgId"))]
    pub xchg_id: Max3NumericText,

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

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

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

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

    #[yaserde(rename = "Tracblt")]
    #[cfg_attr(feature = "serde", serde(rename = "Tracblt"))]
    pub tracblt: Vec<Traceability4>,
}

impl Validate for Header31 {}


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

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

impl Validate for ImpliedCurrencyAndAmount {
    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:catp.016.001.01")]
pub struct IssuerAndSerialNumber1 {
    #[yaserde(rename = "Issr")]
    #[cfg_attr(feature = "serde", serde(rename = "Issr"))]
    pub issr: CertificateIssuer1,

    #[yaserde(rename = "SrlNb")]
    #[cfg_attr(feature = "serde", serde(rename = "SrlNb"))]
    pub srl_nb: Max35Binary,
}

impl Validate for IssuerAndSerialNumber1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct Kek4 {
    #[yaserde(rename = "Vrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Vrsn"))]
    pub vrsn: Number,

    #[yaserde(rename = "KEKId")]
    #[cfg_attr(feature = "serde", serde(rename = "KEKId"))]
    pub kek_id: Kekidentifier2,

    #[yaserde(rename = "KeyNcrptnAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyNcrptnAlgo"))]
    pub key_ncrptn_algo: AlgorithmIdentification13,

    #[yaserde(rename = "NcrptdKey")]
    #[cfg_attr(feature = "serde", serde(rename = "NcrptdKey"))]
    pub ncrptd_key: Max500Binary,
}

impl Validate for Kek4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct Kekidentifier2 {
    #[yaserde(rename = "KeyId")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyId"))]
    pub key_id: Max140Text,

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

    #[yaserde(rename = "SeqNb")]
    #[cfg_attr(feature = "serde", serde(rename = "SeqNb"))]
    pub seq_nb: Number,

    #[yaserde(rename = "DerivtnId")]
    #[cfg_attr(feature = "serde", serde(rename = "DerivtnId"))]
    pub derivtn_id: Min5Max16Binary,
}

impl Validate for Kekidentifier2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct KeyTransport4 {
    #[yaserde(rename = "Vrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Vrsn"))]
    pub vrsn: Number,

    #[yaserde(rename = "RcptId")]
    #[cfg_attr(feature = "serde", serde(rename = "RcptId"))]
    pub rcpt_id: Recipient5Choice,

    #[yaserde(rename = "KeyNcrptnAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyNcrptnAlgo"))]
    pub key_ncrptn_algo: AlgorithmIdentification11,

    #[yaserde(rename = "NcrptdKey")]
    #[cfg_attr(feature = "serde", serde(rename = "NcrptdKey"))]
    pub ncrptd_key: Max5000Binary,
}

impl Validate for KeyTransport4 {}


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Validate for Max76Text {
    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() > 76 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 76 \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:catp.016.001.01")]

pub enum MessageFunction11Code {
    #[yaserde(rename = "BALN")]
    #[cfg_attr(feature = "serde", serde(rename = "BALN"))]
    Baln,
    #[yaserde(rename = "CMPA")]
    #[cfg_attr(feature = "serde", serde(rename = "CMPA"))]
    Cmpa,
    #[yaserde(rename = "CMPD")]
    #[cfg_attr(feature = "serde", serde(rename = "CMPD"))]
    Cmpd,
    #[yaserde(rename = "ACMD")]
    #[cfg_attr(feature = "serde", serde(rename = "ACMD"))]
    Acmd,
    #[yaserde(rename = "DVCC")]
    #[cfg_attr(feature = "serde", serde(rename = "DVCC"))]
    Dvcc,
    #[yaserde(rename = "DIAQ")]
    #[cfg_attr(feature = "serde", serde(rename = "DIAQ"))]
    Diaq,
    #[yaserde(rename = "DIAP")]
    #[cfg_attr(feature = "serde", serde(rename = "DIAP"))]
    Diap,
    #[yaserde(rename = "GSTS")]
    #[cfg_attr(feature = "serde", serde(rename = "GSTS"))]
    Gsts,
    #[yaserde(rename = "INQQ")]
    #[cfg_attr(feature = "serde", serde(rename = "INQQ"))]
    Inqq,
    #[yaserde(rename = "INQP")]
    #[cfg_attr(feature = "serde", serde(rename = "INQP"))]
    Inqp,
    #[yaserde(rename = "KYAQ")]
    #[cfg_attr(feature = "serde", serde(rename = "KYAQ"))]
    Kyaq,
    #[yaserde(rename = "KYAP")]
    #[cfg_attr(feature = "serde", serde(rename = "KYAP"))]
    Kyap,
    #[yaserde(rename = "PINQ")]
    #[cfg_attr(feature = "serde", serde(rename = "PINQ"))]
    Pinq,
    #[yaserde(rename = "PINP")]
    #[cfg_attr(feature = "serde", serde(rename = "PINP"))]
    Pinp,
    #[yaserde(rename = "RJAQ")]
    #[cfg_attr(feature = "serde", serde(rename = "RJAQ"))]
    Rjaq,
    #[yaserde(rename = "RJAP")]
    #[cfg_attr(feature = "serde", serde(rename = "RJAP"))]
    Rjap,
    #[yaserde(rename = "WITV")]
    #[cfg_attr(feature = "serde", serde(rename = "WITV"))]
    Witv,
    #[yaserde(rename = "WITK")]
    #[cfg_attr(feature = "serde", serde(rename = "WITK"))]
    Witk,
    #[yaserde(rename = "WITQ")]
    #[cfg_attr(feature = "serde", serde(rename = "WITQ"))]
    Witq,
    #[yaserde(rename = "WITP")]
    #[cfg_attr(feature = "serde", serde(rename = "WITP"))]
    Witp,
    #[yaserde(rename = "INQC")]
    #[cfg_attr(feature = "serde", serde(rename = "INQC"))]
    Inqc,
    #[yaserde(rename = "H2AP")]
    #[cfg_attr(feature = "serde", serde(rename = "H2AP"))]
    H2Ap,
    #[yaserde(rename = "H2AQ")]
    #[cfg_attr(feature = "serde", serde(rename = "H2AQ"))]
    H2Aq,
    #[yaserde(rename = "TMOP")]
    #[cfg_attr(feature = "serde", serde(rename = "TMOP"))]
    Tmop,
    #[yaserde(rename = "CSEC")]
    #[cfg_attr(feature = "serde", serde(rename = "CSEC"))]
    Csec,
    #[yaserde(rename = "DSEC")]
    #[cfg_attr(feature = "serde", serde(rename = "DSEC"))]
    Dsec,
    #[yaserde(rename = "SKSC")]
    #[cfg_attr(feature = "serde", serde(rename = "SKSC"))]
    Sksc,
    #[yaserde(rename = "SSTS")]
    #[cfg_attr(feature = "serde", serde(rename = "SSTS"))]
    Ssts,
    #[yaserde(rename = "DPSK")]
    #[cfg_attr(feature = "serde", serde(rename = "DPSK"))]
    Dpsk,
    #[yaserde(rename = "DPSV")]
    #[cfg_attr(feature = "serde", serde(rename = "DPSV"))]
    Dpsv,
    #[yaserde(rename = "DPSQ")]
    #[cfg_attr(feature = "serde", serde(rename = "DPSQ"))]
    Dpsq,
    #[yaserde(rename = "DPSP")]
    #[cfg_attr(feature = "serde", serde(rename = "DPSP"))]
    Dpsp,
    #[yaserde(rename = "EXPK")]
    #[cfg_attr(feature = "serde", serde(rename = "EXPK"))]
    Expk,
    #[yaserde(rename = "EXPV")]
    #[cfg_attr(feature = "serde", serde(rename = "EXPV"))]
    Expv,
    #[yaserde(rename = "TRFQ")]
    #[cfg_attr(feature = "serde", serde(rename = "TRFQ"))]
    Trfq,
    #[yaserde(rename = "TRFP")]
    #[cfg_attr(feature = "serde", serde(rename = "TRFP"))]
    Trfp,
    #[yaserde(rename = "RPTC")]
    #[cfg_attr(feature = "serde", serde(rename = "RPTC"))]
    Rptc,
    __Unknown__(String),
}

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

impl Validate for MessageFunction11Code {}



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

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

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

impl Validate for Min5Max16Binary {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 5 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 5 \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 Min8Max28NumericText (pub String);
crate::simple_type!(Min8Max28NumericText);

impl Validate for Min8Max28NumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct NameAndAddress3 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max70Text,

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

impl Validate for NameAndAddress3 {}


#[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:catp.016.001.01")]
pub struct OnLinePIN5 {
    #[yaserde(rename = "NcrptdPINBlck")]
    #[cfg_attr(feature = "serde", serde(rename = "NcrptdPINBlck"))]
    pub ncrptd_pin_blck: ContentInformationType10,

    #[yaserde(rename = "PINFrmt")]
    #[cfg_attr(feature = "serde", serde(rename = "PINFrmt"))]
    pub pin_frmt: Pinformat4Code,

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

impl Validate for OnLinePIN5 {}


#[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:catp.016.001.01")]

pub enum OutputFormat1Code {
    #[yaserde(rename = "MREF")]
    #[cfg_attr(feature = "serde", serde(rename = "MREF"))]
    Mref,
    #[yaserde(rename = "TEXT")]
    #[cfg_attr(feature = "serde", serde(rename = "TEXT"))]
    Text,
    #[yaserde(rename = "HTML")]
    #[cfg_attr(feature = "serde", serde(rename = "HTML"))]
    Html,
    __Unknown__(String),
}

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

impl Validate for OutputFormat1Code {}



#[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:catp.016.001.01")]

pub enum Pinformat4Code {
    #[yaserde(rename = "ANSI")]
    #[cfg_attr(feature = "serde", serde(rename = "ANSI"))]
    Ansi,
    #[yaserde(rename = "BNCM")]
    #[cfg_attr(feature = "serde", serde(rename = "BNCM"))]
    Bncm,
    #[yaserde(rename = "BKSY")]
    #[cfg_attr(feature = "serde", serde(rename = "BKSY"))]
    Bksy,
    #[yaserde(rename = "DBLD")]
    #[cfg_attr(feature = "serde", serde(rename = "DBLD"))]
    Dbld,
    #[yaserde(rename = "DBLC")]
    #[cfg_attr(feature = "serde", serde(rename = "DBLC"))]
    Dblc,
    #[yaserde(rename = "ECI2")]
    #[cfg_attr(feature = "serde", serde(rename = "ECI2"))]
    Eci2,
    #[yaserde(rename = "ECI3")]
    #[cfg_attr(feature = "serde", serde(rename = "ECI3"))]
    Eci3,
    #[yaserde(rename = "EMVS")]
    #[cfg_attr(feature = "serde", serde(rename = "EMVS"))]
    Emvs,
    #[yaserde(rename = "IBM3")]
    #[cfg_attr(feature = "serde", serde(rename = "IBM3"))]
    Ibm3,
    #[yaserde(rename = "ISO0")]
    #[cfg_attr(feature = "serde", serde(rename = "ISO0"))]
    Iso0,
    #[yaserde(rename = "ISO1")]
    #[cfg_attr(feature = "serde", serde(rename = "ISO1"))]
    Iso1,
    #[yaserde(rename = "ISO2")]
    #[cfg_attr(feature = "serde", serde(rename = "ISO2"))]
    Iso2,
    #[yaserde(rename = "ISO3")]
    #[cfg_attr(feature = "serde", serde(rename = "ISO3"))]
    Iso3,
    #[yaserde(rename = "ISO4")]
    #[cfg_attr(feature = "serde", serde(rename = "ISO4"))]
    Iso4,
    #[yaserde(rename = "ISO5")]
    #[cfg_attr(feature = "serde", serde(rename = "ISO5"))]
    Iso5,
    #[yaserde(rename = "VIS2")]
    #[cfg_attr(feature = "serde", serde(rename = "VIS2"))]
    Vis2,
    #[yaserde(rename = "VIS3")]
    #[cfg_attr(feature = "serde", serde(rename = "VIS3"))]
    Vis3,
    __Unknown__(String),
}

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

impl Validate for Pinformat4Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct Parameter4 {
    #[yaserde(rename = "NcrptnFrmt")]
    #[cfg_attr(feature = "serde", serde(rename = "NcrptnFrmt"))]
    pub ncrptn_frmt: EncryptionFormat1Code,

    #[yaserde(rename = "DgstAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "DgstAlgo"))]
    pub dgst_algo: Algorithm11Code,

    #[yaserde(rename = "MskGnrtrAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "MskGnrtrAlgo"))]
    pub msk_gnrtr_algo: AlgorithmIdentification12,
}

impl Validate for Parameter4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct Parameter5 {
    #[yaserde(rename = "DgstAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "DgstAlgo"))]
    pub dgst_algo: Algorithm11Code,
}

impl Validate for Parameter5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct Parameter6 {
    #[yaserde(rename = "NcrptnFrmt")]
    #[cfg_attr(feature = "serde", serde(rename = "NcrptnFrmt"))]
    pub ncrptn_frmt: EncryptionFormat1Code,

    #[yaserde(rename = "InitlstnVctr")]
    #[cfg_attr(feature = "serde", serde(rename = "InitlstnVctr"))]
    pub initlstn_vctr: Max500Binary,

    #[yaserde(rename = "BPddg")]
    #[cfg_attr(feature = "serde", serde(rename = "BPddg"))]
    pub b_pddg: BytePadding1Code,
}

impl Validate for Parameter6 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct Parameter7 {
    #[yaserde(rename = "InitlstnVctr")]
    #[cfg_attr(feature = "serde", serde(rename = "InitlstnVctr"))]
    pub initlstn_vctr: Max500Binary,

    #[yaserde(rename = "BPddg")]
    #[cfg_attr(feature = "serde", serde(rename = "BPddg"))]
    pub b_pddg: BytePadding1Code,
}

impl Validate for Parameter7 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct PartyIdentification72Choice {
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_b_i_c: Option<AnyBICIdentifier>,
    #[yaserde(rename = "PrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
    pub prtry_id: Option<GenericIdentification1>,
}

impl Validate for PartyIdentification72Choice {}




#[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:catp.016.001.01")]

pub enum PartyType12Code {
    #[yaserde(rename = "ACQR")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
    Acqr,
    #[yaserde(rename = "ATMG")]
    #[cfg_attr(feature = "serde", serde(rename = "ATMG"))]
    Atmg,
    #[yaserde(rename = "CISP")]
    #[cfg_attr(feature = "serde", serde(rename = "CISP"))]
    Cisp,
    #[yaserde(rename = "DLIS")]
    #[cfg_attr(feature = "serde", serde(rename = "DLIS"))]
    Dlis,
    #[yaserde(rename = "HSTG")]
    #[cfg_attr(feature = "serde", serde(rename = "HSTG"))]
    Hstg,
    #[yaserde(rename = "ITAG")]
    #[cfg_attr(feature = "serde", serde(rename = "ITAG"))]
    Itag,
    #[yaserde(rename = "OATM")]
    #[cfg_attr(feature = "serde", serde(rename = "OATM"))]
    Oatm,
    __Unknown__(String),
}

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

impl Validate for PartyType12Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct PaymentCard22 {
    #[yaserde(rename = "CardDataNtryMd")]
    #[cfg_attr(feature = "serde", serde(rename = "CardDataNtryMd"))]
    pub card_data_ntry_md: CardDataReading1Code,

    #[yaserde(rename = "FllbckInd")]
    #[cfg_attr(feature = "serde", serde(rename = "FllbckInd"))]
    pub fllbck_ind: CardFallback1Code,

    #[yaserde(rename = "PrtctdCardData")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtctdCardData"))]
    pub prtctd_card_data: ContentInformationType10,

    #[yaserde(rename = "PlainCardData")]
    #[cfg_attr(feature = "serde", serde(rename = "PlainCardData"))]
    pub plain_card_data: PlainCardData18,

    #[yaserde(rename = "CardCtryCd")]
    #[cfg_attr(feature = "serde", serde(rename = "CardCtryCd"))]
    pub card_ctry_cd: Max3Text,

    #[yaserde(rename = "CardCcyCd")]
    #[cfg_attr(feature = "serde", serde(rename = "CardCcyCd"))]
    pub card_ccy_cd: Exact3AlphaNumericText,
}

impl Validate for PaymentCard22 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct PlainCardData18 {
    #[yaserde(rename = "PAN")]
    #[cfg_attr(feature = "serde", serde(rename = "PAN"))]
    pub pan: Min8Max28NumericText,

    #[yaserde(rename = "CardSeqNb")]
    #[cfg_attr(feature = "serde", serde(rename = "CardSeqNb"))]
    pub card_seq_nb: Min2Max3NumericText,

    #[yaserde(rename = "FctvDt")]
    #[cfg_attr(feature = "serde", serde(rename = "FctvDt"))]
    pub fctv_dt: Max10Text,

    #[yaserde(rename = "XpryDt")]
    #[cfg_attr(feature = "serde", serde(rename = "XpryDt"))]
    pub xpry_dt: Max10Text,

    #[yaserde(rename = "SvcCd")]
    #[cfg_attr(feature = "serde", serde(rename = "SvcCd"))]
    pub svc_cd: Exact3NumericText,

    #[yaserde(rename = "Trck1")]
    #[cfg_attr(feature = "serde", serde(rename = "Trck1"))]
    pub trck_1: Max76Text,

    #[yaserde(rename = "Trck2")]
    #[cfg_attr(feature = "serde", serde(rename = "Trck2"))]
    pub trck_2: Max37Text,

    #[yaserde(rename = "Trck3")]
    #[cfg_attr(feature = "serde", serde(rename = "Trck3"))]
    pub trck_3: Max104Text,

    #[yaserde(rename = "CrdhldrNm")]
    #[cfg_attr(feature = "serde", serde(rename = "CrdhldrNm"))]
    pub crdhldr_nm: Max45Text,
}

impl Validate for PlainCardData18 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct PointOfInteractionCapabilities7 {
    #[yaserde(rename = "CardRdData")]
    #[cfg_attr(feature = "serde", serde(rename = "CardRdData"))]
    pub card_rd_data: Vec<CardDataReading4Code>,

    #[yaserde(rename = "CardWrtData")]
    #[cfg_attr(feature = "serde", serde(rename = "CardWrtData"))]
    pub card_wrt_data: Vec<CardDataReading4Code>,

    #[yaserde(rename = "Authntcn")]
    #[cfg_attr(feature = "serde", serde(rename = "Authntcn"))]
    pub authntcn: Vec<CardholderVerificationCapability3Code>,

    #[yaserde(rename = "PINLngthCpblties")]
    #[cfg_attr(feature = "serde", serde(rename = "PINLngthCpblties"))]
    pub pin_lngth_cpblties: Number,

    #[yaserde(rename = "ApprvlCdLngth")]
    #[cfg_attr(feature = "serde", serde(rename = "ApprvlCdLngth"))]
    pub apprvl_cd_lngth: Number,

    #[yaserde(rename = "MxScrptLngth")]
    #[cfg_attr(feature = "serde", serde(rename = "MxScrptLngth"))]
    pub mx_scrpt_lngth: Number,

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

    #[yaserde(rename = "WdrwlMdia")]
    #[cfg_attr(feature = "serde", serde(rename = "WdrwlMdia"))]
    pub wdrwl_mdia: Vec<AtmmediaType1Code>,

    #[yaserde(rename = "DpstdMdia")]
    #[cfg_attr(feature = "serde", serde(rename = "DpstdMdia"))]
    pub dpstd_mdia: Vec<AtmmediaType2Code>,

    #[yaserde(rename = "MsgCpblties")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgCpblties"))]
    pub msg_cpblties: Vec<DisplayCapabilities5>,
}

impl Validate for PointOfInteractionCapabilities7 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct PostalAddress1 {
    #[yaserde(rename = "AdrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "AdrTp"))]
    pub adr_tp: AddressType2Code,

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

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

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

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

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

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

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

impl Validate for PostalAddress1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct PostalAddress17 {
    #[yaserde(rename = "AdrLine")]
    #[cfg_attr(feature = "serde", serde(rename = "AdrLine"))]
    pub adr_line: Vec<Max70Text>,

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

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

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

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

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

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

    #[yaserde(rename = "GLctn")]
    #[cfg_attr(feature = "serde", serde(rename = "GLctn"))]
    pub g_lctn: GeographicLocation1Choice,
}

impl Validate for PostalAddress17 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct Recipient4Choice {
    #[yaserde(rename = "KeyTrnsprt")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyTrnsprt"))]
    pub key_trnsprt: Option<KeyTransport4>,
    #[yaserde(rename = "KEK")]
    #[cfg_attr(feature = "serde", serde(rename = "KEK"))]
    pub kek: Option<Kek4>,
    #[yaserde(rename = "KeyIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyIdr"))]
    pub key_idr: Option<Kekidentifier2>,
}

impl Validate for Recipient4Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct Recipient5Choice {
    #[yaserde(rename = "IssrAndSrlNb")]
    #[cfg_attr(feature = "serde", serde(rename = "IssrAndSrlNb"))]
    pub issr_and_srl_nb: Option<IssuerAndSerialNumber1>,
    #[yaserde(rename = "KeyIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyIdr"))]
    pub key_idr: Option<Kekidentifier2>,
}

impl Validate for Recipient5Choice {}




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

    #[yaserde(rename = "NbOfOcrncs")]
    #[cfg_attr(feature = "serde", serde(rename = "NbOfOcrncs"))]
    pub nb_of_ocrncs: Number,

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

    #[yaserde(rename = "PrdUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "PrdUnit"))]
    pub prd_unit: Frequency3Code,

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

impl Validate for RecurringTransaction3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct RelativeDistinguishedName1 {
    #[yaserde(rename = "AttrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "AttrTp"))]
    pub attr_tp: AttributeType1Code,

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

impl Validate for RelativeDistinguishedName1 {}


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

impl Validate for SimpleIdentificationInformation4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct TerminalHosting1 {
    #[yaserde(rename = "Ctgy")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctgy"))]
    pub ctgy: TransactionEnvironment3Code,

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

impl Validate for TerminalHosting1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct Traceability4 {
    #[yaserde(rename = "RlayId")]
    #[cfg_attr(feature = "serde", serde(rename = "RlayId"))]
    pub rlay_id: GenericIdentification77,

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

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

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

impl Validate for Traceability4 {}


#[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:catp.016.001.01")]

pub enum TransactionEnvironment2Code {
    #[yaserde(rename = "PRIV")]
    #[cfg_attr(feature = "serde", serde(rename = "PRIV"))]
    Priv,
    #[yaserde(rename = "PUBL")]
    #[cfg_attr(feature = "serde", serde(rename = "PUBL"))]
    Publ,
    __Unknown__(String),
}

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

impl Validate for TransactionEnvironment2Code {}



#[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:catp.016.001.01")]

pub enum TransactionEnvironment3Code {
    #[yaserde(rename = "BRCH")]
    #[cfg_attr(feature = "serde", serde(rename = "BRCH"))]
    Brch,
    #[yaserde(rename = "MERC")]
    #[cfg_attr(feature = "serde", serde(rename = "MERC"))]
    Merc,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    __Unknown__(String),
}

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

impl Validate for TransactionEnvironment3Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct TransactionIdentifier1 {
    #[yaserde(rename = "TxDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "TxDtTm"))]
    pub tx_dt_tm: IsodateTime,

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

impl Validate for TransactionIdentifier1 {}


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

    #[yaserde(rename = "VrfctnNtty")]
    #[cfg_attr(feature = "serde", serde(rename = "VrfctnNtty"))]
    pub vrfctn_ntty: AuthenticationEntity2Code,

    #[yaserde(rename = "Rslt")]
    #[cfg_attr(feature = "serde", serde(rename = "Rslt"))]
    pub rslt: Verification1Code,

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

    #[yaserde(rename = "AuthntcnTkn")]
    #[cfg_attr(feature = "serde", serde(rename = "AuthntcnTkn"))]
    pub authntcn_tkn: Max140Binary,
}

impl Validate for TransactionVerificationResult5 {}


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

impl Validate for Upicidentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.016.001.01")]
pub struct Utmcoordinates1 {
    #[yaserde(rename = "UTMZone")]
    #[cfg_attr(feature = "serde", serde(rename = "UTMZone"))]
    pub utm_zone: Max16Text,

    #[yaserde(rename = "UTMEstwrd")]
    #[cfg_attr(feature = "serde", serde(rename = "UTMEstwrd"))]
    pub utm_estwrd: Number,

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

impl Validate for Utmcoordinates1 {}


#[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:catp.016.001.01")]

pub enum UserInterface5Code {
    #[yaserde(rename = "CDSP")]
    #[cfg_attr(feature = "serde", serde(rename = "CDSP"))]
    Cdsp,
    #[yaserde(rename = "CRCP")]
    #[cfg_attr(feature = "serde", serde(rename = "CRCP"))]
    Crcp,
    #[yaserde(rename = "CRDO")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDO"))]
    Crdo,
    __Unknown__(String),
}

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

impl Validate for UserInterface5Code {}



#[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:catp.016.001.01")]

pub enum Verification1Code {
    #[yaserde(rename = "FAIL")]
    #[cfg_attr(feature = "serde", serde(rename = "FAIL"))]
    Fail,
    #[yaserde(rename = "MISS")]
    #[cfg_attr(feature = "serde", serde(rename = "MISS"))]
    Miss,
    #[yaserde(rename = "NOVF")]
    #[cfg_attr(feature = "serde", serde(rename = "NOVF"))]
    Novf,
    #[yaserde(rename = "PART")]
    #[cfg_attr(feature = "serde", serde(rename = "PART"))]
    Part,
    #[yaserde(rename = "SUCC")]
    #[cfg_attr(feature = "serde", serde(rename = "SUCC"))]
    Succ,
    #[yaserde(rename = "ERRR")]
    #[cfg_attr(feature = "serde", serde(rename = "ERRR"))]
    Errr,
    __Unknown__(String),
}

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

impl Validate for Verification1Code {}

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