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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.017.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.017.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.017.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.017.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.017.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.017.001.01")]
pub struct Atmcontext19 {
    #[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: Atmservice23,
}

impl Validate for Atmcontext19 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.017.001.01")]
pub struct Atmcustomer5 {
    #[yaserde(rename = "Prfl")]
    #[cfg_attr(feature = "serde", serde(rename = "Prfl"))]
    pub prfl: AtmcustomerProfile2,

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

impl Validate for Atmcustomer5 {}


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


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

pub enum Atmdevice1Code {
    #[yaserde(rename = "CDIS")]
    #[cfg_attr(feature = "serde", serde(rename = "CDIS"))]
    Cdis,
    #[yaserde(rename = "DPRN")]
    #[cfg_attr(feature = "serde", serde(rename = "DPRN"))]
    Dprn,
    #[yaserde(rename = "JRNL")]
    #[cfg_attr(feature = "serde", serde(rename = "JRNL"))]
    Jrnl,
    #[yaserde(rename = "JPRN")]
    #[cfg_attr(feature = "serde", serde(rename = "JPRN"))]
    Jprn,
    #[yaserde(rename = "RPRN")]
    #[cfg_attr(feature = "serde", serde(rename = "RPRN"))]
    Rprn,
    #[yaserde(rename = "RWDR")]
    #[cfg_attr(feature = "serde", serde(rename = "RWDR"))]
    Rwdr,
    __Unknown__(String),
}

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

impl Validate for Atmdevice1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.017.001.01")]
pub struct Atmenvironment12 {
    #[yaserde(rename = "Acqrr")]
    #[cfg_attr(feature = "serde", serde(rename = "Acqrr"))]
    pub acqrr: Acquirer7,

    #[yaserde(rename = "ATMMgr")]
    #[cfg_attr(feature = "serde", serde(rename = "ATMMgr"))]
    pub atm_mgr: Acquirer8,

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

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

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

impl Validate for Atmenvironment12 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.017.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.017.001.01")]
pub struct Atmservice23 {
    #[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: AtmserviceType9Code,

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

impl Validate for Atmservice23 {}


#[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.017.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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.017.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.017.001.01")]
pub struct Atmtransaction24 {
    #[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 = "TrfIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "TrfIdr"))]
    pub trf_idr: Max70Text,

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

    #[yaserde(rename = "TxRspn")]
    #[cfg_attr(feature = "serde", serde(rename = "TxRspn"))]
    pub tx_rspn: ResponseType7,

    #[yaserde(rename = "Actn")]
    #[cfg_attr(feature = "serde", serde(rename = "Actn"))]
    pub actn: Vec<Action7>,

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

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

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

    #[yaserde(rename = "TtlAuthrsdAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlAuthrsdAmt"))]
    pub ttl_authrsd_amt: AmountAndCurrency1,

    #[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 = "AddtlChrg")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlChrg"))]
    pub addtl_chrg: Vec<DetailedAmount18>,

    #[yaserde(rename = "Lmts")]
    #[cfg_attr(feature = "serde", serde(rename = "Lmts"))]
    pub lmts: AtmtransactionAmounts6,

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

    #[yaserde(rename = "PropsdExctnDt")]
    #[cfg_attr(feature = "serde", serde(rename = "PropsdExctnDt"))]
    pub propsd_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 = "AuthstnRslt")]
    #[cfg_attr(feature = "serde", serde(rename = "AuthstnRslt"))]
    pub authstn_rslt: AuthorisationResult13,

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


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.017.001.01")]
pub struct AtmtransactionAmounts6 {
    #[yaserde(rename = "Ccy")]
    #[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
    pub ccy: ActiveCurrencyCode,

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

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

    #[yaserde(rename = "AddtlAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlAmt"))]
    pub addtl_amt: Vec<AtmtransactionAmounts7>,
}

impl Validate for AtmtransactionAmounts6 {}


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

    #[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 = "Labl")]
    #[cfg_attr(feature = "serde", serde(rename = "Labl"))]
    pub labl: Max70Text,
}

impl Validate for AtmtransactionAmounts7 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.017.001.01")]
pub struct AtmtransferResponse1 {
    #[yaserde(rename = "Envt")]
    #[cfg_attr(feature = "serde", serde(rename = "Envt"))]
    pub envt: Atmenvironment12,

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

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

impl Validate for AtmtransferResponse1 {}


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

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

    #[yaserde(rename = "ATMTrfRspn")]
    #[cfg_attr(feature = "serde", serde(rename = "ATMTrfRspn"))]
    pub atm_trf_rspn: AtmtransferResponse1,

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

impl Validate for AtmtransferResponseV01 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.017.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.017.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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.017.001.01")]
pub struct Acquirer8 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

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

impl Validate for Acquirer8 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.017.001.01")]
pub struct Action7 {
    #[yaserde(rename = "ActnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ActnTp"))]
    pub actn_tp: ActionType6Code,

