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:caam.009.001.02")]
pub struct Atmcassette2 {
    #[yaserde(rename = "PhysId")]
    #[cfg_attr(feature = "serde", serde(rename = "PhysId"))]
    pub phys_id: Max35Text,

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

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

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

    #[yaserde(rename = "SubTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SubTp"))]
    pub sub_tp: Vec<AtmnoteType1Code>,

    #[yaserde(rename = "MdiaTp")]
    #[cfg_attr(feature = "serde", serde(rename = "MdiaTp"))]
    pub mdia_tp: AtmmediaType1Code,

    #[yaserde(rename = "MdiaCntrs")]
    #[cfg_attr(feature = "serde", serde(rename = "MdiaCntrs"))]
    pub mdia_cntrs: Vec<AtmcassetteCounters3>,
}

impl Validate for Atmcassette2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caam.009.001.02")]
pub struct AtmcassetteCounters3 {
    #[yaserde(rename = "UnitVal")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitVal"))]
    pub unit_val: ImpliedCurrencyAndAmount,

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

    #[yaserde(rename = "MdiaCtgy")]
    #[cfg_attr(feature = "serde", serde(rename = "MdiaCtgy"))]
    pub mdia_ctgy: AtmmediaType3Code,

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

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

    #[yaserde(rename = "FlowTtls")]
    #[cfg_attr(feature = "serde", serde(rename = "FlowTtls"))]
    pub flow_ttls: Vec<AtmcassetteCounters4>,
}

impl Validate for AtmcassetteCounters3 {}


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

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

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

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

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

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

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

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

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

impl Validate for AtmcassetteCounters4 {}


#[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:caam.009.001.02")]

pub enum AtmcassetteType1Code {
    #[yaserde(rename = "DPST")]
    #[cfg_attr(feature = "serde", serde(rename = "DPST"))]
    Dpst,
    #[yaserde(rename = "DISP")]
    #[cfg_attr(feature = "serde", serde(rename = "DISP"))]
    Disp,
    #[yaserde(rename = "RCYC")]
    #[cfg_attr(feature = "serde", serde(rename = "RCYC"))]
    Rcyc,
    #[yaserde(rename = "RJCT")]
    #[cfg_attr(feature = "serde", serde(rename = "RJCT"))]
    Rjct,
    #[yaserde(rename = "RPLT")]
    #[cfg_attr(feature = "serde", serde(rename = "RPLT"))]
    Rplt,
    #[yaserde(rename = "RTRC")]
    #[cfg_attr(feature = "serde", serde(rename = "RTRC"))]
    Rtrc,
    __Unknown__(String),
}

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

impl Validate for AtmcassetteType1Code {}



#[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:caam.009.001.02")]

pub enum Atmcommand5Code {
    #[yaserde(rename = "ABAL")]
    #[cfg_attr(feature = "serde", serde(rename = "ABAL"))]
    Abal,
    #[yaserde(rename = "CCNT")]
    #[cfg_attr(feature = "serde", serde(rename = "CCNT"))]
    Ccnt,
    #[yaserde(rename = "RPTC")]
    #[cfg_attr(feature = "serde", serde(rename = "RPTC"))]
    Rptc,
    __Unknown__(String),
}

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

impl Validate for Atmcommand5Code {}



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

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

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

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

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

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

impl Validate for Atmcommand8 {}


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

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

impl Validate for Atmcommand9 {}


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

pub enum AtmcounterType1Code {
    #[yaserde(rename = "INQU")]
    #[cfg_attr(feature = "serde", serde(rename = "INQU"))]
    Inqu,
    #[yaserde(rename = "CTXN")]
    #[cfg_attr(feature = "serde", serde(rename = "CTXN"))]
    Ctxn,
    #[yaserde(rename = "CTOF")]
    #[cfg_attr(feature = "serde", serde(rename = "CTOF"))]
    Ctof,
    #[yaserde(rename = "BDAY")]
    #[cfg_attr(feature = "serde", serde(rename = "BDAY"))]
    Bday,
    #[yaserde(rename = "PRTN")]
    #[cfg_attr(feature = "serde", serde(rename = "PRTN"))]
    Prtn,
    #[yaserde(rename = "OPER")]
    #[cfg_attr(feature = "serde", serde(rename = "OPER"))]
    Oper,
    __Unknown__(String),
}

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

impl Validate for AtmcounterType1Code {}



#[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:caam.009.001.02")]

pub enum AtmcounterType2Code {
    #[yaserde(rename = "BDAY")]
    #[cfg_attr(feature = "serde", serde(rename = "BDAY"))]
    Bday,
    #[yaserde(rename = "INQU")]
    #[cfg_attr(feature = "serde", serde(rename = "INQU"))]
    Inqu,
    #[yaserde(rename = "CTOF")]
    #[cfg_attr(feature = "serde", serde(rename = "CTOF"))]
    Ctof,
    #[yaserde(rename = "OPER")]
    #[cfg_attr(feature = "serde", serde(rename = "OPER"))]
    Oper,
    __Unknown__(String),
}

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

impl Validate for AtmcounterType2Code {}



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

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

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

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

