rust_iso20022 0.1.1

// @generated by src/bin/codegen.rs from the ISO 20022 XSD schema. Do not edit.
#![allow(clippy::all)]
#![allow(non_snake_case, non_camel_case_types, dead_code, unused_imports)]
// yaserde_derive 0.7 emits trait impls inside nested choice submodules, which
// trips the `non_local_definitions` lint on recent rustc. The generated code is
// correct; silence the lint here.
#![allow(non_local_definitions)]
use std::str::FromStr;
use crate::validate::Validate;
use yaserde_derive::{YaDeserialize, YaSerialize};

// pub type Document = Document;
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:canm.002.001.05")]
pub struct AticalaxProcessing {}

impl Validate for AticalaxProcessing {}


#[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:canm.002.001.05")]

pub enum AticapartyType1Code {
    #[yaserde(rename = "ACCP")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCP"))]
    Accp,
    #[yaserde(rename = "ACQR")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
    Acqr,
    #[yaserde(rename = "ICCA")]
    #[cfg_attr(feature = "serde", serde(rename = "ICCA"))]
    Icca,
    #[yaserde(rename = "CISS")]
    #[cfg_attr(feature = "serde", serde(rename = "CISS"))]
    Ciss,
    #[yaserde(rename = "DLIS")]
    #[cfg_attr(feature = "serde", serde(rename = "DLIS"))]
    Dlis,
    #[yaserde(rename = "AGNT")]
    #[cfg_attr(feature = "serde", serde(rename = "AGNT"))]
    Agnt,
    #[yaserde(rename = "ACQP")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQP"))]
    Acqp,
    #[yaserde(rename = "CISP")]
    #[cfg_attr(feature = "serde", serde(rename = "CISP"))]
    Cisp,
    #[yaserde(rename = "WLPR")]
    #[cfg_attr(feature = "serde", serde(rename = "WLPR"))]
    Wlpr,
    #[yaserde(rename = "PASP")]
    #[cfg_attr(feature = "serde", serde(rename = "PASP"))]
    Pasp,
    __Unknown__(String),
}

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

impl Validate for AticapartyType1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:canm.002.001.05")]
pub struct AdditionalFee4 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: Iso8583FeeTypeCode,

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

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

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

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

    #[yaserde(rename = "CdtDbt")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtDbt"))]
    pub cdt_dbt: CreditDebit3Code,

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

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

    #[yaserde(rename = "RcncltnCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "RcncltnCcy"))]
    pub rcncltn_ccy: Iso3NumericCurrencyCode,

    #[yaserde(rename = "RcncltnFctvXchgRate")]
    #[cfg_attr(feature = "serde", serde(rename = "RcncltnFctvXchgRate"))]
    pub rcncltn_fctv_xchg_rate: BaseOne25Rate,

    #[yaserde(rename = "Assgnr")]
    #[cfg_attr(feature = "serde", serde(rename = "Assgnr"))]
    pub assgnr: AticapartyType1Code,

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

impl Validate for AdditionalFee4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:canm.002.001.05")]
pub struct Address4 {
    #[yaserde(rename = "Line1")]
    #[cfg_attr(feature = "serde", serde(rename = "Line1"))]
    pub line_1: Max99Text,

    #[yaserde(rename = "Line2")]
    #[cfg_attr(feature = "serde", serde(rename = "Line2"))]
    pub line_2: Max99Text,

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

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

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

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

    #[yaserde(rename = "CtrySubDvsnMnr")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrySubDvsnMnr"))]
    pub ctry_sub_dvsn_mnr: IsocountrySubDivisionCode,

    #[yaserde(rename = "CtrySubDvsnMjr")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrySubDvsnMjr"))]
    pub ctry_sub_dvsn_mjr: IsocountrySubDivisionCode,

    #[yaserde(rename = "CtrySubDvsnMjrNm")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrySubDvsnMjrNm"))]
    pub ctry_sub_dvsn_mjr_nm: Max50Text,

    #[yaserde(rename = "CtrySubDvsnMnrNm")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrySubDvsnMnrNm"))]
    pub ctry_sub_dvsn_mnr_nm: Max50Text,

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

    #[yaserde(rename = "GeogcLctn")]
    #[cfg_attr(feature = "serde", serde(rename = "GeogcLctn"))]
    pub geogc_lctn: GeographicPointInDecimalDegreesText,
}

impl Validate for Address4 {}


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

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

