rust_iso20022 0.1.1

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

pub enum Atmcommand4Code {
    #[yaserde(rename = "ABAL")]
    #[cfg_attr(feature = "serde", serde(rename = "ABAL"))]
    Abal,
    #[yaserde(rename = "ASTS")]
    #[cfg_attr(feature = "serde", serde(rename = "ASTS"))]
    Asts,
    #[yaserde(rename = "CFGT")]
    #[cfg_attr(feature = "serde", serde(rename = "CFGT"))]
    Cfgt,
    #[yaserde(rename = "CCNT")]
    #[cfg_attr(feature = "serde", serde(rename = "CCNT"))]
    Ccnt,
    #[yaserde(rename = "DISC")]
    #[cfg_attr(feature = "serde", serde(rename = "DISC"))]
    Disc,
    #[yaserde(rename = "SNDM")]
    #[cfg_attr(feature = "serde", serde(rename = "SNDM"))]
    Sndm,
    #[yaserde(rename = "RPTC")]
    #[cfg_attr(feature = "serde", serde(rename = "RPTC"))]
    Rptc,
    __Unknown__(String),
}

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

impl Validate for Atmcommand4Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.015.001.01")]
pub struct Atmcommand7 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: Atmcommand4Code,

    #[yaserde(rename = "Urgcy")]
    #[cfg_attr(feature = "serde", serde(rename = "Urgcy"))]
    pub urgcy: TmscontactLevel2Code,

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

    #[yaserde(rename = "CmdId")]
    #[cfg_attr(feature = "serde", serde(rename = "CmdId"))]
    pub cmd_id: AtmcommandIdentification1,

    #[yaserde(rename = "CmdParams")]
    #[cfg_attr(feature = "serde", serde(rename = "CmdParams"))]
    pub cmd_params: AtmcommandParameters1Choice,
}

impl Validate for Atmcommand7 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.015.001.01")]
pub struct AtmcommandIdentification1 {
    #[yaserde(rename = "Orgn")]
    #[cfg_attr(feature = "serde", serde(rename = "Orgn"))]
    pub orgn: Max35Text,

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

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

impl Validate for AtmcommandIdentification1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.015.001.01")]
pub struct AtmcommandParameters1Choice {
    #[yaserde(rename = "ATMReqrdGblSts")]
    #[cfg_attr(feature = "serde", serde(rename = "ATMReqrdGblSts"))]
    pub atmreqrd_gbl_sts: Option<Atmstatus1Code>,
    #[yaserde(rename = "XpctdMsgFctn")]
    #[cfg_attr(feature = "serde", serde(rename = "XpctdMsgFctn"))]
    pub xpctd_msg_fctn: Option<MessageFunction8Code>,
    #[yaserde(rename = "ReqrdCfgtnParam")]
    #[cfg_attr(feature = "serde", serde(rename = "ReqrdCfgtnParam"))]
    pub reqrd_cfgtn_param: Option<AtmconfigurationParameter1>,
}

impl Validate for AtmcommandParameters1Choice {}




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

impl Validate for Atmcontext12 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.015.001.01")]
pub struct AtmdepositCompletionAcknowledgement1 {
    #[yaserde(rename = "ATM")]
    #[cfg_attr(feature = "serde", serde(rename = "ATM"))]
    pub atm: AutomatedTellerMachine3,

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

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

impl Validate for AtmdepositCompletionAcknowledgement1 {}


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

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

    #[yaserde(rename = "ATMDpstCmpltnAck")]
    #[cfg_attr(feature = "serde", serde(rename = "ATMDpstCmpltnAck"))]
    pub atm_dpst_cmpltn_ack: AtmdepositCompletionAcknowledgement1,

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

impl Validate for AtmdepositCompletionAcknowledgementV01 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.015.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.015.001.01")]
pub struct Atmservice13 {
    #[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 = "HstSvcCd")]
    #[cfg_attr(feature = "serde", serde(rename = "HstSvcCd"))]
    pub hst_svc_cd: Max35Text,

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

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

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

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