impl Validate for Atmenvironment10 {}


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

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

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

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

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

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

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

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

impl Validate for Atmequipment1 {}


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

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

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

impl Validate for AtmmediaType1Code {}



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

pub enum AtmmediaType3Code {
    #[yaserde(rename = "CNTR")]
    #[cfg_attr(feature = "serde", serde(rename = "CNTR"))]
    Cntr,
    #[yaserde(rename = "FITN")]
    #[cfg_attr(feature = "serde", serde(rename = "FITN"))]
    Fitn,
    #[yaserde(rename = "FITU")]
    #[cfg_attr(feature = "serde", serde(rename = "FITU"))]
    Fitu,
    #[yaserde(rename = "SPCT")]
    #[cfg_attr(feature = "serde", serde(rename = "SPCT"))]
    Spct,
    #[yaserde(rename = "UNFT")]
    #[cfg_attr(feature = "serde", serde(rename = "UNFT"))]
    Unft,
    #[yaserde(rename = "UNRG")]
    #[cfg_attr(feature = "serde", serde(rename = "UNRG"))]
    Unrg,
    __Unknown__(String),
}

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

impl Validate for AtmmediaType3Code {}



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

pub enum AtmnoteType1Code {
    #[yaserde(rename = "ALLT")]
    #[cfg_attr(feature = "serde", serde(rename = "ALLT"))]
    Allt,
    #[yaserde(rename = "CNTR")]
    #[cfg_attr(feature = "serde", serde(rename = "CNTR"))]
    Cntr,
    #[yaserde(rename = "IDVD")]
    #[cfg_attr(feature = "serde", serde(rename = "IDVD"))]
    Idvd,
    #[yaserde(rename = "SCNT")]
    #[cfg_attr(feature = "serde", serde(rename = "SCNT"))]
    Scnt,
    #[yaserde(rename = "UNFT")]
    #[cfg_attr(feature = "serde", serde(rename = "UNFT"))]
    Unft,
    __Unknown__(String),
}

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

impl Validate for AtmnoteType1Code {}



#[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:caam.009.001.02")]

pub enum Atmoperation1Code {
    #[yaserde(rename = "ADJU")]
    #[cfg_attr(feature = "serde", serde(rename = "ADJU"))]
    Adju,
    #[yaserde(rename = "INSR")]
    #[cfg_attr(feature = "serde", serde(rename = "INSR"))]
    Insr,
    #[yaserde(rename = "LOAD")]
    #[cfg_attr(feature = "serde", serde(rename = "LOAD"))]
    Load,
    #[yaserde(rename = "REMV")]
    #[cfg_attr(feature = "serde", serde(rename = "REMV"))]
    Remv,
    #[yaserde(rename = "UNLD")]
    #[cfg_attr(feature = "serde", serde(rename = "UNLD"))]
    Unld,
    __Unknown__(String),
}

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

impl Validate for Atmoperation1Code {}



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

    #[yaserde(rename = "CmdRslt")]
    #[cfg_attr(feature = "serde", serde(rename = "CmdRslt"))]
    pub cmd_rslt: Vec<Atmcommand8>,

    #[yaserde(rename = "CmdCntxt")]
    #[cfg_attr(feature = "serde", serde(rename = "CmdCntxt"))]
    pub cmd_cntxt: Atmcommand9,

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

impl Validate for AtmreconciliationAdvice2 {}


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

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

    #[yaserde(rename = "ATMRcncltnAdvc")]
    #[cfg_attr(feature = "serde", serde(rename = "ATMRcncltnAdvc"))]
    pub atm_rcncltn_advc: AtmreconciliationAdvice2,

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

impl Validate for AtmreconciliationAdviceV02 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caam.009.001.02")]
pub struct Atmtotals1 {
    #[yaserde(rename = "MdiaTp")]
    #[cfg_attr(feature = "serde", serde(rename = "MdiaTp"))]
    pub mdia_tp: AtmmediaType1Code,

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

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

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

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

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

impl Validate for Atmtotals1 {}


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

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

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

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

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

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

impl Validate for Atmtotals3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caam.009.001.02")]
pub struct Atmtransaction25 {
    #[yaserde(rename = "TpOfOpr")]
    #[cfg_attr(feature = "serde", serde(rename = "TpOfOpr"))]
    pub tp_of_opr: Atmoperation1Code,

    #[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 = "ATMTtls")]
    #[cfg_attr(feature = "serde", serde(rename = "ATMTtls"))]
    pub atm_ttls: Vec<Atmtotals1>,

    #[yaserde(rename = "Csstt")]
    #[cfg_attr(feature = "serde", serde(rename = "Csstt"))]
    pub csstt: Vec<Atmcassette2>,