    #[yaserde(rename = "MsgToPres")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgToPres"))]
    pub msg_to_pres: ActionMessage4,

    #[yaserde(rename = "ReqToPrfrm")]
    #[cfg_attr(feature = "serde", serde(rename = "ReqToPrfrm"))]
    pub req_to_prfrm: MessageFunction11Code,
}

impl Validate for Action7 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.017.001.01")]
pub struct ActionMessage4 {
    #[yaserde(rename = "Frmt")]
    #[cfg_attr(feature = "serde", serde(rename = "Frmt"))]
    pub frmt: OutputFormat2Code,

    #[yaserde(rename = "Msg")]
    #[cfg_attr(feature = "serde", serde(rename = "Msg"))]
    pub msg: Max20000Text,

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

    #[yaserde(rename = "Dvc")]
    #[cfg_attr(feature = "serde", serde(rename = "Dvc"))]
    pub dvc: Atmdevice1Code,

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

impl Validate for ActionMessage4 {}


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

pub enum ActionType6Code {
    #[yaserde(rename = "DCCQ")]
    #[cfg_attr(feature = "serde", serde(rename = "DCCQ"))]
    Dccq,
    #[yaserde(rename = "FEES")]
    #[cfg_attr(feature = "serde", serde(rename = "FEES"))]
    Fees,
    #[yaserde(rename = "HAMT")]
    #[cfg_attr(feature = "serde", serde(rename = "HAMT"))]
    Hamt,
    #[yaserde(rename = "LAMT")]
    #[cfg_attr(feature = "serde", serde(rename = "LAMT"))]
    Lamt,
    #[yaserde(rename = "BUSY")]
    #[cfg_attr(feature = "serde", serde(rename = "BUSY"))]
    Busy,
    #[yaserde(rename = "CPTR")]
    #[cfg_attr(feature = "serde", serde(rename = "CPTR"))]
    Cptr,
    #[yaserde(rename = "DISP")]
    #[cfg_attr(feature = "serde", serde(rename = "DISP"))]
    Disp,
    #[yaserde(rename = "CPNS")]
    #[cfg_attr(feature = "serde", serde(rename = "CPNS"))]
    Cpns,
    #[yaserde(rename = "RQST")]
    #[cfg_attr(feature = "serde", serde(rename = "RQST"))]
    Rqst,
    #[yaserde(rename = "PINL")]
    #[cfg_attr(feature = "serde", serde(rename = "PINL"))]
    Pinl,
    #[yaserde(rename = "PINR")]
    #[cfg_attr(feature = "serde", serde(rename = "PINR"))]
    Pinr,
    #[yaserde(rename = "TRCK")]
    #[cfg_attr(feature = "serde", serde(rename = "TRCK"))]
    Trck,
    __Unknown__(String),
}

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

impl Validate for ActionType6Code {}



#[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.017.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.017.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.017.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.017.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.017.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.017.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.017.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.017.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.017.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.017.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.017.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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.017.001.01")]
pub struct AmountAndCurrency1 {
    #[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,
}

impl Validate for AmountAndCurrency1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.017.001.01")]
pub struct AmountAndDirection43 {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: CurrencyAndAmount,

    #[yaserde(rename = "Sgn")]
    #[cfg_attr(feature = "serde", serde(rename = "Sgn"))]
    pub sgn: PlusOrMinusIndicator,

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

impl Validate for AmountAndDirection43 {}


#[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.017.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.017.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.017.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.017.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.017.001.01")]
pub struct AuthorisationResult13 {
    #[yaserde(rename = "AuthstnNtty")]
    #[cfg_attr(feature = "serde", serde(rename = "AuthstnNtty"))]
    pub authstn_ntty: PartyType16Code,

    #[yaserde(rename = "AuthstnRspn")]
    #[cfg_attr(feature = "serde", serde(rename = "AuthstnRspn"))]
    pub authstn_rspn: ResponseType7,

    #[yaserde(rename = "RspnTrac")]
    #[cfg_attr(feature = "serde", serde(rename = "RspnTrac"))]
    pub rspn_trac: Vec<ResponseType8>,

    #[yaserde(rename = "AuthstnCd")]
    #[cfg_attr(feature = "serde", serde(rename = "AuthstnCd"))]
    pub authstn_cd: Min6Max8Text,