    #[yaserde(rename = "PrtlDpst")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtlDpst"))]
    pub prtl_dpst: TrueFalseIndicator,
}

impl Validate for Atmservice13 {}


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

pub enum AtmserviceType6Code {
    #[yaserde(rename = "MCHG")]
    #[cfg_attr(feature = "serde", serde(rename = "MCHG"))]
    Mchg,
    #[yaserde(rename = "DPSN")]
    #[cfg_attr(feature = "serde", serde(rename = "DPSN"))]
    Dpsn,
    #[yaserde(rename = "DPSV")]
    #[cfg_attr(feature = "serde", serde(rename = "DPSV"))]
    Dpsv,
    __Unknown__(String),
}

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

impl Validate for AtmserviceType6Code {}



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

pub enum Atmstatus1Code {
    #[yaserde(rename = "INSV")]
    #[cfg_attr(feature = "serde", serde(rename = "INSV"))]
    Insv,
    #[yaserde(rename = "OUTS")]
    #[cfg_attr(feature = "serde", serde(rename = "OUTS"))]
    Outs,
    __Unknown__(String),
}

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

impl Validate for Atmstatus1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.015.001.01")]
pub struct Atmtransaction18 {
    #[yaserde(rename = "TxId")]
    #[cfg_attr(feature = "serde", serde(rename = "TxId"))]
    pub tx_id: TransactionIdentifier1,

    #[yaserde(rename = "Rspn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rspn"))]
    pub rspn: Response4Code,

    #[yaserde(rename = "RspnRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "RspnRsn"))]
    pub rspn_rsn: ResultDetail4Code,

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