    #[yaserde(rename = "TxTtls")]
    #[cfg_attr(feature = "serde", serde(rename = "TxTtls"))]
    pub tx_ttls: Vec<Atmtotals3>,

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

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

impl Validate for Atmtransaction25 {}


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

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

impl Validate for Acquirer7 {}


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

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

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:caam.009.001.02")]

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:caam.009.001.02")]

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:caam.009.001.02")]

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:caam.009.001.02")]

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:caam.009.001.02")]

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:caam.009.001.02")]
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:caam.009.001.02")]
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:caam.009.001.02")]
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:caam.009.001.02")]
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:caam.009.001.02")]
pub struct AlgorithmIdentification15 {
    #[yaserde(rename = "Algo")]
    #[cfg_attr(feature = "serde", serde(rename = "Algo"))]
    pub algo: Algorithm12Code,

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

impl Validate for AlgorithmIdentification15 {}


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

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:caam.009.001.02")]
pub struct AuthenticatedData4 {
    #[yaserde(rename = "Vrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Vrsn"))]
    pub vrsn: Number,

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

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

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

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

impl Validate for AuthenticatedData4 {}


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

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

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

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

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

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

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

impl Validate for AutomatedTellerMachine8 {}


#[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:caam.009.001.02")]

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:caam.009.001.02")]
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:caam.009.001.02")]
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:caam.009.001.02")]
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:caam.009.001.02")]

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

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

impl Validate for ContentType2Code {}



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

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

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:caam.009.001.02")]
pub struct Document {
    #[yaserde(rename = "ATMRcncltnAdvc")]
    #[cfg_attr(feature = "serde", serde(rename = "ATMRcncltnAdvc"))]
    pub atm_rcncltn_advc: AtmreconciliationAdviceV02,
}

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:caam.009.001.02")]
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:caam.009.001.02")]
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:caam.009.001.02")]

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:caam.009.001.02")]
pub struct EnvelopedData4 {
    #[yaserde(rename = "Vrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Vrsn"))]
    pub vrsn: Number,

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

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

impl Validate for EnvelopedData4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caam.009.001.02")]
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:caam.009.001.02")]
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:caam.009.001.02")]
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:caam.009.001.02")]
pub struct Header32 {
    #[yaserde(rename = "MsgFctn")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgFctn"))]
    pub msg_fctn: AtmmessageFunction2,

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

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

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

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

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

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

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

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

impl Validate for Header32 {}


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Validate for MessageFunction11Code {}



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

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

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

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

impl Validate for Number {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caam.009.001.02")]
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:caam.009.001.02")]
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:caam.009.001.02")]
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:caam.009.001.02")]
pub struct Parameter7 {
    #[yaserde(rename = "InitlstnVctr")]
    #[cfg_attr(feature = "serde", serde(rename = "InitlstnVctr"))]
    pub initlstn_vctr: Max500Binary,

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

impl Validate for Parameter7 {}


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

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

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

impl Validate for PartyType12Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caam.009.001.02")]
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:caam.009.001.02")]
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:caam.009.001.02")]
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:caam.009.001.02")]
pub struct RelativeDistinguishedName1 {
    #[yaserde(rename = "AttrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "AttrTp"))]
    pub attr_tp: AttributeType1Code,

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

impl Validate for RelativeDistinguishedName1 {}


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

pub enum TerminalManagementActionResult2Code {
    #[yaserde(rename = "CNTE")]
    #[cfg_attr(feature = "serde", serde(rename = "CNTE"))]
    Cnte,
    #[yaserde(rename = "FMTE")]
    #[cfg_attr(feature = "serde", serde(rename = "FMTE"))]
    Fmte,
    #[yaserde(rename = "HRDW")]
    #[cfg_attr(feature = "serde", serde(rename = "HRDW"))]
    Hrdw,
    #[yaserde(rename = "NSUP")]
    #[cfg_attr(feature = "serde", serde(rename = "NSUP"))]
    Nsup,
    #[yaserde(rename = "SECR")]
    #[cfg_attr(feature = "serde", serde(rename = "SECR"))]
    Secr,
    #[yaserde(rename = "SUCC")]
    #[cfg_attr(feature = "serde", serde(rename = "SUCC"))]
    Succ,
    #[yaserde(rename = "SYNE")]
    #[cfg_attr(feature = "serde", serde(rename = "SYNE"))]
    Syne,
    #[yaserde(rename = "TIMO")]
    #[cfg_attr(feature = "serde", serde(rename = "TIMO"))]
    Timo,
    #[yaserde(rename = "UKRF")]
    #[cfg_attr(feature = "serde", serde(rename = "UKRF"))]
    Ukrf,
    __Unknown__(String),
}

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

impl Validate for TerminalManagementActionResult2Code {}



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

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

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

impl Validate for TransactionEnvironment2Code {}



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

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:caam.009.001.02")]
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:caam.009.001.02")]
pub struct Utmcoordinates1 {
    #[yaserde(rename = "UTMZone")]
    #[cfg_attr(feature = "serde", serde(rename = "UTMZone"))]
    pub utm_zone: Max16Text,

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

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

impl Validate for Utmcoordinates1 {}

impl crate::MxMessage for Document {
    const BUSINESS_AREA: crate::BusinessArea = crate::BusinessArea::caam;
    const FUNCTIONALITY: &'static str = "009";
    const VARIANT: &'static str = "001";
    const VERSION: &'static str = "02";
    const MESSAGE_NAME: &'static str = "caam.009.001.02";
    const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:caam.009.001.02";
}