impl Validate for BaseOneRate {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:canm.002.001.05")]
pub struct ContentInformationType41 {
    #[yaserde(rename = "MACData")]
    #[cfg_attr(feature = "serde", serde(rename = "MACData"))]
    pub mac_data: Macdata1,

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

impl Validate for ContentInformationType41 {}


#[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:canm.002.001.05")]

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

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

impl Validate for CreditDebit3Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:canm.002.001.05")]
pub struct Document {
    #[yaserde(rename = "NtwkMgmtRspn")]
    #[cfg_attr(feature = "serde", serde(rename = "NtwkMgmtRspn"))]
    pub ntwk_mgmt_rspn: NetworkManagementResponseV05,
}

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:canm.002.001.05")]
pub struct ErrorDetails4 {
    #[yaserde(rename = "ErrCd")]
    #[cfg_attr(feature = "serde", serde(rename = "ErrCd"))]
    pub err_cd: Iso8583MessageErrorCode,

    #[yaserde(rename = "svrtyCd")]
    #[cfg_attr(feature = "serde", serde(rename = "svrtyCd"))]
    pub svrty_cd: Max2NumericText,

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

    #[yaserde(rename = "DataElmtInErr")]
    #[cfg_attr(feature = "serde", serde(rename = "DataElmtInErr"))]
    pub data_elmt_in_err: Vec<Max4000Text>,
}

impl Validate for ErrorDetails4 {}


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

impl Validate for Exact12Text {
    fn validate(&self) -> Result<(), String> { 
        if self.0.len() != 12 {
            return Err(format!("Length validation error. \nExpected: 0 length == 12 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

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

impl Validate for Exact15Text {
    fn validate(&self) -> Result<(), String> { 
        if self.0.len() != 15 {
            return Err(format!("Length validation error. \nExpected: 0 length == 15 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

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

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

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

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

impl Validate for GeographicPointInDecimalDegreesText {
    fn validate(&self) -> Result<(), String> { 
        if self.0.len() > 27 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 27 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

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

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

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

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

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

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

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

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

    #[yaserde(rename = "MsgChcksmInptVal")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgChcksmInptVal"))]
    pub msg_chcksm_inpt_val: Max140Binary,

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

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

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

impl Validate for Header72 {}


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

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

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

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

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

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

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

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

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

impl Validate for IsocountrySubDivisionCode {}
#[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 Isomax3ACountryCode (pub String);
crate::simple_type!(Isomax3ACountryCode);

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

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

impl Validate for Isotime {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
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:canm.002.001.05")]
pub struct Jurisdiction2 {
    #[yaserde(rename = "DmstInd")]
    #[cfg_attr(feature = "serde", serde(rename = "DmstInd"))]
    pub dmst_ind: TrueFalseIndicator,

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

impl Validate for Jurisdiction2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:canm.002.001.05")]
pub struct LocalAddress2 {
    #[yaserde(rename = "Line1")]
    #[cfg_attr(feature = "serde", serde(rename = "Line1"))]
    pub line_1: Max200Text,

    #[yaserde(rename = "Line2")]
    #[cfg_attr(feature = "serde", serde(rename = "Line2"))]
    pub line_2: Max200Text,

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

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

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

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

    #[yaserde(rename = "CtrySubDvsnMnrNm")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrySubDvsnMnrNm"))]
    pub ctry_sub_dvsn_mnr_nm: Max100Text,

    #[yaserde(rename = "CtrySubDvsnMjrNm")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrySubDvsnMjrNm"))]
    pub ctry_sub_dvsn_mjr_nm: Max100Text,
}

impl Validate for LocalAddress2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:canm.002.001.05")]
pub struct LocalData20 {
    #[yaserde(rename = "Lang")]
    #[cfg_attr(feature = "serde", serde(rename = "Lang"))]
    pub lang: Isomax3ALanguageCode,

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

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

    #[yaserde(rename = "LglCorpNm")]
    #[cfg_attr(feature = "serde", serde(rename = "LglCorpNm"))]
    pub lgl_corp_nm: Max210Text,

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

    #[yaserde(rename = "PrvtData")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvtData"))]
    pub prvt_data: Vec<AticalaxProcessing>,

    #[yaserde(rename = "NtlData")]
    #[cfg_attr(feature = "serde", serde(rename = "NtlData"))]
    pub ntl_data: Vec<AticalaxProcessing>,
}

impl Validate for LocalData20 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:canm.002.001.05")]
pub struct Macdata1 {
    #[yaserde(rename = "Ctrl")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctrl"))]
    pub ctrl: Exact1HexBinaryText,

    #[yaserde(rename = "KeySetIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "KeySetIdr"))]
    pub key_set_idr: Max8NumericText,

    #[yaserde(rename = "DrvdInf")]
    #[cfg_attr(feature = "serde", serde(rename = "DrvdInf"))]
    pub drvd_inf: Max32HexBinaryText,

    #[yaserde(rename = "Algo")]
    #[cfg_attr(feature = "serde", serde(rename = "Algo"))]
    pub algo: Max2NumericText,

    #[yaserde(rename = "KeyLngth")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyLngth"))]
    pub key_lngth: Max4NumericText,

    #[yaserde(rename = "KeyPrtcn")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyPrtcn"))]
    pub key_prtcn: Max2NumericText,

    #[yaserde(rename = "KeyIndx")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyIndx"))]
    pub key_indx: Max5NumericText,

    #[yaserde(rename = "PddgMtd")]
    #[cfg_attr(feature = "serde", serde(rename = "PddgMtd"))]
    pub pddg_mtd: Max2NumericText,

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

impl Validate for Macdata1 {}


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

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

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

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

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

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

impl Validate for Max12NumericText {}
#[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 Max15AlphaNumericText (pub String);
crate::simple_type!(Max15AlphaNumericText);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Validate for Max4NumericText {}
#[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 Max50Text (pub String);
crate::simple_type!(Max50Text);

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

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

impl Validate for Max5NumericText {}
#[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 Max8HexBinaryText (pub String);
crate::simple_type!(Max8HexBinaryText);

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

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

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

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

    #[yaserde(rename = "NtwkMgmtTp")]
    #[cfg_attr(feature = "serde", serde(rename = "NtwkMgmtTp"))]
    pub ntwk_mgmt_tp: Iso8583NetworkManagementInformationCode,

    #[yaserde(rename = "Sndr")]
    #[cfg_attr(feature = "serde", serde(rename = "Sndr"))]
    pub sndr: SenderData1,

    #[yaserde(rename = "MsgRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgRsn"))]
    pub msg_rsn: Vec<Iso8583MessageReasonCode>,

    #[yaserde(rename = "AltrnMsgRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "AltrnMsgRsn"))]
    pub altrn_msg_rsn: Vec<Max256Text>,

    #[yaserde(rename = "Prgrmm")]
    #[cfg_attr(feature = "serde", serde(rename = "Prgrmm"))]
    pub prgrmm: ProgrammeMode6,

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

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

    #[yaserde(rename = "SysTracAudtNb")]
    #[cfg_attr(feature = "serde", serde(rename = "SysTracAudtNb"))]
    pub sys_trac_audt_nb: Max12NumericText,

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

    #[yaserde(rename = "RtrvlRefNb")]
    #[cfg_attr(feature = "serde", serde(rename = "RtrvlRefNb"))]
    pub rtrvl_ref_nb: Exact12Text,

    #[yaserde(rename = "LifeCyclId")]
    #[cfg_attr(feature = "serde", serde(rename = "LifeCyclId"))]
    pub life_cycl_id: Exact15Text,

    #[yaserde(rename = "Jursdctn")]
    #[cfg_attr(feature = "serde", serde(rename = "Jursdctn"))]
    pub jursdctn: Jurisdiction2,

    #[yaserde(rename = "SttlmSvc")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmSvc"))]
    pub sttlm_svc: SettlementService7,

    #[yaserde(rename = "AddtlFee")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlFee"))]
    pub addtl_fee: Vec<AdditionalFee4>,

    #[yaserde(rename = "Rcncltn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rcncltn"))]
    pub rcncltn: Reconciliation5,

    #[yaserde(rename = "TxDesc")]
    #[cfg_attr(feature = "serde", serde(rename = "TxDesc"))]
    pub tx_desc: Max1000Text,

    #[yaserde(rename = "PrcgRslt")]
    #[cfg_attr(feature = "serde", serde(rename = "PrcgRslt"))]
    pub prcg_rslt: ProcessingResult30,

    #[yaserde(rename = "OrgnlRspnCd")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlRspnCd"))]
    pub orgnl_rspn_cd: Iso8583ResponseCode,

    #[yaserde(rename = "PrvtData")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvtData"))]
    pub prvt_data: Vec<AticalaxProcessing>,

    #[yaserde(rename = "NtlData")]
    #[cfg_attr(feature = "serde", serde(rename = "NtlData"))]
    pub ntl_data: Vec<AticalaxProcessing>,

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

impl Validate for NetworkManagementResponseV05 {}


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

impl Validate for Number {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:canm.002.001.05")]
pub struct ProcessingResult30 {
    #[yaserde(rename = "RspnSrcId")]
    #[cfg_attr(feature = "serde", serde(rename = "RspnSrcId"))]
    pub rspn_src_id: Max35Text,

    #[yaserde(rename = "RspnSrcTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RspnSrcTp"))]
    pub rspn_src_tp: AticapartyType1Code,

    #[yaserde(rename = "RspnSrcCtry")]
    #[cfg_attr(feature = "serde", serde(rename = "RspnSrcCtry"))]
    pub rspn_src_ctry: Isomax3ACountryCode,

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

    #[yaserde(rename = "RspnCd")]
    #[cfg_attr(feature = "serde", serde(rename = "RspnCd"))]
    pub rspn_cd: Iso8583ResponseCode,

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

    #[yaserde(rename = "ActnCd")]
    #[cfg_attr(feature = "serde", serde(rename = "ActnCd"))]
    pub actn_cd: Iso8583ActionCode,

    #[yaserde(rename = "ErrDtl")]
    #[cfg_attr(feature = "serde", serde(rename = "ErrDtl"))]
    pub err_dtl: Vec<ErrorDetails4>,

    #[yaserde(rename = "PrvtData")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvtData"))]
    pub prvt_data: Vec<AticalaxProcessing>,

    #[yaserde(rename = "NtlData")]
    #[cfg_attr(feature = "serde", serde(rename = "NtlData"))]
    pub ntl_data: Vec<AticalaxProcessing>,
}

impl Validate for ProcessingResult30 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:canm.002.001.05")]
pub struct ProgrammeMode6 {
    #[yaserde(rename = "PropsdId")]
    #[cfg_attr(feature = "serde", serde(rename = "PropsdId"))]
    pub propsd_id: Vec<Max35Text>,

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

    #[yaserde(rename = "PrvtData")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvtData"))]
    pub prvt_data: Vec<AticalaxProcessing>,

    #[yaserde(rename = "NtlData")]
    #[cfg_attr(feature = "serde", serde(rename = "NtlData"))]
    pub ntl_data: Vec<AticalaxProcessing>,
}

impl Validate for ProgrammeMode6 {}


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

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

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

impl Validate for Reconciliation5 {}


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

    #[yaserde(rename = "BizId")]
    #[cfg_attr(feature = "serde", serde(rename = "BizId"))]
    pub biz_id: Max15AlphaNumericText,

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

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

    #[yaserde(rename = "LglCorpNm")]
    #[cfg_attr(feature = "serde", serde(rename = "LglCorpNm"))]
    pub lgl_corp_nm: Max99Text,

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

    #[yaserde(rename = "PrvtData")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvtData"))]
    pub prvt_data: Vec<AticalaxProcessing>,

    #[yaserde(rename = "NtlData")]
    #[cfg_attr(feature = "serde", serde(rename = "NtlData"))]
    pub ntl_data: Vec<AticalaxProcessing>,

    #[yaserde(rename = "LclData")]
    #[cfg_attr(feature = "serde", serde(rename = "LclData"))]
    pub lcl_data: Vec<LocalData20>,
}

impl Validate for SenderData1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:canm.002.001.05")]
pub struct SettlementService7 {
    #[yaserde(rename = "PropsdTp")]
    #[cfg_attr(feature = "serde", serde(rename = "PropsdTp"))]
    pub propsd_tp: Max35Text,

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

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

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

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

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

    #[yaserde(rename = "Tm")]
    #[cfg_attr(feature = "serde", serde(rename = "Tm"))]
    pub tm: Isotime,

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

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

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

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

    #[yaserde(rename = "PrvtData")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvtData"))]
    pub prvt_data: Vec<AticalaxProcessing>,

    #[yaserde(rename = "NtlData")]
    #[cfg_attr(feature = "serde", serde(rename = "NtlData"))]
    pub ntl_data: Vec<AticalaxProcessing>,
}

impl Validate for SettlementService7 {}


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

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