    #[yaserde(rename = "Cmd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cmd"))]
    pub cmd: Vec<Atmcommand7>,
}

impl Validate for Atmtransaction18 {}


#[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.015.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.015.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.015.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.015.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.015.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.015.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.015.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.015.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.015.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.015.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.015.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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.015.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.015.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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.015.001.01")]
pub struct AutomatedTellerMachine3 {
    #[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 = "Lctn")]
    #[cfg_attr(feature = "serde", serde(rename = "Lctn"))]
    pub lctn: PostalAddress17,
}

impl Validate for AutomatedTellerMachine3 {}


#[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.015.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.015.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.015.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.015.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.015.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.015.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.015.001.01")]
pub struct Document {
    #[yaserde(rename = "ATMDpstCmpltnAck")]
    #[cfg_attr(feature = "serde", serde(rename = "ATMDpstCmpltnAck"))]
    pub atm_dpst_cmpltn_ack: AtmdepositCompletionAcknowledgementV01,
}

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.015.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.015.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.015.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.015.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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.015.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.015.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.015.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.015.001.01")]
pub struct Header32 {
    #[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 = "ReTrnsmssnCntr")]
    #[cfg_attr(feature = "serde", serde(rename = "ReTrnsmssnCntr"))]
    pub re_trnsmssn_cntr: Number,

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


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

pub enum MessageFunction8Code {
    #[yaserde(rename = "BALN")]
    #[cfg_attr(feature = "serde", serde(rename = "BALN"))]
    Baln,
    #[yaserde(rename = "GSTS")]
    #[cfg_attr(feature = "serde", serde(rename = "GSTS"))]
    Gsts,
    #[yaserde(rename = "DSEC")]
    #[cfg_attr(feature = "serde", serde(rename = "DSEC"))]
    Dsec,
    #[yaserde(rename = "INQC")]
    #[cfg_attr(feature = "serde", serde(rename = "INQC"))]
    Inqc,
    #[yaserde(rename = "KEYQ")]
    #[cfg_attr(feature = "serde", serde(rename = "KEYQ"))]
    Keyq,
    #[yaserde(rename = "SSTS")]
    #[cfg_attr(feature = "serde", serde(rename = "SSTS"))]
    Ssts,
    __Unknown__(String),
}

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

impl Validate for MessageFunction8Code {}



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

pub enum Response4Code {
    #[yaserde(rename = "APPR")]
    #[cfg_attr(feature = "serde", serde(rename = "APPR"))]
    Appr,
    #[yaserde(rename = "DECL")]
    #[cfg_attr(feature = "serde", serde(rename = "DECL"))]
    Decl,
    #[yaserde(rename = "PART")]
    #[cfg_attr(feature = "serde", serde(rename = "PART"))]
    Part,
    __Unknown__(String),
}

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

impl Validate for Response4Code {}



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

pub enum ResultDetail4Code {
    #[yaserde(rename = "ACTF")]
    #[cfg_attr(feature = "serde", serde(rename = "ACTF"))]
    Actf,
    #[yaserde(rename = "ACQS")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQS"))]
    Acqs,
    #[yaserde(rename = "AMLV")]
    #[cfg_attr(feature = "serde", serde(rename = "AMLV"))]
    Amlv,
    #[yaserde(rename = "AMTA")]
    #[cfg_attr(feature = "serde", serde(rename = "AMTA"))]
    Amta,
    #[yaserde(rename = "AUTH")]
    #[cfg_attr(feature = "serde", serde(rename = "AUTH"))]
    Auth,
    #[yaserde(rename = "BANK")]
    #[cfg_attr(feature = "serde", serde(rename = "BANK"))]
    Bank,
    #[yaserde(rename = "CRDR")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDR"))]
    Crdr,
    #[yaserde(rename = "CRDF")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDF"))]
    Crdf,
    #[yaserde(rename = "ACTC")]
    #[cfg_attr(feature = "serde", serde(rename = "ACTC"))]
    Actc,
    #[yaserde(rename = "CTVG")]
    #[cfg_attr(feature = "serde", serde(rename = "CTVG"))]
    Ctvg,
    #[yaserde(rename = "DBER")]
    #[cfg_attr(feature = "serde", serde(rename = "DBER"))]
    Dber,
    #[yaserde(rename = "FEES")]
    #[cfg_attr(feature = "serde", serde(rename = "FEES"))]
    Fees,
    #[yaserde(rename = "TXNL")]
    #[cfg_attr(feature = "serde", serde(rename = "TXNL"))]
    Txnl,
    #[yaserde(rename = "AMTD")]
    #[cfg_attr(feature = "serde", serde(rename = "AMTD"))]
    Amtd,
    #[yaserde(rename = "NMBD")]
    #[cfg_attr(feature = "serde", serde(rename = "NMBD"))]
    Nmbd,
    #[yaserde(rename = "CRDX")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDX"))]
    Crdx,
    #[yaserde(rename = "FDCL")]
    #[cfg_attr(feature = "serde", serde(rename = "FDCL"))]
    Fdcl,
    #[yaserde(rename = "FMTR")]
    #[cfg_attr(feature = "serde", serde(rename = "FMTR"))]
    Fmtr,
    #[yaserde(rename = "TXNG")]
    #[cfg_attr(feature = "serde", serde(rename = "TXNG"))]
    Txng,
    #[yaserde(rename = "FNDI")]
    #[cfg_attr(feature = "serde", serde(rename = "FNDI"))]
    Fndi,
    #[yaserde(rename = "ACPI")]
    #[cfg_attr(feature = "serde", serde(rename = "ACPI"))]
    Acpi,
    #[yaserde(rename = "AMTI")]
    #[cfg_attr(feature = "serde", serde(rename = "AMTI"))]
    Amti,
    #[yaserde(rename = "ADDI")]
    #[cfg_attr(feature = "serde", serde(rename = "ADDI"))]
    Addi,
    #[yaserde(rename = "BRHI")]
    #[cfg_attr(feature = "serde", serde(rename = "BRHI"))]
    Brhi,
    #[yaserde(rename = "CHDI")]
    #[cfg_attr(feature = "serde", serde(rename = "CHDI"))]
    Chdi,
    #[yaserde(rename = "CRDI")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDI"))]
    Crdi,
    #[yaserde(rename = "CTFV")]
    #[cfg_attr(feature = "serde", serde(rename = "CTFV"))]
    Ctfv,
    #[yaserde(rename = "AMTO")]
    #[cfg_attr(feature = "serde", serde(rename = "AMTO"))]
    Amto,
    #[yaserde(rename = "PINV")]
    #[cfg_attr(feature = "serde", serde(rename = "PINV"))]
    Pinv,
    #[yaserde(rename = "TKKO")]
    #[cfg_attr(feature = "serde", serde(rename = "TKKO"))]
    Tkko,
    #[yaserde(rename = "SGNI")]
    #[cfg_attr(feature = "serde", serde(rename = "SGNI"))]
    Sgni,
    #[yaserde(rename = "TKID")]
    #[cfg_attr(feature = "serde", serde(rename = "TKID"))]
    Tkid,
    #[yaserde(rename = "TXNV")]
    #[cfg_attr(feature = "serde", serde(rename = "TXNV"))]
    Txnv,
    #[yaserde(rename = "DATI")]
    #[cfg_attr(feature = "serde", serde(rename = "DATI"))]
    Dati,
    #[yaserde(rename = "ISSP")]
    #[cfg_attr(feature = "serde", serde(rename = "ISSP"))]
    Issp,
    #[yaserde(rename = "ISSF")]
    #[cfg_attr(feature = "serde", serde(rename = "ISSF"))]
    Issf,
    #[yaserde(rename = "ISSO")]
    #[cfg_attr(feature = "serde", serde(rename = "ISSO"))]
    Isso,
    #[yaserde(rename = "ISST")]
    #[cfg_attr(feature = "serde", serde(rename = "ISST"))]
    Isst,
    #[yaserde(rename = "ISSU")]
    #[cfg_attr(feature = "serde", serde(rename = "ISSU"))]
    Issu,
    #[yaserde(rename = "KEYS")]
    #[cfg_attr(feature = "serde", serde(rename = "KEYS"))]
    Keys,
    #[yaserde(rename = "LBLA")]
    #[cfg_attr(feature = "serde", serde(rename = "LBLA"))]
    Lbla,
    #[yaserde(rename = "CRDL")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDL"))]
    Crdl,
    #[yaserde(rename = "MACR")]
    #[cfg_attr(feature = "serde", serde(rename = "MACR"))]
    Macr,
    #[yaserde(rename = "MACK")]
    #[cfg_attr(feature = "serde", serde(rename = "MACK"))]
    Mack,
    #[yaserde(rename = "ICCM")]
    #[cfg_attr(feature = "serde", serde(rename = "ICCM"))]
    Iccm,
    #[yaserde(rename = "PINN")]
    #[cfg_attr(feature = "serde", serde(rename = "PINN"))]
    Pinn,
    #[yaserde(rename = "CRDA")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDA"))]
    Crda,
    #[yaserde(rename = "LBLU")]
    #[cfg_attr(feature = "serde", serde(rename = "LBLU"))]
    Lblu,
    #[yaserde(rename = "PINA")]
    #[cfg_attr(feature = "serde", serde(rename = "PINA"))]
    Pina,
    #[yaserde(rename = "NPRA")]
    #[cfg_attr(feature = "serde", serde(rename = "NPRA"))]
    Npra,
    #[yaserde(rename = "OFFL")]
    #[cfg_attr(feature = "serde", serde(rename = "OFFL"))]
    Offl,
    #[yaserde(rename = "ONLP")]
    #[cfg_attr(feature = "serde", serde(rename = "ONLP"))]
    Onlp,
    #[yaserde(rename = "NPRC")]
    #[cfg_attr(feature = "serde", serde(rename = "NPRC"))]
    Nprc,
    #[yaserde(rename = "TXNM")]
    #[cfg_attr(feature = "serde", serde(rename = "TXNM"))]
    Txnm,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "BALO")]
    #[cfg_attr(feature = "serde", serde(rename = "BALO"))]
    Balo,
    #[yaserde(rename = "SEQO")]
    #[cfg_attr(feature = "serde", serde(rename = "SEQO"))]
    Seqo,
    #[yaserde(rename = "PINC")]
    #[cfg_attr(feature = "serde", serde(rename = "PINC"))]
    Pinc,
    #[yaserde(rename = "PIND")]
    #[cfg_attr(feature = "serde", serde(rename = "PIND"))]
    Pind,
    #[yaserde(rename = "PINS")]
    #[cfg_attr(feature = "serde", serde(rename = "PINS"))]
    Pins,
    #[yaserde(rename = "PINX")]
    #[cfg_attr(feature = "serde", serde(rename = "PINX"))]
    Pinx,
    #[yaserde(rename = "PINE")]
    #[cfg_attr(feature = "serde", serde(rename = "PINE"))]
    Pine,
    #[yaserde(rename = "QMAX")]
    #[cfg_attr(feature = "serde", serde(rename = "QMAX"))]
    Qmax,
    #[yaserde(rename = "RECD")]
    #[cfg_attr(feature = "serde", serde(rename = "RECD"))]
    Recd,
    #[yaserde(rename = "CRDT")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDT"))]
    Crdt,
    #[yaserde(rename = "SECV")]
    #[cfg_attr(feature = "serde", serde(rename = "SECV"))]
    Secv,
    #[yaserde(rename = "SRVU")]
    #[cfg_attr(feature = "serde", serde(rename = "SRVU"))]
    Srvu,
    #[yaserde(rename = "SFWE")]
    #[cfg_attr(feature = "serde", serde(rename = "SFWE"))]
    Sfwe,
    #[yaserde(rename = "SPCC")]
    #[cfg_attr(feature = "serde", serde(rename = "SPCC"))]
    Spcc,
    #[yaserde(rename = "CRDS")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDS"))]
    Crds,
    #[yaserde(rename = "SRCH")]
    #[cfg_attr(feature = "serde", serde(rename = "SRCH"))]
    Srch,
    #[yaserde(rename = "CNTC")]
    #[cfg_attr(feature = "serde", serde(rename = "CNTC"))]
    Cntc,
    #[yaserde(rename = "FRDS")]
    #[cfg_attr(feature = "serde", serde(rename = "FRDS"))]
    Frds,
    #[yaserde(rename = "SYSP")]
    #[cfg_attr(feature = "serde", serde(rename = "SYSP"))]
    Sysp,
    #[yaserde(rename = "SYSM")]
    #[cfg_attr(feature = "serde", serde(rename = "SYSM"))]
    Sysm,
    #[yaserde(rename = "TRMI")]
    #[cfg_attr(feature = "serde", serde(rename = "TRMI"))]
    Trmi,
    #[yaserde(rename = "ACTT")]
    #[cfg_attr(feature = "serde", serde(rename = "ACTT"))]
    Actt,
    #[yaserde(rename = "TTLV")]
    #[cfg_attr(feature = "serde", serde(rename = "TTLV"))]
    Ttlv,
    #[yaserde(rename = "TXNU")]
    #[cfg_attr(feature = "serde", serde(rename = "TXNU"))]
    Txnu,
    #[yaserde(rename = "TXND")]
    #[cfg_attr(feature = "serde", serde(rename = "TXND"))]
    Txnd,
    #[yaserde(rename = "ORGF")]
    #[cfg_attr(feature = "serde", serde(rename = "ORGF"))]
    Orgf,
    #[yaserde(rename = "UNBO")]
    #[cfg_attr(feature = "serde", serde(rename = "UNBO"))]
    Unbo,
    #[yaserde(rename = "UNBP")]
    #[cfg_attr(feature = "serde", serde(rename = "UNBP"))]
    Unbp,
    #[yaserde(rename = "UNBC")]
    #[cfg_attr(feature = "serde", serde(rename = "UNBC"))]
    Unbc,
    #[yaserde(rename = "CMKY")]
    #[cfg_attr(feature = "serde", serde(rename = "CMKY"))]
    Cmky,
    #[yaserde(rename = "CRDU")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDU"))]
    Crdu,
    #[yaserde(rename = "SVSU")]
    #[cfg_attr(feature = "serde", serde(rename = "SVSU"))]
    Svsu,
    #[yaserde(rename = "VNDR")]
    #[cfg_attr(feature = "serde", serde(rename = "VNDR"))]
    Vndr,
    #[yaserde(rename = "VNDF")]
    #[cfg_attr(feature = "serde", serde(rename = "VNDF"))]
    Vndf,
    #[yaserde(rename = "AMTW")]
    #[cfg_attr(feature = "serde", serde(rename = "AMTW"))]
    Amtw,
    #[yaserde(rename = "NMBW")]
    #[cfg_attr(feature = "serde", serde(rename = "NMBW"))]
    Nmbw,
    #[yaserde(rename = "CRDW")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDW"))]
    Crdw,
    #[yaserde(rename = "MEDI")]
    #[cfg_attr(feature = "serde", serde(rename = "MEDI"))]
    Medi,
    #[yaserde(rename = "SRVI")]
    #[cfg_attr(feature = "serde", serde(rename = "SRVI"))]
    Srvi,
    __Unknown__(String),
}

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

impl Validate for ResultDetail4Code {}



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

pub enum TmscontactLevel2Code {
    #[yaserde(rename = "ASAP")]
    #[cfg_attr(feature = "serde", serde(rename = "ASAP"))]
    Asap,
    #[yaserde(rename = "CRIT")]
    #[cfg_attr(feature = "serde", serde(rename = "CRIT"))]
    Crit,
    #[yaserde(rename = "DTIM")]
    #[cfg_attr(feature = "serde", serde(rename = "DTIM"))]
    Dtim,
    #[yaserde(rename = "ENCS")]
    #[cfg_attr(feature = "serde", serde(rename = "ENCS"))]
    Encs,
    __Unknown__(String),
}

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

impl Validate for TmscontactLevel2Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.015.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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.015.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)]
pub struct TrueFalseIndicator (pub bool);
crate::simple_type!(TrueFalseIndicator);

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

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