    #[yaserde(rename = "Actn")]
    #[cfg_attr(feature = "serde", serde(rename = "Actn"))]
    pub actn: Vec<Action7>,
}

impl Validate for AuthorisationResult13 {}


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

impl Validate for AutomatedTellerMachine2 {}


#[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.017.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.017.001.01")]
pub struct CardAccount13 {
    #[yaserde(rename = "AcctTp")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctTp"))]
    pub acct_tp: CardAccountType3Code,

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

    #[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 = "CdtRef")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtRef"))]
    pub cdt_ref: Max35Text,

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

    #[yaserde(rename = "BalBfr")]
    #[cfg_attr(feature = "serde", serde(rename = "BalBfr"))]
    pub bal_bfr: AmountAndDirection43,

    #[yaserde(rename = "BalAftr")]
    #[cfg_attr(feature = "serde", serde(rename = "BalAftr"))]
    pub bal_aftr: AmountAndDirection43,
}

impl Validate for CardAccount13 {}


#[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.017.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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.017.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.017.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.017.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.017.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(Default, Clone, PartialEq, Debug)]
pub struct CurrencyAndAmountSimpleType (pub String);
crate::simple_type!(CurrencyAndAmountSimpleType);

impl Validate for CurrencyAndAmountSimpleType {
    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.017.001.01")]
pub struct CurrencyAndAmount {
    #[yaserde(text)]
    pub value: String,
    #[yaserde(attribute, rename = "Ccy")]
    #[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
    pub ccy: CurrencyCode,
}

impl Validate for CurrencyAndAmount {}


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

impl Validate for CurrencyCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.017.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.017.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.017.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.017.001.01")]
pub struct Document {
    #[yaserde(rename = "ATMTrfRspn")]
    #[cfg_attr(feature = "serde", serde(rename = "ATMTrfRspn"))]
    pub atm_trf_rspn: AtmtransferResponseV01,
}

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.017.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.017.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.017.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.017.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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.017.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.017.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.017.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.017.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.017.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.017.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.017.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.017.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.017.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.017.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 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 Max20000Text (pub String);
crate::simple_type!(Max20000Text);

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

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

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

pub enum OutputFormat2Code {
    #[yaserde(rename = "MREF")]
    #[cfg_attr(feature = "serde", serde(rename = "MREF"))]
    Mref,
    #[yaserde(rename = "SREF")]
    #[cfg_attr(feature = "serde", serde(rename = "SREF"))]
    Sref,
    #[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 OutputFormat2Code {
    fn default() -> OutputFormat2Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for OutputFormat2Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.017.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.017.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.017.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.017.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.017.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.017.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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.017.001.01")]

pub enum PartyType16Code {
    #[yaserde(rename = "ACQR")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
    Acqr,
    #[yaserde(rename = "CISS")]
    #[cfg_attr(feature = "serde", serde(rename = "CISS"))]
    Ciss,
    #[yaserde(rename = "DLIS")]
    #[cfg_attr(feature = "serde", serde(rename = "DLIS"))]
    Dlis,
    #[yaserde(rename = "ITAG")]
    #[cfg_attr(feature = "serde", serde(rename = "ITAG"))]
    Itag,
    #[yaserde(rename = "OTRM")]
    #[cfg_attr(feature = "serde", serde(rename = "OTRM"))]
    Otrm,
    #[yaserde(rename = "BKAF")]
    #[cfg_attr(feature = "serde", serde(rename = "BKAF"))]
    Bkaf,
    #[yaserde(rename = "BKAT")]
    #[cfg_attr(feature = "serde", serde(rename = "BKAT"))]
    Bkat,
    #[yaserde(rename = "ATMG")]
    #[cfg_attr(feature = "serde", serde(rename = "ATMG"))]
    Atmg,
    __Unknown__(String),
}

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

impl Validate for PartyType16Code {}



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

impl Validate for PlainCardData19 {}


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

impl Validate for PlusOrMinusIndicator {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.017.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.017.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.017.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.017.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.017.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.017.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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.017.001.01")]
pub struct ResponseType7 {
    #[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 = "AddtlRspnInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlRspnInf"))]
    pub addtl_rspn_inf: Max140Text,
}

impl Validate for ResponseType7 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.017.001.01")]
pub struct ResponseType8 {
    #[yaserde(rename = "RspndrId")]
    #[cfg_attr(feature = "serde", serde(rename = "RspndrId"))]
    pub rspndr_id: Max35Text,

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

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

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

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

impl Validate for ResponseType8 {}


#[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.017.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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.017.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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catp.017.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.017.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.017.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.017.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.017.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.017.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.017.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.017.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 = "017";
    const VARIANT: &'static str = "001";
    const VERSION: &'static str = "01";
    const MESSAGE_NAME: &'static str = "catp.017.001.01";
    const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:catp.017.001.01";
}