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:catm.005.001.12")]
pub struct AcceptorConfigurationContent15 {
    #[yaserde(rename = "RplcCfgtn")]
    #[cfg_attr(feature = "serde", serde(rename = "RplcCfgtn"))]
    pub rplc_cfgtn: TrueFalseIndicator,

    #[yaserde(rename = "TMSPrtcolParams")]
    #[cfg_attr(feature = "serde", serde(rename = "TMSPrtcolParams"))]
    pub tms_prtcol_params: Vec<TmsprotocolParameters8>,

    #[yaserde(rename = "AcqrrPrtcolParams")]
    #[cfg_attr(feature = "serde", serde(rename = "AcqrrPrtcolParams"))]
    pub acqrr_prtcol_params: Vec<AcquirerProtocolParameters18>,

    #[yaserde(rename = "SvcPrvdrParams")]
    #[cfg_attr(feature = "serde", serde(rename = "SvcPrvdrParams"))]
    pub svc_prvdr_params: Vec<ServiceProviderParameters5>,

    #[yaserde(rename = "MrchntParams")]
    #[cfg_attr(feature = "serde", serde(rename = "MrchntParams"))]
    pub mrchnt_params: Vec<MerchantConfigurationParameters6>,

    #[yaserde(rename = "TermnlParams")]
    #[cfg_attr(feature = "serde", serde(rename = "TermnlParams"))]
    pub termnl_params: Vec<PaymentTerminalParameters8>,

    #[yaserde(rename = "ApplParams")]
    #[cfg_attr(feature = "serde", serde(rename = "ApplParams"))]
    pub appl_params: Vec<ApplicationParameters13>,

    #[yaserde(rename = "HstComParams")]
    #[cfg_attr(feature = "serde", serde(rename = "HstComParams"))]
    pub hst_com_params: Vec<HostCommunicationParameter8>,

    #[yaserde(rename = "SctyParams")]
    #[cfg_attr(feature = "serde", serde(rename = "SctyParams"))]
    pub scty_params: Vec<SecurityParameters17>,

    #[yaserde(rename = "SaleToPOIParams")]
    #[cfg_attr(feature = "serde", serde(rename = "SaleToPOIParams"))]
    pub sale_to_poi_params: Vec<SaleToPOIProtocolParameter4>,

    #[yaserde(rename = "TermnlPackg")]
    #[cfg_attr(feature = "serde", serde(rename = "TermnlPackg"))]
    pub termnl_packg: Vec<TerminalPackageType5>,
}

impl Validate for AcceptorConfigurationContent15 {}


#[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:catm.005.001.12")]
pub struct AcceptorConfigurationDataSet7 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: DataSetIdentification11,

    #[yaserde(rename = "SeqCntr")]
    #[cfg_attr(feature = "serde", serde(rename = "SeqCntr"))]
    pub seq_cntr: Max9NumericText,

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

    #[yaserde(rename = "POIId")]
    #[cfg_attr(feature = "serde", serde(rename = "POIId"))]
    pub poi_id: Vec<GenericIdentification176>,

    #[yaserde(rename = "CfgtnScp")]
    #[cfg_attr(feature = "serde", serde(rename = "CfgtnScp"))]
    pub cfgtn_scp: PartyType15Code,

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

impl Validate for AcceptorConfigurationDataSet7 {}
#[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:catm.005.001.12")]
pub struct AccountIdentification4Choice {
    #[yaserde(rename = "IBAN")]
    #[cfg_attr(feature = "serde", serde(rename = "IBAN"))]
    pub iban: Option<Iban2007Identifier>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<GenericAccountIdentification1>,
}

impl Validate for AccountIdentification4Choice {}
#[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:catm.005.001.12")]
pub struct AccountSchemeName1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ExternalAccountIdentification1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max35Text>,
}

impl Validate for AccountSchemeName1Choice {}




#[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:catm.005.001.12")]
pub struct Acquirer10 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: GenericIdentification177,

    #[yaserde(rename = "ParamsVrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "ParamsVrsn"))]
    pub params_vrsn: Max256Text,
}

impl Validate for Acquirer10 {}


#[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:catm.005.001.12")]
pub struct AcquirerHostConfiguration11 {
    #[yaserde(rename = "HstId")]
    #[cfg_attr(feature = "serde", serde(rename = "HstId"))]
    pub hst_id: Max35Text,

    #[yaserde(rename = "MsgToSnd")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgToSnd"))]
    pub msg_to_snd: Vec<MessageFunction47Code>,

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

    #[yaserde(rename = "XtrnlyTpSpprtd")]
    #[cfg_attr(feature = "serde", serde(rename = "XtrnlyTpSpprtd"))]
    pub xtrnly_tp_spprtd: Vec<Max1025Text>,
}

impl Validate for AcquirerHostConfiguration11 {}


#[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:catm.005.001.12")]
pub struct AcquirerProtocolExchangeBehavior2 {
    #[yaserde(rename = "FinCaptr")]
    #[cfg_attr(feature = "serde", serde(rename = "FinCaptr"))]
    pub fin_captr: FinancialCapture1Code,

    #[yaserde(rename = "BtchTrf")]
    #[cfg_attr(feature = "serde", serde(rename = "BtchTrf"))]
    pub btch_trf: ExchangeConfiguration9,

    #[yaserde(rename = "CmpltnXchg")]
    #[cfg_attr(feature = "serde", serde(rename = "CmpltnXchg"))]
    pub cmpltn_xchg: ExchangeConfiguration10,

    #[yaserde(rename = "CxlXchg")]
    #[cfg_attr(feature = "serde", serde(rename = "CxlXchg"))]
    pub cxl_xchg: CancellationProcess2Code,
}

impl Validate for AcquirerProtocolExchangeBehavior2 {}


#[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:catm.005.001.12")]
pub struct AcquirerProtocolParameters18 {
    #[yaserde(rename = "ActnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ActnTp"))]
    pub actn_tp: TerminalManagementAction3Code,

    #[yaserde(rename = "AcqrrId")]
    #[cfg_attr(feature = "serde", serde(rename = "AcqrrId"))]
    pub acqrr_id: Vec<GenericIdentification176>,

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

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

    #[yaserde(rename = "Hst")]
    #[cfg_attr(feature = "serde", serde(rename = "Hst"))]
    pub hst: Vec<AcquirerHostConfiguration11>,

    #[yaserde(rename = "OnLineTx")]
    #[cfg_attr(feature = "serde", serde(rename = "OnLineTx"))]
    pub on_line_tx: AcquirerProtocolExchangeBehavior2,

    #[yaserde(rename = "OffLineTx")]
    #[cfg_attr(feature = "serde", serde(rename = "OffLineTx"))]
    pub off_line_tx: AcquirerProtocolExchangeBehavior2,

    #[yaserde(rename = "RcncltnXchg")]
    #[cfg_attr(feature = "serde", serde(rename = "RcncltnXchg"))]
    pub rcncltn_xchg: ExchangeConfiguration9,

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

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

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

    #[yaserde(rename = "SpltTtlCrit")]
    #[cfg_attr(feature = "serde", serde(rename = "SpltTtlCrit"))]
    pub splt_ttl_crit: Vec<ReconciliationCriteria1Code>,

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

    #[yaserde(rename = "AmtQlfrForRsvatn")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtQlfrForRsvatn"))]
    pub amt_qlfr_for_rsvatn: Vec<TypeOfAmount8Code>,

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

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

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

    #[yaserde(rename = "BtchTrfCntt")]
    #[cfg_attr(feature = "serde", serde(rename = "BtchTrfCntt"))]
    pub btch_trf_cntt: Vec<BatchTransactionType1Code>,

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

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

    #[yaserde(rename = "MsgItm")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgItm"))]
    pub msg_itm: Vec<MessageItemCondition2>,

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

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

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

impl Validate for AcquirerProtocolParameters18 {}


#[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:catm.005.001.12")]
pub struct ActionMessage12 {
    #[yaserde(rename = "MsgDstn")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgDstn"))]
    pub msg_dstn: UserInterface9Code,

    #[yaserde(rename = "InfQlfr")]
    #[cfg_attr(feature = "serde", serde(rename = "InfQlfr"))]
    pub inf_qlfr: InformationQualify1Code,

    #[yaserde(rename = "Frmt")]
    #[cfg_attr(feature = "serde", serde(rename = "Frmt"))]
    pub frmt: OutputFormat3Code,

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

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

    #[yaserde(rename = "OutptBrcd")]
    #[cfg_attr(feature = "serde", serde(rename = "OutptBrcd"))]
    pub outpt_brcd: OutputBarcode2,

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

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

impl Validate for ActionMessage12 {}


#[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(Default, Clone, PartialEq, Debug)]
pub struct ActiveOrHistoricCurrencyCode (pub String);
crate::simple_type!(ActiveOrHistoricCurrencyCode);

impl Validate for ActiveOrHistoricCurrencyCode {}
#[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:catm.005.001.12")]

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

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

impl Validate for AddressType2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.005.001.12")]
pub struct AddressType3Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<AddressType2Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification30>,
}

impl Validate for AddressType3Choice {}




#[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:catm.005.001.12")]
pub struct AddressVerification1 {
    #[yaserde(rename = "AdrDgts")]
    #[cfg_attr(feature = "serde", serde(rename = "AdrDgts"))]
    pub adr_dgts: Max5NumericText,

    #[yaserde(rename = "PstlCdDgts")]
    #[cfg_attr(feature = "serde", serde(rename = "PstlCdDgts"))]
    pub pstl_cd_dgts: Max5NumericText,
}

impl Validate for AddressVerification1 {}


#[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:catm.005.001.12")]

pub enum Algorithm26Code {
    #[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,
    #[yaserde(rename = "SH31")]
    #[cfg_attr(feature = "serde", serde(rename = "SH31"))]
    Sh31,
    #[yaserde(rename = "SH32")]
    #[cfg_attr(feature = "serde", serde(rename = "SH32"))]
    Sh32,
    #[yaserde(rename = "SH33")]
    #[cfg_attr(feature = "serde", serde(rename = "SH33"))]
    Sh33,
    #[yaserde(rename = "SH35")]
    #[cfg_attr(feature = "serde", serde(rename = "SH35"))]
    Sh35,
    #[yaserde(rename = "SHK1")]
    #[cfg_attr(feature = "serde", serde(rename = "SHK1"))]
    Shk1,
    #[yaserde(rename = "SHK2")]
    #[cfg_attr(feature = "serde", serde(rename = "SHK2"))]
    Shk2,
    #[yaserde(rename = "SMS3")]
    #[cfg_attr(feature = "serde", serde(rename = "SMS3"))]
    Sms3,
    __Unknown__(String),
}

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

impl Validate for Algorithm26Code {}



#[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:catm.005.001.12")]

pub enum Algorithm27Code {
    #[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,
    #[yaserde(rename = "CMA2")]
    #[cfg_attr(feature = "serde", serde(rename = "CMA2"))]
    Cma2,
    #[yaserde(rename = "CM31")]
    #[cfg_attr(feature = "serde", serde(rename = "CM31"))]
    Cm31,
    #[yaserde(rename = "CM32")]
    #[cfg_attr(feature = "serde", serde(rename = "CM32"))]
    Cm32,
    #[yaserde(rename = "CM33")]
    #[cfg_attr(feature = "serde", serde(rename = "CM33"))]
    Cm33,
    #[yaserde(rename = "MCS3")]
    #[cfg_attr(feature = "serde", serde(rename = "MCS3"))]
    Mcs3,
    #[yaserde(rename = "CCA1")]
    #[cfg_attr(feature = "serde", serde(rename = "CCA1"))]
    Cca1,
    #[yaserde(rename = "CCA2")]
    #[cfg_attr(feature = "serde", serde(rename = "CCA2"))]
    Cca2,
    #[yaserde(rename = "CCA3")]
    #[cfg_attr(feature = "serde", serde(rename = "CCA3"))]
    Cca3,
    S34C,
    S34R,
    __Unknown__(String),
}

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

impl Validate for Algorithm27Code {}



#[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:catm.005.001.12")]

pub enum Algorithm28Code {
    #[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 = "UKA2")]
    #[cfg_attr(feature = "serde", serde(rename = "UKA2"))]
    Uka2,
    #[yaserde(rename = "EA9C")]
    #[cfg_attr(feature = "serde", serde(rename = "EA9C"))]
    Ea9C,
    #[yaserde(rename = "EA5C")]
    #[cfg_attr(feature = "serde", serde(rename = "EA5C"))]
    Ea5C,
    #[yaserde(rename = "DA12")]
    #[cfg_attr(feature = "serde", serde(rename = "DA12"))]
    Da12,
    #[yaserde(rename = "DA19")]
    #[cfg_attr(feature = "serde", serde(rename = "DA19"))]
    Da19,
    #[yaserde(rename = "DA25")]
    #[cfg_attr(feature = "serde", serde(rename = "DA25"))]
    Da25,
    N108,
    #[yaserde(rename = "EA5R")]
    #[cfg_attr(feature = "serde", serde(rename = "EA5R"))]
    Ea5R,
    #[yaserde(rename = "EA9R")]
    #[cfg_attr(feature = "serde", serde(rename = "EA9R"))]
    Ea9R,
    #[yaserde(rename = "EA2R")]
    #[cfg_attr(feature = "serde", serde(rename = "EA2R"))]
    Ea2R,
    #[yaserde(rename = "E3DR")]
    #[cfg_attr(feature = "serde", serde(rename = "E3DR"))]
    E3Dr,
    E36C,
    E36R,
    #[yaserde(rename = "SD5C")]
    #[cfg_attr(feature = "serde", serde(rename = "SD5C"))]
    Sd5C,
    #[yaserde(rename = "UKA1")]
    #[cfg_attr(feature = "serde", serde(rename = "UKA1"))]
    Uka1,
    #[yaserde(rename = "UKA3")]
    #[cfg_attr(feature = "serde", serde(rename = "UKA3"))]
    Uka3,
    #[yaserde(rename = "SM4C")]
    #[cfg_attr(feature = "serde", serde(rename = "SM4C"))]
    Sm4C,
    #[yaserde(rename = "SM4R")]
    #[cfg_attr(feature = "serde", serde(rename = "SM4R"))]
    Sm4R,
    __Unknown__(String),
}

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

impl Validate for Algorithm28Code {}



#[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:catm.005.001.12")]

pub enum Algorithm29Code {
    #[yaserde(rename = "ERS2")]
    #[cfg_attr(feature = "serde", serde(rename = "ERS2"))]
    Ers2,
    #[yaserde(rename = "ERS1")]
    #[cfg_attr(feature = "serde", serde(rename = "ERS1"))]
    Ers1,
    #[yaserde(rename = "RPSS")]
    #[cfg_attr(feature = "serde", serde(rename = "RPSS"))]
    Rpss,
    #[yaserde(rename = "ERS3")]
    #[cfg_attr(feature = "serde", serde(rename = "ERS3"))]
    Ers3,
    #[yaserde(rename = "ED32")]
    #[cfg_attr(feature = "serde", serde(rename = "ED32"))]
    Ed32,
    #[yaserde(rename = "ED33")]
    #[cfg_attr(feature = "serde", serde(rename = "ED33"))]
    Ed33,
    #[yaserde(rename = "ED35")]
    #[cfg_attr(feature = "serde", serde(rename = "ED35"))]
    Ed35,
    #[yaserde(rename = "ED23")]
    #[cfg_attr(feature = "serde", serde(rename = "ED23"))]
    Ed23,
    #[yaserde(rename = "ED25")]
    #[cfg_attr(feature = "serde", serde(rename = "ED25"))]
    Ed25,
    #[yaserde(rename = "ES22")]
    #[cfg_attr(feature = "serde", serde(rename = "ES22"))]
    Es22,
    #[yaserde(rename = "ES32")]
    #[cfg_attr(feature = "serde", serde(rename = "ES32"))]
    Es32,
    #[yaserde(rename = "ES33")]
    #[cfg_attr(feature = "serde", serde(rename = "ES33"))]
    Es33,
    #[yaserde(rename = "ES35")]
    #[cfg_attr(feature = "serde", serde(rename = "ES35"))]
    Es35,
    #[yaserde(rename = "ES23")]
    #[cfg_attr(feature = "serde", serde(rename = "ES23"))]
    Es23,
    #[yaserde(rename = "ES25")]
    #[cfg_attr(feature = "serde", serde(rename = "ES25"))]
    Es25,
    #[yaserde(rename = "ED22")]
    #[cfg_attr(feature = "serde", serde(rename = "ED22"))]
    Ed22,
    #[yaserde(rename = "EF32")]
    #[cfg_attr(feature = "serde", serde(rename = "EF32"))]
    Ef32,
    #[yaserde(rename = "EF22")]
    #[cfg_attr(feature = "serde", serde(rename = "EF22"))]
    Ef22,
    #[yaserde(rename = "EF33")]
    #[cfg_attr(feature = "serde", serde(rename = "EF33"))]
    Ef33,
    #[yaserde(rename = "EF35")]
    #[cfg_attr(feature = "serde", serde(rename = "EF35"))]
    Ef35,
    #[yaserde(rename = "EF23")]
    #[cfg_attr(feature = "serde", serde(rename = "EF23"))]
    Ef23,
    #[yaserde(rename = "EO33")]
    #[cfg_attr(feature = "serde", serde(rename = "EO33"))]
    Eo33,
    #[yaserde(rename = "EF25")]
    #[cfg_attr(feature = "serde", serde(rename = "EF25"))]
    Ef25,
    #[yaserde(rename = "EO32")]
    #[cfg_attr(feature = "serde", serde(rename = "EO32"))]
    Eo32,
    #[yaserde(rename = "EO22")]
    #[cfg_attr(feature = "serde", serde(rename = "EO22"))]
    Eo22,
    #[yaserde(rename = "EO35")]
    #[cfg_attr(feature = "serde", serde(rename = "EO35"))]
    Eo35,
    #[yaserde(rename = "EO23")]
    #[cfg_attr(feature = "serde", serde(rename = "EO23"))]
    Eo23,
    #[yaserde(rename = "EO25")]
    #[cfg_attr(feature = "serde", serde(rename = "EO25"))]
    Eo25,
    #[yaserde(rename = "DD22")]
    #[cfg_attr(feature = "serde", serde(rename = "DD22"))]
    Dd22,
    #[yaserde(rename = "DD32")]
    #[cfg_attr(feature = "serde", serde(rename = "DD32"))]
    Dd32,
    #[yaserde(rename = "DD33")]
    #[cfg_attr(feature = "serde", serde(rename = "DD33"))]
    Dd33,
    #[yaserde(rename = "DD35")]
    #[cfg_attr(feature = "serde", serde(rename = "DD35"))]
    Dd35,
    #[yaserde(rename = "DD23")]
    #[cfg_attr(feature = "serde", serde(rename = "DD23"))]
    Dd23,
    #[yaserde(rename = "DD25")]
    #[cfg_attr(feature = "serde", serde(rename = "DD25"))]
    Dd25,
    #[yaserde(rename = "SM22")]
    #[cfg_attr(feature = "serde", serde(rename = "SM22"))]
    Sm22,
    #[yaserde(rename = "SM33")]
    #[cfg_attr(feature = "serde", serde(rename = "SM33"))]
    Sm33,
    #[yaserde(rename = "SM32")]
    #[cfg_attr(feature = "serde", serde(rename = "SM32"))]
    Sm32,
    #[yaserde(rename = "SM35")]
    #[cfg_attr(feature = "serde", serde(rename = "SM35"))]
    Sm35,
    #[yaserde(rename = "SM23")]
    #[cfg_attr(feature = "serde", serde(rename = "SM23"))]
    Sm23,
    #[yaserde(rename = "SM25")]
    #[cfg_attr(feature = "serde", serde(rename = "SM25"))]
    Sm25,
    S2S3,
    __Unknown__(String),
}

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

impl Validate for Algorithm29Code {}



#[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:catm.005.001.12")]

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:catm.005.001.12")]

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:catm.005.001.12")]
pub struct AlgorithmIdentification31 {
    #[yaserde(rename = "Algo")]
    #[cfg_attr(feature = "serde", serde(rename = "Algo"))]
    pub algo: Algorithm27Code,

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

impl Validate for AlgorithmIdentification31 {}


#[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:catm.005.001.12")]
pub struct AlgorithmIdentification32 {
    #[yaserde(rename = "Algo")]
    #[cfg_attr(feature = "serde", serde(rename = "Algo"))]
    pub algo: Algorithm28Code,

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

impl Validate for AlgorithmIdentification32 {}


#[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:catm.005.001.12")]
pub struct AlgorithmIdentification33 {
    #[yaserde(rename = "Algo")]
    #[cfg_attr(feature = "serde", serde(rename = "Algo"))]
    pub algo: Algorithm29Code,

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

impl Validate for AlgorithmIdentification33 {}


#[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:catm.005.001.12")]
pub struct AlgorithmIdentification34 {
    #[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: Parameter18,
}

impl Validate for AlgorithmIdentification34 {}


#[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:catm.005.001.12")]
pub struct AlgorithmIdentification35 {
    #[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: Parameter17,
}

impl Validate for AlgorithmIdentification35 {}


#[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:catm.005.001.12")]
pub struct AlgorithmIdentification36 {
    #[yaserde(rename = "Algo")]
    #[cfg_attr(feature = "serde", serde(rename = "Algo"))]
    pub algo: Algorithm26Code,
}

impl Validate for AlgorithmIdentification36 {}


#[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:catm.005.001.12")]

pub enum AmountUnit1Code {
    #[yaserde(rename = "MONE")]
    #[cfg_attr(feature = "serde", serde(rename = "MONE"))]
    Mone,
    #[yaserde(rename = "POIN")]
    #[cfg_attr(feature = "serde", serde(rename = "POIN"))]
    Poin,
    __Unknown__(String),
}

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

impl Validate for AmountUnit1Code {}



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

impl Validate for AnyBICDec2014Identifier {}
#[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:catm.005.001.12")]
pub struct ApplicationParameters13 {
    #[yaserde(rename = "ActnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ActnTp"))]
    pub actn_tp: TerminalManagementAction3Code,

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

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

    #[yaserde(rename = "ParamFrmtIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "ParamFrmtIdr"))]
    pub param_frmt_idr: Max8Text,

    #[yaserde(rename = "ParamsLngth")]
    #[cfg_attr(feature = "serde", serde(rename = "ParamsLngth"))]
    pub params_lngth: PositiveNumber,

    #[yaserde(rename = "OffsetStart")]
    #[cfg_attr(feature = "serde", serde(rename = "OffsetStart"))]
    pub offset_start: PositiveNumber,

    #[yaserde(rename = "OffsetEnd")]
    #[cfg_attr(feature = "serde", serde(rename = "OffsetEnd"))]
    pub offset_end: PositiveNumber,

    #[yaserde(rename = "Params")]
    #[cfg_attr(feature = "serde", serde(rename = "Params"))]
    pub params: Vec<Max100KBinary>,

    #[yaserde(rename = "NcrptdParams")]
    #[cfg_attr(feature = "serde", serde(rename = "NcrptdParams"))]
    pub ncrptd_params: ContentInformationType40,
}

impl Validate for ApplicationParameters13 {}


#[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:catm.005.001.12")]

pub enum AttendanceContext1Code {
    #[yaserde(rename = "ATTD")]
    #[cfg_attr(feature = "serde", serde(rename = "ATTD"))]
    Attd,
    #[yaserde(rename = "SATT")]
    #[cfg_attr(feature = "serde", serde(rename = "SATT"))]
    Satt,
    #[yaserde(rename = "UATT")]
    #[cfg_attr(feature = "serde", serde(rename = "UATT"))]
    Uatt,
    __Unknown__(String),
}

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

impl Validate for AttendanceContext1Code {}



#[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:catm.005.001.12")]

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:catm.005.001.12")]
pub struct AuthenticatedData10 {
    #[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<Recipient15Choice>,

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

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


#[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:catm.005.001.12")]

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

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

impl Validate for AuthenticationEntity2Code {}



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

pub enum AuthenticationMethod6Code {
    #[yaserde(rename = "NPIN")]
    #[cfg_attr(feature = "serde", serde(rename = "NPIN"))]
    Npin,
    #[yaserde(rename = "PPSG")]
    #[cfg_attr(feature = "serde", serde(rename = "PPSG"))]
    Ppsg,
    #[yaserde(rename = "PSWD")]
    #[cfg_attr(feature = "serde", serde(rename = "PSWD"))]
    Pswd,
    #[yaserde(rename = "SCRT")]
    #[cfg_attr(feature = "serde", serde(rename = "SCRT"))]
    Scrt,
    #[yaserde(rename = "SCNL")]
    #[cfg_attr(feature = "serde", serde(rename = "SCNL"))]
    Scnl,
    #[yaserde(rename = "SNCT")]
    #[cfg_attr(feature = "serde", serde(rename = "SNCT"))]
    Snct,
    #[yaserde(rename = "CPSG")]
    #[cfg_attr(feature = "serde", serde(rename = "CPSG"))]
    Cpsg,
    #[yaserde(rename = "ADDB")]
    #[cfg_attr(feature = "serde", serde(rename = "ADDB"))]
    Addb,
    #[yaserde(rename = "BIOM")]
    #[cfg_attr(feature = "serde", serde(rename = "BIOM"))]
    Biom,
    #[yaserde(rename = "CDHI")]
    #[cfg_attr(feature = "serde", serde(rename = "CDHI"))]
    Cdhi,
    #[yaserde(rename = "CRYP")]
    #[cfg_attr(feature = "serde", serde(rename = "CRYP"))]
    Cryp,
    #[yaserde(rename = "CSCV")]
    #[cfg_attr(feature = "serde", serde(rename = "CSCV"))]
    Cscv,
    #[yaserde(rename = "PSVE")]
    #[cfg_attr(feature = "serde", serde(rename = "PSVE"))]
    Psve,
    #[yaserde(rename = "CSEC")]
    #[cfg_attr(feature = "serde", serde(rename = "CSEC"))]
    Csec,
    #[yaserde(rename = "ADDS")]
    #[cfg_attr(feature = "serde", serde(rename = "ADDS"))]
    Adds,
    #[yaserde(rename = "MANU")]
    #[cfg_attr(feature = "serde", serde(rename = "MANU"))]
    Manu,
    #[yaserde(rename = "FPIN")]
    #[cfg_attr(feature = "serde", serde(rename = "FPIN"))]
    Fpin,
    #[yaserde(rename = "TOKP")]
    #[cfg_attr(feature = "serde", serde(rename = "TOKP"))]
    Tokp,
    __Unknown__(String),
}

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

impl Validate for AuthenticationMethod6Code {}



#[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:catm.005.001.12")]

pub enum AuthenticationMethod8Code {
    #[yaserde(rename = "TOKA")]
    #[cfg_attr(feature = "serde", serde(rename = "TOKA"))]
    Toka,
    #[yaserde(rename = "ADDB")]
    #[cfg_attr(feature = "serde", serde(rename = "ADDB"))]
    Addb,
    #[yaserde(rename = "BYPS")]
    #[cfg_attr(feature = "serde", serde(rename = "BYPS"))]
    Byps,
    #[yaserde(rename = "BIOM")]
    #[cfg_attr(feature = "serde", serde(rename = "BIOM"))]
    Biom,
    #[yaserde(rename = "CDHI")]
    #[cfg_attr(feature = "serde", serde(rename = "CDHI"))]
    Cdhi,
    #[yaserde(rename = "CRYP")]
    #[cfg_attr(feature = "serde", serde(rename = "CRYP"))]
    Cryp,
    #[yaserde(rename = "CSCV")]
    #[cfg_attr(feature = "serde", serde(rename = "CSCV"))]
    Cscv,
    #[yaserde(rename = "MANU")]
    #[cfg_attr(feature = "serde", serde(rename = "MANU"))]
    Manu,
    #[yaserde(rename = "MERC")]
    #[cfg_attr(feature = "serde", serde(rename = "MERC"))]
    Merc,
    #[yaserde(rename = "MOBL")]
    #[cfg_attr(feature = "serde", serde(rename = "MOBL"))]
    Mobl,
    #[yaserde(rename = "FPIN")]
    #[cfg_attr(feature = "serde", serde(rename = "FPIN"))]
    Fpin,
    #[yaserde(rename = "NPIN")]
    #[cfg_attr(feature = "serde", serde(rename = "NPIN"))]
    Npin,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "PPSG")]
    #[cfg_attr(feature = "serde", serde(rename = "PPSG"))]
    Ppsg,
    #[yaserde(rename = "PSVE")]
    #[cfg_attr(feature = "serde", serde(rename = "PSVE"))]
    Psve,
    #[yaserde(rename = "PSWD")]
    #[cfg_attr(feature = "serde", serde(rename = "PSWD"))]
    Pswd,
    #[yaserde(rename = "TOKP")]
    #[cfg_attr(feature = "serde", serde(rename = "TOKP"))]
    Tokp,
    #[yaserde(rename = "SCRT")]
    #[cfg_attr(feature = "serde", serde(rename = "SCRT"))]
    Scrt,
    #[yaserde(rename = "SCNL")]
    #[cfg_attr(feature = "serde", serde(rename = "SCNL"))]
    Scnl,
    #[yaserde(rename = "CSEC")]
    #[cfg_attr(feature = "serde", serde(rename = "CSEC"))]
    Csec,
    #[yaserde(rename = "SNCT")]
    #[cfg_attr(feature = "serde", serde(rename = "SNCT"))]
    Snct,
    #[yaserde(rename = "ADDS")]
    #[cfg_attr(feature = "serde", serde(rename = "ADDS"))]
    Adds,
    #[yaserde(rename = "CPSG")]
    #[cfg_attr(feature = "serde", serde(rename = "CPSG"))]
    Cpsg,
    #[yaserde(rename = "TOKN")]
    #[cfg_attr(feature = "serde", serde(rename = "TOKN"))]
    Tokn,
    #[yaserde(rename = "UKNW")]
    #[cfg_attr(feature = "serde", serde(rename = "UKNW"))]
    Uknw,
    __Unknown__(String),
}

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

impl Validate for AuthenticationMethod8Code {}



#[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:catm.005.001.12")]

pub enum AuthenticationResult1Code {
    #[yaserde(rename = "DENY")]
    #[cfg_attr(feature = "serde", serde(rename = "DENY"))]
    Deny,
    #[yaserde(rename = "MRCH")]
    #[cfg_attr(feature = "serde", serde(rename = "MRCH"))]
    Mrch,
    #[yaserde(rename = "CARD")]
    #[cfg_attr(feature = "serde", serde(rename = "CARD"))]
    Card,
    #[yaserde(rename = "AUTH")]
    #[cfg_attr(feature = "serde", serde(rename = "AUTH"))]
    Auth,
    #[yaserde(rename = "CRPT")]
    #[cfg_attr(feature = "serde", serde(rename = "CRPT"))]
    Crpt,
    #[yaserde(rename = "UCRP")]
    #[cfg_attr(feature = "serde", serde(rename = "UCRP"))]
    Ucrp,
    __Unknown__(String),
}

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

impl Validate for AuthenticationResult1Code {}



#[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:catm.005.001.12")]

pub enum BarcodeType1Code {
    #[yaserde(rename = "COQR")]
    #[cfg_attr(feature = "serde", serde(rename = "COQR"))]
    Coqr,
    C128,
    C025,
    C039,
    #[yaserde(rename = "EA13")]
    #[cfg_attr(feature = "serde", serde(rename = "EA13"))]
    Ea13,
    #[yaserde(rename = "EAN8")]
    #[cfg_attr(feature = "serde", serde(rename = "EAN8"))]
    Ean8,
    P417,
    #[yaserde(rename = "UPCA")]
    #[cfg_attr(feature = "serde", serde(rename = "UPCA"))]
    Upca,
    __Unknown__(String),
}

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

impl Validate for BarcodeType1Code {}



#[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:catm.005.001.12")]

pub enum BatchTransactionType1Code {
    #[yaserde(rename = "DTCT")]
    #[cfg_attr(feature = "serde", serde(rename = "DTCT"))]
    Dtct,
    #[yaserde(rename = "CNCL")]
    #[cfg_attr(feature = "serde", serde(rename = "CNCL"))]
    Cncl,
    #[yaserde(rename = "FAIL")]
    #[cfg_attr(feature = "serde", serde(rename = "FAIL"))]
    Fail,
    #[yaserde(rename = "DCLN")]
    #[cfg_attr(feature = "serde", serde(rename = "DCLN"))]
    Dcln,
    __Unknown__(String),
}

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

impl Validate for BatchTransactionType1Code {}



#[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:catm.005.001.12")]

pub enum BusinessArea2Code {
    #[yaserde(rename = "AIBD")]
    #[cfg_attr(feature = "serde", serde(rename = "AIBD"))]
    Aibd,
    #[yaserde(rename = "PPAY")]
    #[cfg_attr(feature = "serde", serde(rename = "PPAY"))]
    Ppay,
    #[yaserde(rename = "TKNF")]
    #[cfg_attr(feature = "serde", serde(rename = "TKNF"))]
    Tknf,
    #[yaserde(rename = "EOPT")]
    #[cfg_attr(feature = "serde", serde(rename = "EOPT"))]
    Eopt,
    #[yaserde(rename = "TOPT")]
    #[cfg_attr(feature = "serde", serde(rename = "TOPT"))]
    Topt,
    __Unknown__(String),
}

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

impl Validate for BusinessArea2Code {}



#[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:catm.005.001.12")]

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

pub enum CapeencodingMode1Code {
    #[yaserde(rename = "XMLE")]
    #[cfg_attr(feature = "serde", serde(rename = "XMLE"))]
    Xmle,
    #[yaserde(rename = "JSON")]
    #[cfg_attr(feature = "serde", serde(rename = "JSON"))]
    Json,
    __Unknown__(String),
}

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

impl Validate for CapeencodingMode1Code {}



#[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:catm.005.001.12")]

pub enum CapeexchangeMode1Code {
    #[yaserde(rename = "APIE")]
    #[cfg_attr(feature = "serde", serde(rename = "APIE"))]
    Apie,
    #[yaserde(rename = "MSGE")]
    #[cfg_attr(feature = "serde", serde(rename = "MSGE"))]
    Msge,
    __Unknown__(String),
}

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

impl Validate for CapeexchangeMode1Code {}



#[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:catm.005.001.12")]

pub enum CancellationProcess2Code {
    #[yaserde(rename = "ADVC")]
    #[cfg_attr(feature = "serde", serde(rename = "ADVC"))]
    Advc,
    #[yaserde(rename = "NALW")]
    #[cfg_attr(feature = "serde", serde(rename = "NALW"))]
    Nalw,
    #[yaserde(rename = "REQU")]
    #[cfg_attr(feature = "serde", serde(rename = "REQU"))]
    Requ,
    #[yaserde(rename = "APPL")]
    #[cfg_attr(feature = "serde", serde(rename = "APPL"))]
    Appl,
    __Unknown__(String),
}

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

impl Validate for CancellationProcess2Code {}



#[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:catm.005.001.12")]

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

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

impl Validate for CardDataReading5Code {}



#[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:catm.005.001.12")]

pub enum CardDataReading8Code {
    #[yaserde(rename = "TAGC")]
    #[cfg_attr(feature = "serde", serde(rename = "TAGC"))]
    Tagc,
    #[yaserde(rename = "PHYS")]
    #[cfg_attr(feature = "serde", serde(rename = "PHYS"))]
    Phys,
    #[yaserde(rename = "BRCD")]
    #[cfg_attr(feature = "serde", serde(rename = "BRCD"))]
    Brcd,
    #[yaserde(rename = "MGST")]
    #[cfg_attr(feature = "serde", serde(rename = "MGST"))]
    Mgst,
    #[yaserde(rename = "CICC")]
    #[cfg_attr(feature = "serde", serde(rename = "CICC"))]
    Cicc,
    #[yaserde(rename = "DFLE")]
    #[cfg_attr(feature = "serde", serde(rename = "DFLE"))]
    Dfle,
    #[yaserde(rename = "CTLS")]
    #[cfg_attr(feature = "serde", serde(rename = "CTLS"))]
    Ctls,
    #[yaserde(rename = "ECTL")]
    #[cfg_attr(feature = "serde", serde(rename = "ECTL"))]
    Ectl,
    #[yaserde(rename = "CDFL")]
    #[cfg_attr(feature = "serde", serde(rename = "CDFL"))]
    Cdfl,
    #[yaserde(rename = "SICC")]
    #[cfg_attr(feature = "serde", serde(rename = "SICC"))]
    Sicc,
    #[yaserde(rename = "UNKW")]
    #[cfg_attr(feature = "serde", serde(rename = "UNKW"))]
    Unkw,
    #[yaserde(rename = "QRCD")]
    #[cfg_attr(feature = "serde", serde(rename = "QRCD"))]
    Qrcd,
    #[yaserde(rename = "OPTC")]
    #[cfg_attr(feature = "serde", serde(rename = "OPTC"))]
    Optc,
    __Unknown__(String),
}

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

impl Validate for CardDataReading8Code {}



#[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:catm.005.001.12")]

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

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

impl Validate for CardFallback1Code {}



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

pub enum CardIdentificationType1Code {
    #[yaserde(rename = "ACCT")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCT"))]
    Acct,
    #[yaserde(rename = "BARC")]
    #[cfg_attr(feature = "serde", serde(rename = "BARC"))]
    Barc,
    #[yaserde(rename = "ISO2")]
    #[cfg_attr(feature = "serde", serde(rename = "ISO2"))]
    Iso2,
    #[yaserde(rename = "PHON")]
    #[cfg_attr(feature = "serde", serde(rename = "PHON"))]
    Phon,
    #[yaserde(rename = "CPAN")]
    #[cfg_attr(feature = "serde", serde(rename = "CPAN"))]
    Cpan,
    #[yaserde(rename = "PRIV")]
    #[cfg_attr(feature = "serde", serde(rename = "PRIV"))]
    Priv,
    #[yaserde(rename = "UUID")]
    #[cfg_attr(feature = "serde", serde(rename = "UUID"))]
    Uuid,
    __Unknown__(String),
}

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

impl Validate for CardIdentificationType1Code {}



#[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:catm.005.001.12")]
pub struct CardPaymentEnvironment82 {
    #[yaserde(rename = "Acqrr")]
    #[cfg_attr(feature = "serde", serde(rename = "Acqrr"))]
    pub acqrr: Acquirer10,

    #[yaserde(rename = "SvcPrvdr")]
    #[cfg_attr(feature = "serde", serde(rename = "SvcPrvdr"))]
    pub svc_prvdr: Acquirer10,

    #[yaserde(rename = "Mrchnt")]
    #[cfg_attr(feature = "serde", serde(rename = "Mrchnt"))]
    pub mrchnt: Organisation45,

    #[yaserde(rename = "POI")]
    #[cfg_attr(feature = "serde", serde(rename = "POI"))]
    pub poi: PointOfInteraction16,

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

    #[yaserde(rename = "Chck")]
    #[cfg_attr(feature = "serde", serde(rename = "Chck"))]
    pub chck: Check1,

    #[yaserde(rename = "StordValAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "StordValAcct"))]
    pub stord_val_acct: Vec<StoredValueAccount2>,

    #[yaserde(rename = "LltyAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "LltyAcct"))]
    pub llty_acct: Vec<LoyaltyAccount3>,

    #[yaserde(rename = "CstmrDvc")]
    #[cfg_attr(feature = "serde", serde(rename = "CstmrDvc"))]
    pub cstmr_dvc: CustomerDevice3,

    #[yaserde(rename = "Wllt")]
    #[cfg_attr(feature = "serde", serde(rename = "Wllt"))]
    pub wllt: CustomerDevice3,

    #[yaserde(rename = "PmtTkn")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtTkn"))]
    pub pmt_tkn: Token1,

    #[yaserde(rename = "MrchntTkn")]
    #[cfg_attr(feature = "serde", serde(rename = "MrchntTkn"))]
    pub mrchnt_tkn: MerchantToken2,

    #[yaserde(rename = "Crdhldr")]
    #[cfg_attr(feature = "serde", serde(rename = "Crdhldr"))]
    pub crdhldr: Cardholder21,

    #[yaserde(rename = "PrtctdCrdhldrData")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtctdCrdhldrData"))]
    pub prtctd_crdhldr_data: ContentInformationType40,

    #[yaserde(rename = "SaleEnvt")]
    #[cfg_attr(feature = "serde", serde(rename = "SaleEnvt"))]
    pub sale_envt: RetailerSaleEnvironment2,
}

impl Validate for CardPaymentEnvironment82 {}


#[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:catm.005.001.12")]

pub enum CardProductType1Code {
    #[yaserde(rename = "COMM")]
    #[cfg_attr(feature = "serde", serde(rename = "COMM"))]
    Comm,
    #[yaserde(rename = "CONS")]
    #[cfg_attr(feature = "serde", serde(rename = "CONS"))]
    Cons,
    __Unknown__(String),
}

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

impl Validate for CardProductType1Code {}



#[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:catm.005.001.12")]
pub struct Cardholder21 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: PersonIdentification15,

    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max45Text,

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

    #[yaserde(rename = "BllgAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "BllgAdr"))]
    pub bllg_adr: PostalAddress22,

    #[yaserde(rename = "ShppgAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "ShppgAdr"))]
    pub shppg_adr: PostalAddress22,

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

    #[yaserde(rename = "Vhcl")]
    #[cfg_attr(feature = "serde", serde(rename = "Vhcl"))]
    pub vhcl: Vehicle1,

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

    #[yaserde(rename = "TxVrfctnRslt")]
    #[cfg_attr(feature = "serde", serde(rename = "TxVrfctnRslt"))]
    pub tx_vrfctn_rslt: Vec<TransactionVerificationResult4>,

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

    #[yaserde(rename = "MobData")]
    #[cfg_attr(feature = "serde", serde(rename = "MobData"))]
    pub mob_data: Vec<MobileData6>,
}

impl Validate for Cardholder21 {}


#[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:catm.005.001.12")]
pub struct CardholderAuthentication17 {
    #[yaserde(rename = "AuthntcnMtd")]
    #[cfg_attr(feature = "serde", serde(rename = "AuthntcnMtd"))]
    pub authntcn_mtd: AuthenticationMethod8Code,

    #[yaserde(rename = "AuthntcnXmptn")]
    #[cfg_attr(feature = "serde", serde(rename = "AuthntcnXmptn"))]
    pub authntcn_xmptn: Exemption1Code,

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

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

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

    #[yaserde(rename = "CrdhldrId")]
    #[cfg_attr(feature = "serde", serde(rename = "CrdhldrId"))]
    pub crdhldr_id: PersonIdentification15,

    #[yaserde(rename = "AdrVrfctn")]
    #[cfg_attr(feature = "serde", serde(rename = "AdrVrfctn"))]
    pub adr_vrfctn: AddressVerification1,

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

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

    #[yaserde(rename = "AuthntcnRslt")]
    #[cfg_attr(feature = "serde", serde(rename = "AuthntcnRslt"))]
    pub authntcn_rslt: AuthenticationResult1Code,

    #[yaserde(rename = "AuthntcnAddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AuthntcnAddtlInf"))]
    pub authntcn_addtl_inf: ExternallyDefinedData5,
}

impl Validate for CardholderAuthentication17 {}


#[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:catm.005.001.12")]

pub enum CardholderVerificationCapability4Code {
    #[yaserde(rename = "APKI")]
    #[cfg_attr(feature = "serde", serde(rename = "APKI"))]
    Apki,
    #[yaserde(rename = "CHDT")]
    #[cfg_attr(feature = "serde", serde(rename = "CHDT"))]
    Chdt,
    #[yaserde(rename = "MNSG")]
    #[cfg_attr(feature = "serde", serde(rename = "MNSG"))]
    Mnsg,
    #[yaserde(rename = "MNVR")]
    #[cfg_attr(feature = "serde", serde(rename = "MNVR"))]
    Mnvr,
    #[yaserde(rename = "FBIG")]
    #[cfg_attr(feature = "serde", serde(rename = "FBIG"))]
    Fbig,
    #[yaserde(rename = "FBIO")]
    #[cfg_attr(feature = "serde", serde(rename = "FBIO"))]
    Fbio,
    #[yaserde(rename = "FDSG")]
    #[cfg_attr(feature = "serde", serde(rename = "FDSG"))]
    Fdsg,
    #[yaserde(rename = "FCPN")]
    #[cfg_attr(feature = "serde", serde(rename = "FCPN"))]
    Fcpn,
    #[yaserde(rename = "FEPN")]
    #[cfg_attr(feature = "serde", serde(rename = "FEPN"))]
    Fepn,
    #[yaserde(rename = "NPIN")]
    #[cfg_attr(feature = "serde", serde(rename = "NPIN"))]
    Npin,
    #[yaserde(rename = "PKIS")]
    #[cfg_attr(feature = "serde", serde(rename = "PKIS"))]
    Pkis,
    #[yaserde(rename = "SCEC")]
    #[cfg_attr(feature = "serde", serde(rename = "SCEC"))]
    Scec,
    #[yaserde(rename = "NBIO")]
    #[cfg_attr(feature = "serde", serde(rename = "NBIO"))]
    Nbio,
    #[yaserde(rename = "NOVF")]
    #[cfg_attr(feature = "serde", serde(rename = "NOVF"))]
    Novf,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    __Unknown__(String),
}

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

impl Validate for CardholderVerificationCapability4Code {}



#[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:catm.005.001.12")]
pub struct CashAccount40 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: AccountIdentification4Choice,

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

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

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

    #[yaserde(rename = "Prxy")]
    #[cfg_attr(feature = "serde", serde(rename = "Prxy"))]
    pub prxy: ProxyAccountIdentification1,
}

impl Validate for CashAccount40 {}
#[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:catm.005.001.12")]
pub struct CashAccountType2Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ExternalCashAccountType1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max35Text>,
}

impl Validate for CashAccountType2Choice {}




#[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:catm.005.001.12")]
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:catm.005.001.12")]
pub struct Check1 {
    #[yaserde(rename = "BkId")]
    #[cfg_attr(feature = "serde", serde(rename = "BkId"))]
    pub bk_id: Max35Text,

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

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

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

    #[yaserde(rename = "ChckTrckData2")]
    #[cfg_attr(feature = "serde", serde(rename = "ChckTrckData2"))]
    pub chck_trck_data_2: TrackData2,

    #[yaserde(rename = "ChckTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ChckTp"))]
    pub chck_tp: CheckType1Code,

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

impl Validate for Check1 {}


#[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:catm.005.001.12")]

pub enum CheckType1Code {
    #[yaserde(rename = "BANK")]
    #[cfg_attr(feature = "serde", serde(rename = "BANK"))]
    Bank,
    #[yaserde(rename = "BUSI")]
    #[cfg_attr(feature = "serde", serde(rename = "BUSI"))]
    Busi,
    #[yaserde(rename = "GOVC")]
    #[cfg_attr(feature = "serde", serde(rename = "GOVC"))]
    Govc,
    #[yaserde(rename = "PAYR")]
    #[cfg_attr(feature = "serde", serde(rename = "PAYR"))]
    Payr,
    #[yaserde(rename = "PERS")]
    #[cfg_attr(feature = "serde", serde(rename = "PERS"))]
    Pers,
    __Unknown__(String),
}

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

impl Validate for CheckType1Code {}



#[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:catm.005.001.12")]
pub struct ClockSynchronisation3 {
    #[yaserde(rename = "POITmZone")]
    #[cfg_attr(feature = "serde", serde(rename = "POITmZone"))]
    pub poi_tm_zone: Max70Text,

    #[yaserde(rename = "SynctnSvr")]
    #[cfg_attr(feature = "serde", serde(rename = "SynctnSvr"))]
    pub synctn_svr: Vec<NetworkParameters7>,

    #[yaserde(rename = "Dely")]
    #[cfg_attr(feature = "serde", serde(rename = "Dely"))]
    pub dely: Isotime,
}

impl Validate for ClockSynchronisation3 {}


#[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:catm.005.001.12")]
pub struct CommunicationAddress9 {
    #[yaserde(rename = "PstlAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "PstlAdr"))]
    pub pstl_adr: PostalAddress22,

    #[yaserde(rename = "Email")]
    #[cfg_attr(feature = "serde", serde(rename = "Email"))]
    pub email: Max256Text,

    #[yaserde(rename = "URLAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "URLAdr"))]
    pub url_adr: Max256Text,

    #[yaserde(rename = "Phne")]
    #[cfg_attr(feature = "serde", serde(rename = "Phne"))]
    pub phne: PhoneNumber,

    #[yaserde(rename = "CstmrSvc")]
    #[cfg_attr(feature = "serde", serde(rename = "CstmrSvc"))]
    pub cstmr_svc: PhoneNumber,

    #[yaserde(rename = "AddtlCtctInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlCtctInf"))]
    pub addtl_ctct_inf: Max256Text,
}

impl Validate for CommunicationAddress9 {}


#[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:catm.005.001.12")]
pub struct CommunicationCharacteristics5 {
    #[yaserde(rename = "ComTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ComTp"))]
    pub com_tp: PoicommunicationType2Code,

    #[yaserde(rename = "RmotPty")]
    #[cfg_attr(feature = "serde", serde(rename = "RmotPty"))]
    pub rmot_pty: Vec<PartyType7Code>,

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

    #[yaserde(rename = "Params")]
    #[cfg_attr(feature = "serde", serde(rename = "Params"))]
    pub params: NetworkParameters7,

    #[yaserde(rename = "PhysIntrfc")]
    #[cfg_attr(feature = "serde", serde(rename = "PhysIntrfc"))]
    pub phys_intrfc: PhysicalInterfaceParameter1,
}

impl Validate for CommunicationCharacteristics5 {}


#[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:catm.005.001.12")]
pub struct Contact13 {
    #[yaserde(rename = "NmPrfx")]
    #[cfg_attr(feature = "serde", serde(rename = "NmPrfx"))]
    pub nm_prfx: NamePrefix2Code,

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

    #[yaserde(rename = "PhneNb")]
    #[cfg_attr(feature = "serde", serde(rename = "PhneNb"))]
    pub phne_nb: PhoneNumber,

    #[yaserde(rename = "MobNb")]
    #[cfg_attr(feature = "serde", serde(rename = "MobNb"))]
    pub mob_nb: PhoneNumber,

    #[yaserde(rename = "FaxNb")]
    #[cfg_attr(feature = "serde", serde(rename = "FaxNb"))]
    pub fax_nb: PhoneNumber,

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

    #[yaserde(rename = "EmailAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "EmailAdr"))]
    pub email_adr: Max256Text,

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

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

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

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

    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Vec<OtherContact1>,

    #[yaserde(rename = "PrefrdMtd")]
    #[cfg_attr(feature = "serde", serde(rename = "PrefrdMtd"))]
    pub prefrd_mtd: PreferredContactMethod2Code,
}

impl Validate for Contact13 {}


#[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:catm.005.001.12")]
pub struct ContentInformationType38 {
    #[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: AuthenticatedData10,

    #[yaserde(rename = "SgndData")]
    #[cfg_attr(feature = "serde", serde(rename = "SgndData"))]
    pub sgnd_data: SignedData9,
}

impl Validate for ContentInformationType38 {}


#[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:catm.005.001.12")]
pub struct ContentInformationType39 {
    #[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: EnvelopedData11,

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

    #[yaserde(rename = "SgndData")]
    #[cfg_attr(feature = "serde", serde(rename = "SgndData"))]
    pub sgnd_data: SignedData9,

    #[yaserde(rename = "DgstdData")]
    #[cfg_attr(feature = "serde", serde(rename = "DgstdData"))]
    pub dgstd_data: DigestedData6,
}

impl Validate for ContentInformationType39 {}


#[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:catm.005.001.12")]
pub struct ContentInformationType40 {
    #[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: EnvelopedData11,
}

impl Validate for ContentInformationType40 {}


#[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:catm.005.001.12")]

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

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

impl Validate for ContentType2Code {}



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

impl Validate for CountryCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.005.001.12")]
pub struct CreditTransferContext1 {
    #[yaserde(rename = "AutomtcNtfctnOfCshMvmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "AutomtcNtfctnOfCshMvmnt"))]
    pub automtc_ntfctn_of_csh_mvmnt: TrueFalseIndicator,

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

    #[yaserde(rename = "SysToNtfy")]
    #[cfg_attr(feature = "serde", serde(rename = "SysToNtfy"))]
    pub sys_to_ntfy: Max1025Text,

    #[yaserde(rename = "Dbtr")]
    #[cfg_attr(feature = "serde", serde(rename = "Dbtr"))]
    pub dbtr: PartyIdentification272,

    #[yaserde(rename = "DbtrAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "DbtrAcct"))]
    pub dbtr_acct: CashAccount40,

    #[yaserde(rename = "PrtctdDbtrAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtctdDbtrAcct"))]
    pub prtctd_dbtr_acct: ContentInformationType39,

    #[yaserde(rename = "Cdtr")]
    #[cfg_attr(feature = "serde", serde(rename = "Cdtr"))]
    pub cdtr: PartyIdentification272,

    #[yaserde(rename = "CdtrAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtrAcct"))]
    pub cdtr_acct: CashAccount40,

    #[yaserde(rename = "PrtctdCdtrAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtctdCdtrAcct"))]
    pub prtctd_cdtr_acct: ContentInformationType39,
}

impl Validate for CreditTransferContext1 {}


#[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:catm.005.001.12")]
pub struct CryptographicKey19 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max350Text,

    #[yaserde(rename = "KeyId")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyId"))]
    pub key_id: Max350Text,

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

    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max256Text,

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

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

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

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

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

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

    #[yaserde(rename = "Fctn")]
    #[cfg_attr(feature = "serde", serde(rename = "Fctn"))]
    pub fctn: Vec<KeyUsage1Code>,

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

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

    #[yaserde(rename = "KeyVal")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyVal"))]
    pub key_val: ContentInformationType39,

    #[yaserde(rename = "CmpntWthAuthrsdAccs")]
    #[cfg_attr(feature = "serde", serde(rename = "CmpntWthAuthrsdAccs"))]
    pub cmpnt_wth_authrsd_accs: Vec<GenericIdentification186>,

    #[yaserde(rename = "PrtctdCmpntWthAuthrsdAccs")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtctdCmpntWthAuthrsdAccs"))]
    pub prtctd_cmpnt_wth_authrsd_accs: Vec<ContentInformationType39>,

    #[yaserde(rename = "KeyChckVal")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyChckVal"))]
    pub key_chck_val: Max35Binary,

    #[yaserde(rename = "AddtlMgmtInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlMgmtInf"))]
    pub addtl_mgmt_inf: Vec<GenericInformation1>,

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

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

impl Validate for CryptographicKey19 {}


#[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:catm.005.001.12")]

pub enum CryptographicKeyType5Code {
    #[yaserde(rename = "AES2")]
    #[cfg_attr(feature = "serde", serde(rename = "AES2"))]
    Aes2,
    #[yaserde(rename = "EDE3")]
    #[cfg_attr(feature = "serde", serde(rename = "EDE3"))]
    Ede3,
    #[yaserde(rename = "DKP9")]
    #[cfg_attr(feature = "serde", serde(rename = "DKP9"))]
    Dkp9,
    #[yaserde(rename = "AES9")]
    #[cfg_attr(feature = "serde", serde(rename = "AES9"))]
    Aes9,
    #[yaserde(rename = "AES5")]
    #[cfg_attr(feature = "serde", serde(rename = "AES5"))]
    Aes5,
    #[yaserde(rename = "EDE4")]
    #[cfg_attr(feature = "serde", serde(rename = "EDE4"))]
    Ede4,
    #[yaserde(rename = "UKA2")]
    #[cfg_attr(feature = "serde", serde(rename = "UKA2"))]
    Uka2,
    #[yaserde(rename = "UKA6")]
    #[cfg_attr(feature = "serde", serde(rename = "UKA6"))]
    Uka6,
    #[yaserde(rename = "RSAC")]
    #[cfg_attr(feature = "serde", serde(rename = "RSAC"))]
    Rsac,
    #[yaserde(rename = "ECCC")]
    #[cfg_attr(feature = "serde", serde(rename = "ECCC"))]
    Eccc,
    #[yaserde(rename = "DKAE")]
    #[cfg_attr(feature = "serde", serde(rename = "DKAE"))]
    Dkae,
    #[yaserde(rename = "UKA8")]
    #[cfg_attr(feature = "serde", serde(rename = "UKA8"))]
    Uka8,
    __Unknown__(String),
}

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

impl Validate for CryptographicKeyType5Code {}



#[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:catm.005.001.12")]
pub struct CustomerDevice3 {
    #[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: Max70Text,

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

impl Validate for CustomerDevice3 {}


#[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:catm.005.001.12")]

pub enum DataSetCategory10Code {
    #[yaserde(rename = "AQPR")]
    #[cfg_attr(feature = "serde", serde(rename = "AQPR"))]
    Aqpr,
    #[yaserde(rename = "APPR")]
    #[cfg_attr(feature = "serde", serde(rename = "APPR"))]
    Appr,
    #[yaserde(rename = "MTMG")]
    #[cfg_attr(feature = "serde", serde(rename = "MTMG"))]
    Mtmg,
    #[yaserde(rename = "MRPR")]
    #[cfg_attr(feature = "serde", serde(rename = "MRPR"))]
    Mrpr,
    #[yaserde(rename = "MTOR")]
    #[cfg_attr(feature = "serde", serde(rename = "MTOR"))]
    Mtor,
    #[yaserde(rename = "SCPR")]
    #[cfg_attr(feature = "serde", serde(rename = "SCPR"))]
    Scpr,
    #[yaserde(rename = "SWPK")]
    #[cfg_attr(feature = "serde", serde(rename = "SWPK"))]
    Swpk,
    #[yaserde(rename = "TRPR")]
    #[cfg_attr(feature = "serde", serde(rename = "TRPR"))]
    Trpr,
    #[yaserde(rename = "CRTF")]
    #[cfg_attr(feature = "serde", serde(rename = "CRTF"))]
    Crtf,
    #[yaserde(rename = "TMSP")]
    #[cfg_attr(feature = "serde", serde(rename = "TMSP"))]
    Tmsp,
    __Unknown__(String),
}

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

impl Validate for DataSetCategory10Code {}



#[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:catm.005.001.12")]

pub enum DataSetCategory19Code {
    #[yaserde(rename = "ACQP")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQP"))]
    Acqp,
    #[yaserde(rename = "APPR")]
    #[cfg_attr(feature = "serde", serde(rename = "APPR"))]
    Appr,
    #[yaserde(rename = "APSB")]
    #[cfg_attr(feature = "serde", serde(rename = "APSB"))]
    Apsb,
    #[yaserde(rename = "KDWL")]
    #[cfg_attr(feature = "serde", serde(rename = "KDWL"))]
    Kdwl,
    #[yaserde(rename = "KMGT")]
    #[cfg_attr(feature = "serde", serde(rename = "KMGT"))]
    Kmgt,
    #[yaserde(rename = "RPRT")]
    #[cfg_attr(feature = "serde", serde(rename = "RPRT"))]
    Rprt,
    #[yaserde(rename = "SWPK")]
    #[cfg_attr(feature = "serde", serde(rename = "SWPK"))]
    Swpk,
    #[yaserde(rename = "TMSP")]
    #[cfg_attr(feature = "serde", serde(rename = "TMSP"))]
    Tmsp,
    #[yaserde(rename = "MRPR")]
    #[cfg_attr(feature = "serde", serde(rename = "MRPR"))]
    Mrpr,
    #[yaserde(rename = "TRPR")]
    #[cfg_attr(feature = "serde", serde(rename = "TRPR"))]
    Trpr,
    #[yaserde(rename = "CRTF")]
    #[cfg_attr(feature = "serde", serde(rename = "CRTF"))]
    Crtf,
    #[yaserde(rename = "SACP")]
    #[cfg_attr(feature = "serde", serde(rename = "SACP"))]
    Sacp,
    #[yaserde(rename = "SAPR")]
    #[cfg_attr(feature = "serde", serde(rename = "SAPR"))]
    Sapr,
    #[yaserde(rename = "LOGF")]
    #[cfg_attr(feature = "serde", serde(rename = "LOGF"))]
    Logf,
    #[yaserde(rename = "RPFL")]
    #[cfg_attr(feature = "serde", serde(rename = "RPFL"))]
    Rpfl,
    #[yaserde(rename = "CONF")]
    #[cfg_attr(feature = "serde", serde(rename = "CONF"))]
    Conf,
    #[yaserde(rename = "SPRP")]
    #[cfg_attr(feature = "serde", serde(rename = "SPRP"))]
    Sprp,
    #[yaserde(rename = "TPKG")]
    #[cfg_attr(feature = "serde", serde(rename = "TPKG"))]
    Tpkg,
    __Unknown__(String),
}

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

impl Validate for DataSetCategory19Code {}



#[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:catm.005.001.12")]

pub enum DataSetCategory20Code {
    #[yaserde(rename = "AQPR")]
    #[cfg_attr(feature = "serde", serde(rename = "AQPR"))]
    Aqpr,
    #[yaserde(rename = "APPR")]
    #[cfg_attr(feature = "serde", serde(rename = "APPR"))]
    Appr,
    #[yaserde(rename = "TXCP")]
    #[cfg_attr(feature = "serde", serde(rename = "TXCP"))]
    Txcp,
    #[yaserde(rename = "AKCP")]
    #[cfg_attr(feature = "serde", serde(rename = "AKCP"))]
    Akcp,
    #[yaserde(rename = "DLGT")]
    #[cfg_attr(feature = "serde", serde(rename = "DLGT"))]
    Dlgt,
    #[yaserde(rename = "MGTP")]
    #[cfg_attr(feature = "serde", serde(rename = "MGTP"))]
    Mgtp,
    #[yaserde(rename = "MRPR")]
    #[cfg_attr(feature = "serde", serde(rename = "MRPR"))]
    Mrpr,
    #[yaserde(rename = "SCPR")]
    #[cfg_attr(feature = "serde", serde(rename = "SCPR"))]
    Scpr,
    #[yaserde(rename = "SWPK")]
    #[cfg_attr(feature = "serde", serde(rename = "SWPK"))]
    Swpk,
    #[yaserde(rename = "STRP")]
    #[cfg_attr(feature = "serde", serde(rename = "STRP"))]
    Strp,
    #[yaserde(rename = "TRPR")]
    #[cfg_attr(feature = "serde", serde(rename = "TRPR"))]
    Trpr,
    #[yaserde(rename = "VDPR")]
    #[cfg_attr(feature = "serde", serde(rename = "VDPR"))]
    Vdpr,
    #[yaserde(rename = "PARA")]
    #[cfg_attr(feature = "serde", serde(rename = "PARA"))]
    Para,
    #[yaserde(rename = "TMSP")]
    #[cfg_attr(feature = "serde", serde(rename = "TMSP"))]
    Tmsp,
    #[yaserde(rename = "CRTF")]
    #[cfg_attr(feature = "serde", serde(rename = "CRTF"))]
    Crtf,
    #[yaserde(rename = "LOGF")]
    #[cfg_attr(feature = "serde", serde(rename = "LOGF"))]
    Logf,
    #[yaserde(rename = "CMRQ")]
    #[cfg_attr(feature = "serde", serde(rename = "CMRQ"))]
    Cmrq,
    #[yaserde(rename = "MDFL")]
    #[cfg_attr(feature = "serde", serde(rename = "MDFL"))]
    Mdfl,
    #[yaserde(rename = "CONF")]
    #[cfg_attr(feature = "serde", serde(rename = "CONF"))]
    Conf,
    #[yaserde(rename = "RPFL")]
    #[cfg_attr(feature = "serde", serde(rename = "RPFL"))]
    Rpfl,
    #[yaserde(rename = "SAPR")]
    #[cfg_attr(feature = "serde", serde(rename = "SAPR"))]
    Sapr,
    #[yaserde(rename = "SPRP")]
    #[cfg_attr(feature = "serde", serde(rename = "SPRP"))]
    Sprp,
    #[yaserde(rename = "PROB")]
    #[cfg_attr(feature = "serde", serde(rename = "PROB"))]
    Prob,
    __Unknown__(String),
}

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

impl Validate for DataSetCategory20Code {}



#[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:catm.005.001.12")]
pub struct DataSetIdentification11 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max256Text,

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

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

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

impl Validate for DataSetIdentification11 {}


#[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:catm.005.001.12")]
pub struct DateAndPlaceOfBirth1 {
    #[yaserde(rename = "BirthDt")]
    #[cfg_attr(feature = "serde", serde(rename = "BirthDt"))]
    pub birth_dt: Isodate,

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

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

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

impl Validate for DateAndPlaceOfBirth1 {}


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

impl Validate for DecimalNumber {}
#[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:catm.005.001.12")]
pub struct DeviceDisplayRequest7 {
    #[yaserde(rename = "DispOutpt")]
    #[cfg_attr(feature = "serde", serde(rename = "DispOutpt"))]
    pub disp_outpt: Vec<ActionMessage12>,
}

impl Validate for DeviceDisplayRequest7 {}


#[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:catm.005.001.12")]
pub struct DeviceInitialisationCardReaderRequest7 {
    #[yaserde(rename = "WarmRstFlg")]
    #[cfg_attr(feature = "serde", serde(rename = "WarmRstFlg"))]
    pub warm_rst_flg: TrueFalseIndicator,

    #[yaserde(rename = "ForceNtryMd")]
    #[cfg_attr(feature = "serde", serde(rename = "ForceNtryMd"))]
    pub force_ntry_md: Vec<CardDataReading8Code>,

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

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

    #[yaserde(rename = "DispOutpt")]
    #[cfg_attr(feature = "serde", serde(rename = "DispOutpt"))]
    pub disp_outpt: ActionMessage12,
}

impl Validate for DeviceInitialisationCardReaderRequest7 {}


#[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:catm.005.001.12")]
pub struct DeviceInputNotification7 {
    #[yaserde(rename = "XchgId")]
    #[cfg_attr(feature = "serde", serde(rename = "XchgId"))]
    pub xchg_id: Max35Text,

    #[yaserde(rename = "OutptCntt")]
    #[cfg_attr(feature = "serde", serde(rename = "OutptCntt"))]
    pub outpt_cntt: ActionMessage12,
}

impl Validate for DeviceInputNotification7 {}


#[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:catm.005.001.12")]
pub struct DeviceInputRequest7 {
    #[yaserde(rename = "DispOutpt")]
    #[cfg_attr(feature = "serde", serde(rename = "DispOutpt"))]
    pub disp_outpt: ActionMessage12,

    #[yaserde(rename = "InptData")]
    #[cfg_attr(feature = "serde", serde(rename = "InptData"))]
    pub inpt_data: InputData7,
}

impl Validate for DeviceInputRequest7 {}


#[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:catm.005.001.12")]
pub struct DevicePlayResourceRequest1 {
    #[yaserde(rename = "RspnMd")]
    #[cfg_attr(feature = "serde", serde(rename = "RspnMd"))]
    pub rspn_md: ResponseMode2Code,

    #[yaserde(rename = "RsrcActn")]
    #[cfg_attr(feature = "serde", serde(rename = "RsrcActn"))]
    pub rsrc_actn: ResourceAction1Code,

    #[yaserde(rename = "SoundVol")]
    #[cfg_attr(feature = "serde", serde(rename = "SoundVol"))]
    pub sound_vol: PercentageRate,

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

    #[yaserde(rename = "Rsrc")]
    #[cfg_attr(feature = "serde", serde(rename = "Rsrc"))]
    pub rsrc: ResourceContent1,

    #[yaserde(rename = "TmgSlot")]
    #[cfg_attr(feature = "serde", serde(rename = "TmgSlot"))]
    pub tmg_slot: ProcessingPosition2Code,
}

impl Validate for DevicePlayResourceRequest1 {}


#[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:catm.005.001.12")]
pub struct DevicePoweroffCardReaderRequest7 {
    #[yaserde(rename = "PwrOffMaxWtgTm")]
    #[cfg_attr(feature = "serde", serde(rename = "PwrOffMaxWtgTm"))]
    pub pwr_off_max_wtg_tm: Number,

    #[yaserde(rename = "DispOutpt")]
    #[cfg_attr(feature = "serde", serde(rename = "DispOutpt"))]
    pub disp_outpt: ActionMessage12,
}

impl Validate for DevicePoweroffCardReaderRequest7 {}


#[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:catm.005.001.12")]
pub struct DevicePrintRequest7 {
    #[yaserde(rename = "DocQlfr")]
    #[cfg_attr(feature = "serde", serde(rename = "DocQlfr"))]
    pub doc_qlfr: DocumentType7Code,

    #[yaserde(rename = "RspnMd")]
    #[cfg_attr(feature = "serde", serde(rename = "RspnMd"))]
    pub rspn_md: ResponseMode2Code,

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

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

    #[yaserde(rename = "OutptCntt")]
    #[cfg_attr(feature = "serde", serde(rename = "OutptCntt"))]
    pub outpt_cntt: ActionMessage12,
}

impl Validate for DevicePrintRequest7 {}


#[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:catm.005.001.12")]
pub struct DeviceRequest9 {
    #[yaserde(rename = "Envt")]
    #[cfg_attr(feature = "serde", serde(rename = "Envt"))]
    pub envt: CardPaymentEnvironment82,

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

    #[yaserde(rename = "SvcCntt")]
    #[cfg_attr(feature = "serde", serde(rename = "SvcCntt"))]
    pub svc_cntt: RetailerService8Code,

    #[yaserde(rename = "DispReq")]
    #[cfg_attr(feature = "serde", serde(rename = "DispReq"))]
    pub disp_req: DeviceDisplayRequest7,

    #[yaserde(rename = "InptReq")]
    #[cfg_attr(feature = "serde", serde(rename = "InptReq"))]
    pub inpt_req: DeviceInputRequest7,

    #[yaserde(rename = "PrtReq")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtReq"))]
    pub prt_req: DevicePrintRequest7,

    #[yaserde(rename = "PlayRsrcReq")]
    #[cfg_attr(feature = "serde", serde(rename = "PlayRsrcReq"))]
    pub play_rsrc_req: DevicePlayResourceRequest1,

    #[yaserde(rename = "ScrInptReq")]
    #[cfg_attr(feature = "serde", serde(rename = "ScrInptReq"))]
    pub scr_inpt_req: DeviceSecureInputRequest6,

    #[yaserde(rename = "InitlstnCardRdrReq")]
    #[cfg_attr(feature = "serde", serde(rename = "InitlstnCardRdrReq"))]
    pub initlstn_card_rdr_req: DeviceInitialisationCardReaderRequest7,

    #[yaserde(rename = "CardRdrAPDUReq")]
    #[cfg_attr(feature = "serde", serde(rename = "CardRdrAPDUReq"))]
    pub card_rdr_apdu_req: DeviceSendApplicationProtocolDataUnitCardReaderRequest1,

    #[yaserde(rename = "PwrOffCardRdrReq")]
    #[cfg_attr(feature = "serde", serde(rename = "PwrOffCardRdrReq"))]
    pub pwr_off_card_rdr_req: DevicePoweroffCardReaderRequest7,

    #[yaserde(rename = "TrnsmssnReq")]
    #[cfg_attr(feature = "serde", serde(rename = "TrnsmssnReq"))]
    pub trnsmssn_req: DeviceTransmitMessageRequest2,

    #[yaserde(rename = "InptNtfctn")]
    #[cfg_attr(feature = "serde", serde(rename = "InptNtfctn"))]
    pub inpt_ntfctn: DeviceInputNotification7,

    #[yaserde(rename = "SplmtryData")]
    #[cfg_attr(feature = "serde", serde(rename = "SplmtryData"))]
    pub splmtry_data: Vec<SupplementaryData1>,
}

impl Validate for DeviceRequest9 {}


#[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:catm.005.001.12")]
pub struct DeviceSecureInputRequest6 {
    #[yaserde(rename = "PINReqTp")]
    #[cfg_attr(feature = "serde", serde(rename = "PINReqTp"))]
    pub pin_req_tp: PinrequestType1Code,

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

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

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

    #[yaserde(rename = "CrdhldrPIN")]
    #[cfg_attr(feature = "serde", serde(rename = "CrdhldrPIN"))]
    pub crdhldr_pin: OnLinePIN11,
}

impl Validate for DeviceSecureInputRequest6 {}


#[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:catm.005.001.12")]
pub struct DeviceSendApplicationProtocolDataUnitCardReaderRequest1 {
    #[yaserde(rename = "Clss")]
    #[cfg_attr(feature = "serde", serde(rename = "Clss"))]
    pub clss: Min1Max256Binary,

    #[yaserde(rename = "Instr")]
    #[cfg_attr(feature = "serde", serde(rename = "Instr"))]
    pub instr: Min1Max256Binary,

    #[yaserde(rename = "Param1")]
    #[cfg_attr(feature = "serde", serde(rename = "Param1"))]
    pub param_1: Min1Max256Binary,

    #[yaserde(rename = "Param2")]
    #[cfg_attr(feature = "serde", serde(rename = "Param2"))]
    pub param_2: Min1Max256Binary,

    #[yaserde(rename = "Data")]
    #[cfg_attr(feature = "serde", serde(rename = "Data"))]
    pub data: Min1Max256Binary,

    #[yaserde(rename = "XpctdLngth")]
    #[cfg_attr(feature = "serde", serde(rename = "XpctdLngth"))]
    pub xpctd_lngth: Min1Max256Binary,
}

impl Validate for DeviceSendApplicationProtocolDataUnitCardReaderRequest1 {}


#[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:catm.005.001.12")]
pub struct DeviceTransmitMessageRequest2 {
    #[yaserde(rename = "DstnAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "DstnAdr"))]
    pub dstn_adr: NetworkParameters7,

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

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

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

impl Validate for DeviceTransmitMessageRequest2 {}


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

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

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

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

impl Validate for DigestedData6 {}


#[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:catm.005.001.12")]
pub struct DirectDebitContext1 {
    #[yaserde(rename = "Dbtr")]
    #[cfg_attr(feature = "serde", serde(rename = "Dbtr"))]
    pub dbtr: PartyIdentification272,

    #[yaserde(rename = "DbtrAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "DbtrAcct"))]
    pub dbtr_acct: CashAccount40,

    #[yaserde(rename = "PrtctdDbtrAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtctdDbtrAcct"))]
    pub prtctd_dbtr_acct: ContentInformationType39,

    #[yaserde(rename = "Cdtr")]
    #[cfg_attr(feature = "serde", serde(rename = "Cdtr"))]
    pub cdtr: PartyIdentification272,

    #[yaserde(rename = "CdtrAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtrAcct"))]
    pub cdtr_acct: CashAccount40,

    #[yaserde(rename = "PrtctdCdtrAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtctdCdtrAcct"))]
    pub prtctd_cdtr_acct: ContentInformationType39,

    #[yaserde(rename = "MndtRltdInf")]
    #[cfg_attr(feature = "serde", serde(rename = "MndtRltdInf"))]
    pub mndt_rltd_inf: MandateRelatedInformation17,
}

impl Validate for DirectDebitContext1 {}


#[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:catm.005.001.12")]
pub struct DisplayCapabilities7 {
    #[yaserde(rename = "Dstn")]
    #[cfg_attr(feature = "serde", serde(rename = "Dstn"))]
    pub dstn: Vec<UserInterface9Code>,

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

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

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

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

impl Validate for DisplayCapabilities7 {}


#[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:catm.005.001.12")]
pub struct Document {
    #[yaserde(rename = "MntncDlgtnReq")]
    #[cfg_attr(feature = "serde", serde(rename = "MntncDlgtnReq"))]
    pub mntnc_dlgtn_req: MaintenanceDelegationRequestV12,
}

impl Validate for Document {}


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

pub enum DocumentType7Code {
    #[yaserde(rename = "JNRL")]
    #[cfg_attr(feature = "serde", serde(rename = "JNRL"))]
    Jnrl,
    #[yaserde(rename = "CRCP")]
    #[cfg_attr(feature = "serde", serde(rename = "CRCP"))]
    Crcp,
    #[yaserde(rename = "HRCP")]
    #[cfg_attr(feature = "serde", serde(rename = "HRCP"))]
    Hrcp,
    #[yaserde(rename = "SRCP")]
    #[cfg_attr(feature = "serde", serde(rename = "SRCP"))]
    Srcp,
    #[yaserde(rename = "RPIN")]
    #[cfg_attr(feature = "serde", serde(rename = "RPIN"))]
    Rpin,
    #[yaserde(rename = "VCHR")]
    #[cfg_attr(feature = "serde", serde(rename = "VCHR"))]
    Vchr,
    __Unknown__(String),
}

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

impl Validate for DocumentType7Code {}



#[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:catm.005.001.12")]
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:catm.005.001.12")]
pub struct EncryptedContent7 {
    #[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: AlgorithmIdentification32,

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

impl Validate for EncryptedContent7 {}


#[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:catm.005.001.12")]

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

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

impl Validate for EncryptionFormat2Code {}



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

    #[yaserde(rename = "OrgtrInf")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgtrInf"))]
    pub orgtr_inf: OriginatorInformation1,

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

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

impl Validate for EnvelopedData11 {}


#[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:catm.005.001.12")]
pub struct ErrorAction5 {
    #[yaserde(rename = "ActnRslt")]
    #[cfg_attr(feature = "serde", serde(rename = "ActnRslt"))]
    pub actn_rslt: Vec<TerminalManagementActionResult5Code>,

    #[yaserde(rename = "ActnToPrc")]
    #[cfg_attr(feature = "serde", serde(rename = "ActnToPrc"))]
    pub actn_to_prc: TerminalManagementErrorAction2Code,
}

impl Validate for ErrorAction5 {}


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

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

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

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

impl Validate for Exact4NumericText {}
#[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:catm.005.001.12")]
pub struct ExchangeConfiguration10 {
    #[yaserde(rename = "XchgPlcy")]
    #[cfg_attr(feature = "serde", serde(rename = "XchgPlcy"))]
    pub xchg_plcy: Vec<ExchangePolicy2Code>,

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

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

    #[yaserde(rename = "ReTry")]
    #[cfg_attr(feature = "serde", serde(rename = "ReTry"))]
    pub re_try: ProcessRetry3,

    #[yaserde(rename = "TmCond")]
    #[cfg_attr(feature = "serde", serde(rename = "TmCond"))]
    pub tm_cond: ProcessTiming6,

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

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

impl Validate for ExchangeConfiguration10 {}


#[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:catm.005.001.12")]
pub struct ExchangeConfiguration9 {
    #[yaserde(rename = "XchgPlcy")]
    #[cfg_attr(feature = "serde", serde(rename = "XchgPlcy"))]
    pub xchg_plcy: Vec<ExchangePolicy2Code>,

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

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

    #[yaserde(rename = "ReTry")]
    #[cfg_attr(feature = "serde", serde(rename = "ReTry"))]
    pub re_try: ProcessRetry3,

    #[yaserde(rename = "TmCond")]
    #[cfg_attr(feature = "serde", serde(rename = "TmCond"))]
    pub tm_cond: ProcessTiming6,
}

impl Validate for ExchangeConfiguration9 {}


#[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:catm.005.001.12")]

pub enum ExchangePolicy2Code {
    #[yaserde(rename = "ONDM")]
    #[cfg_attr(feature = "serde", serde(rename = "ONDM"))]
    Ondm,
    #[yaserde(rename = "IMMD")]
    #[cfg_attr(feature = "serde", serde(rename = "IMMD"))]
    Immd,
    #[yaserde(rename = "ASAP")]
    #[cfg_attr(feature = "serde", serde(rename = "ASAP"))]
    Asap,
    #[yaserde(rename = "AGRP")]
    #[cfg_attr(feature = "serde", serde(rename = "AGRP"))]
    Agrp,
    #[yaserde(rename = "NBLT")]
    #[cfg_attr(feature = "serde", serde(rename = "NBLT"))]
    Nblt,
    #[yaserde(rename = "TTLT")]
    #[cfg_attr(feature = "serde", serde(rename = "TTLT"))]
    Ttlt,
    #[yaserde(rename = "CYCL")]
    #[cfg_attr(feature = "serde", serde(rename = "CYCL"))]
    Cycl,
    #[yaserde(rename = "NONE")]
    #[cfg_attr(feature = "serde", serde(rename = "NONE"))]
    None,
    #[yaserde(rename = "BLCK")]
    #[cfg_attr(feature = "serde", serde(rename = "BLCK"))]
    Blck,
    __Unknown__(String),
}

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

impl Validate for ExchangePolicy2Code {}



#[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:catm.005.001.12")]

pub enum Exemption1Code {
    #[yaserde(rename = "LOWA")]
    #[cfg_attr(feature = "serde", serde(rename = "LOWA"))]
    Lowa,
    #[yaserde(rename = "MINT")]
    #[cfg_attr(feature = "serde", serde(rename = "MINT"))]
    Mint,
    #[yaserde(rename = "RECP")]
    #[cfg_attr(feature = "serde", serde(rename = "RECP"))]
    Recp,
    #[yaserde(rename = "SCPE")]
    #[cfg_attr(feature = "serde", serde(rename = "SCPE"))]
    Scpe,
    #[yaserde(rename = "SCAD")]
    #[cfg_attr(feature = "serde", serde(rename = "SCAD"))]
    Scad,
    #[yaserde(rename = "TRAE")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAE"))]
    Trae,
    #[yaserde(rename = "PKGE")]
    #[cfg_attr(feature = "serde", serde(rename = "PKGE"))]
    Pkge,
    #[yaserde(rename = "TMBE")]
    #[cfg_attr(feature = "serde", serde(rename = "TMBE"))]
    Tmbe,
    __Unknown__(String),
}

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

impl Validate for Exemption1Code {}



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

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

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

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

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

impl Validate for ExternalProxyAccountType1Code {
    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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.005.001.12")]
pub struct ExternallyDefinedData5 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max1025Text,

    #[yaserde(rename = "Val")]
    #[cfg_attr(feature = "serde", serde(rename = "Val"))]
    pub val: Max100KBinary,

    #[yaserde(rename = "PrtctdVal")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtctdVal"))]
    pub prtctd_val: ContentInformationType39,

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

impl Validate for ExternallyDefinedData5 {}


#[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:catm.005.001.12")]

pub enum FinancialCapture1Code {
    #[yaserde(rename = "AUTH")]
    #[cfg_attr(feature = "serde", serde(rename = "AUTH"))]
    Auth,
    #[yaserde(rename = "COMP")]
    #[cfg_attr(feature = "serde", serde(rename = "COMP"))]
    Comp,
    #[yaserde(rename = "BTCH")]
    #[cfg_attr(feature = "serde", serde(rename = "BTCH"))]
    Btch,
    __Unknown__(String),
}

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

impl Validate for FinancialCapture1Code {}



#[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:catm.005.001.12")]
pub struct GenericAccountIdentification1 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max34Text,

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

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

impl Validate for GenericAccountIdentification1 {}


#[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:catm.005.001.12")]
pub struct GenericIdentification176 {
    #[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: PartyType33Code,

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

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


#[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:catm.005.001.12")]
pub struct GenericIdentification177 {
    #[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: PartyType33Code,

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

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

    #[yaserde(rename = "RmotAccs")]
    #[cfg_attr(feature = "serde", serde(rename = "RmotAccs"))]
    pub rmot_accs: NetworkParameters7,

    #[yaserde(rename = "Glctn")]
    #[cfg_attr(feature = "serde", serde(rename = "Glctn"))]
    pub glctn: Geolocation1,
}

impl Validate for GenericIdentification177 {}


#[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:catm.005.001.12")]
pub struct GenericIdentification186 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max256Text,

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

impl Validate for GenericIdentification186 {}


#[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:catm.005.001.12")]
pub struct GenericIdentification192 {
    #[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: PartyType35Code,

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

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

impl Validate for GenericIdentification192 {}


#[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:catm.005.001.12")]
pub struct GenericIdentification30 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Exact4AlphaNumericText,

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

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

impl Validate for GenericIdentification30 {}


#[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:catm.005.001.12")]
pub struct GenericIdentification4 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

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

impl Validate for GenericIdentification4 {}


#[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:catm.005.001.12")]
pub struct GenericIdentification48 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

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

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

impl Validate for GenericIdentification48 {}


#[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:catm.005.001.12")]
pub struct GenericInformation1 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max70Text,

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

impl Validate for GenericInformation1 {}


#[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:catm.005.001.12")]
pub struct GenericOrganisationIdentification3 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max256Text,

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

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

impl Validate for GenericOrganisationIdentification3 {}


#[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:catm.005.001.12")]
pub struct GenericPersonIdentification2 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max256Text,

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

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

impl Validate for GenericPersonIdentification2 {}


#[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:catm.005.001.12")]
pub struct Geolocation1 {
    #[yaserde(rename = "GeogcCordints")]
    #[cfg_attr(feature = "serde", serde(rename = "GeogcCordints"))]
    pub geogc_cordints: GeolocationGeographicCoordinates1,

    #[yaserde(rename = "UTMCordints")]
    #[cfg_attr(feature = "serde", serde(rename = "UTMCordints"))]
    pub utm_cordints: GeolocationUTMCoordinates1,
}

impl Validate for Geolocation1 {}


#[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:catm.005.001.12")]
pub struct GeolocationGeographicCoordinates1 {
    #[yaserde(rename = "Lat")]
    #[cfg_attr(feature = "serde", serde(rename = "Lat"))]
    pub lat: Max35Text,

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

impl Validate for GeolocationGeographicCoordinates1 {}


#[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:catm.005.001.12")]
pub struct GeolocationUTMCoordinates1 {
    #[yaserde(rename = "UTMZone")]
    #[cfg_attr(feature = "serde", serde(rename = "UTMZone"))]
    pub utm_zone: Max35Text,

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

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

impl Validate for GeolocationUTMCoordinates1 {}


#[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:catm.005.001.12")]
pub struct HostCommunicationParameter8 {
    #[yaserde(rename = "ActnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ActnTp"))]
    pub actn_tp: TerminalManagementAction3Code,

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

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

    #[yaserde(rename = "Key")]
    #[cfg_attr(feature = "serde", serde(rename = "Key"))]
    pub key: Vec<CryptographicKey19>,

    #[yaserde(rename = "NtwkSvcPrvdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NtwkSvcPrvdr"))]
    pub ntwk_svc_prvdr: NetworkParameters7,

    #[yaserde(rename = "PhysIntrfc")]
    #[cfg_attr(feature = "serde", serde(rename = "PhysIntrfc"))]
    pub phys_intrfc: PhysicalInterfaceParameter1,

    #[yaserde(rename = "XchgMd")]
    #[cfg_attr(feature = "serde", serde(rename = "XchgMd"))]
    pub xchg_md: CapeexchangeMode1Code,

    #[yaserde(rename = "NcodgMd")]
    #[cfg_attr(feature = "serde", serde(rename = "NcodgMd"))]
    pub ncodg_md: CapeencodingMode1Code,
}

impl Validate for HostCommunicationParameter8 {}


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

impl Validate for Iban2007Identifier {}
#[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 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 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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.005.001.12")]

pub enum InformationQualify1Code {
    #[yaserde(rename = "CUSA")]
    #[cfg_attr(feature = "serde", serde(rename = "CUSA"))]
    Cusa,
    #[yaserde(rename = "DISP")]
    #[cfg_attr(feature = "serde", serde(rename = "DISP"))]
    Disp,
    #[yaserde(rename = "DOCT")]
    #[cfg_attr(feature = "serde", serde(rename = "DOCT"))]
    Doct,
    #[yaserde(rename = "ERRO")]
    #[cfg_attr(feature = "serde", serde(rename = "ERRO"))]
    Erro,
    #[yaserde(rename = "INPT")]
    #[cfg_attr(feature = "serde", serde(rename = "INPT"))]
    Inpt,
    #[yaserde(rename = "POIR")]
    #[cfg_attr(feature = "serde", serde(rename = "POIR"))]
    Poir,
    #[yaserde(rename = "RCPT")]
    #[cfg_attr(feature = "serde", serde(rename = "RCPT"))]
    Rcpt,
    #[yaserde(rename = "SOND")]
    #[cfg_attr(feature = "serde", serde(rename = "SOND"))]
    Sond,
    #[yaserde(rename = "STAT")]
    #[cfg_attr(feature = "serde", serde(rename = "STAT"))]
    Stat,
    #[yaserde(rename = "VCHR")]
    #[cfg_attr(feature = "serde", serde(rename = "VCHR"))]
    Vchr,
    __Unknown__(String),
}

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

impl Validate for InformationQualify1Code {}



#[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:catm.005.001.12")]

pub enum InputCommand1Code {
    #[yaserde(rename = "DCSG")]
    #[cfg_attr(feature = "serde", serde(rename = "DCSG"))]
    Dcsg,
    #[yaserde(rename = "DGSG")]
    #[cfg_attr(feature = "serde", serde(rename = "DGSG"))]
    Dgsg,
    #[yaserde(rename = "GAKY")]
    #[cfg_attr(feature = "serde", serde(rename = "GAKY"))]
    Gaky,
    #[yaserde(rename = "GCNF")]
    #[cfg_attr(feature = "serde", serde(rename = "GCNF"))]
    Gcnf,
    #[yaserde(rename = "GFKY")]
    #[cfg_attr(feature = "serde", serde(rename = "GFKY"))]
    Gfky,
    #[yaserde(rename = "GMNE")]
    #[cfg_attr(feature = "serde", serde(rename = "GMNE"))]
    Gmne,
    #[yaserde(rename = "PSWD")]
    #[cfg_attr(feature = "serde", serde(rename = "PSWD"))]
    Pswd,
    #[yaserde(rename = "SITE")]
    #[cfg_attr(feature = "serde", serde(rename = "SITE"))]
    Site,
    #[yaserde(rename = "TXSG")]
    #[cfg_attr(feature = "serde", serde(rename = "TXSG"))]
    Txsg,
    #[yaserde(rename = "HTML")]
    #[cfg_attr(feature = "serde", serde(rename = "HTML"))]
    Html,
    #[yaserde(rename = "SIGN")]
    #[cfg_attr(feature = "serde", serde(rename = "SIGN"))]
    Sign,
    __Unknown__(String),
}

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

impl Validate for InputCommand1Code {}



#[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:catm.005.001.12")]
pub struct InputData7 {
    #[yaserde(rename = "DvcTp")]
    #[cfg_attr(feature = "serde", serde(rename = "DvcTp"))]
    pub dvc_tp: SaleCapabilities2Code,

    #[yaserde(rename = "InfQlfr")]
    #[cfg_attr(feature = "serde", serde(rename = "InfQlfr"))]
    pub inf_qlfr: InformationQualify1Code,

    #[yaserde(rename = "InptCmd")]
    #[cfg_attr(feature = "serde", serde(rename = "InptCmd"))]
    pub inpt_cmd: InputCommand1Code,

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

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

    #[yaserde(rename = "InptTxt")]
    #[cfg_attr(feature = "serde", serde(rename = "InptTxt"))]
    pub inpt_txt: ActionMessage12,

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

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

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

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

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

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

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

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

impl Validate for InputData7 {}


#[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:catm.005.001.12")]
pub struct IssuerAndSerialNumber2 {
    #[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: Max500Binary,
}

impl Validate for IssuerAndSerialNumber2 {}


#[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:catm.005.001.12")]
pub struct Kek9 {
    #[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: Kekidentifier7,

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

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

impl Validate for Kek9 {}


#[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:catm.005.001.12")]
pub struct Kekidentifier7 {
    #[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: Max500Binary,
}

impl Validate for Kekidentifier7 {}


#[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:catm.005.001.12")]
pub struct KeyTransport10 {
    #[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: Recipient13Choice,

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

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

impl Validate for KeyTransport10 {}


#[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:catm.005.001.12")]

pub enum KeyUsage1Code {
    #[yaserde(rename = "ENCR")]
    #[cfg_attr(feature = "serde", serde(rename = "ENCR"))]
    Encr,
    #[yaserde(rename = "DCPT")]
    #[cfg_attr(feature = "serde", serde(rename = "DCPT"))]
    Dcpt,
    #[yaserde(rename = "DENC")]
    #[cfg_attr(feature = "serde", serde(rename = "DENC"))]
    Denc,
    #[yaserde(rename = "DDEC")]
    #[cfg_attr(feature = "serde", serde(rename = "DDEC"))]
    Ddec,
    #[yaserde(rename = "TRNI")]
    #[cfg_attr(feature = "serde", serde(rename = "TRNI"))]
    Trni,
    #[yaserde(rename = "TRNX")]
    #[cfg_attr(feature = "serde", serde(rename = "TRNX"))]
    Trnx,
    #[yaserde(rename = "MACG")]
    #[cfg_attr(feature = "serde", serde(rename = "MACG"))]
    Macg,
    #[yaserde(rename = "MACV")]
    #[cfg_attr(feature = "serde", serde(rename = "MACV"))]
    Macv,
    #[yaserde(rename = "SIGG")]
    #[cfg_attr(feature = "serde", serde(rename = "SIGG"))]
    Sigg,
    #[yaserde(rename = "SUGV")]
    #[cfg_attr(feature = "serde", serde(rename = "SUGV"))]
    Sugv,
    #[yaserde(rename = "PINE")]
    #[cfg_attr(feature = "serde", serde(rename = "PINE"))]
    Pine,
    #[yaserde(rename = "PIND")]
    #[cfg_attr(feature = "serde", serde(rename = "PIND"))]
    Pind,
    #[yaserde(rename = "PINV")]
    #[cfg_attr(feature = "serde", serde(rename = "PINV"))]
    Pinv,
    #[yaserde(rename = "KEYG")]
    #[cfg_attr(feature = "serde", serde(rename = "KEYG"))]
    Keyg,
    #[yaserde(rename = "KEYI")]
    #[cfg_attr(feature = "serde", serde(rename = "KEYI"))]
    Keyi,
    #[yaserde(rename = "KEYX")]
    #[cfg_attr(feature = "serde", serde(rename = "KEYX"))]
    Keyx,
    #[yaserde(rename = "KEYD")]
    #[cfg_attr(feature = "serde", serde(rename = "KEYD"))]
    Keyd,
    __Unknown__(String),
}

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

impl Validate for KeyUsage1Code {}



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

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

impl Validate for LanguageCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.005.001.12")]
pub struct LocalDateTime1 {
    #[yaserde(rename = "FrDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "FrDtTm"))]
    pub fr_dt_tm: IsodateTime,

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

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

impl Validate for LocalDateTime1 {}


#[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:catm.005.001.12")]

pub enum LocationCategory3Code {
    #[yaserde(rename = "INDR")]
    #[cfg_attr(feature = "serde", serde(rename = "INDR"))]
    Indr,
    #[yaserde(rename = "IPMP")]
    #[cfg_attr(feature = "serde", serde(rename = "IPMP"))]
    Ipmp,
    #[yaserde(rename = "MPOI")]
    #[cfg_attr(feature = "serde", serde(rename = "MPOI"))]
    Mpoi,
    #[yaserde(rename = "MPMP")]
    #[cfg_attr(feature = "serde", serde(rename = "MPMP"))]
    Mpmp,
    #[yaserde(rename = "MSLE")]
    #[cfg_attr(feature = "serde", serde(rename = "MSLE"))]
    Msle,
    #[yaserde(rename = "SSLE")]
    #[cfg_attr(feature = "serde", serde(rename = "SSLE"))]
    Ssle,
    #[yaserde(rename = "VNDG")]
    #[cfg_attr(feature = "serde", serde(rename = "VNDG"))]
    Vndg,
    __Unknown__(String),
}

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

impl Validate for LocationCategory3Code {}



#[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:catm.005.001.12")]

pub enum LocationCategory4Code {
    #[yaserde(rename = "ABRD")]
    #[cfg_attr(feature = "serde", serde(rename = "ABRD"))]
    Abrd,
    #[yaserde(rename = "NMDC")]
    #[cfg_attr(feature = "serde", serde(rename = "NMDC"))]
    Nmdc,
    #[yaserde(rename = "FIXD")]
    #[cfg_attr(feature = "serde", serde(rename = "FIXD"))]
    Fixd,
    #[yaserde(rename = "VIRT")]
    #[cfg_attr(feature = "serde", serde(rename = "VIRT"))]
    Virt,
    __Unknown__(String),
}

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

impl Validate for LocationCategory4Code {}



#[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:catm.005.001.12")]
pub struct LoyaltyAccount3 {
    #[yaserde(rename = "LltyId")]
    #[cfg_attr(feature = "serde", serde(rename = "LltyId"))]
    pub llty_id: Max35Text,

    #[yaserde(rename = "NtryMd")]
    #[cfg_attr(feature = "serde", serde(rename = "NtryMd"))]
    pub ntry_md: CardDataReading8Code,

    #[yaserde(rename = "IdTp")]
    #[cfg_attr(feature = "serde", serde(rename = "IdTp"))]
    pub id_tp: CardIdentificationType1Code,

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

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

    #[yaserde(rename = "OwnrNm")]
    #[cfg_attr(feature = "serde", serde(rename = "OwnrNm"))]
    pub ownr_nm: Max45Text,

    #[yaserde(rename = "Unit")]
    #[cfg_attr(feature = "serde", serde(rename = "Unit"))]
    pub unit: AmountUnit1Code,

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

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

impl Validate for LoyaltyAccount3 {}


#[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:catm.005.001.12")]

pub enum LoyaltyHandling1Code {
    #[yaserde(rename = "ALLO")]
    #[cfg_attr(feature = "serde", serde(rename = "ALLO"))]
    Allo,
    #[yaserde(rename = "DENY")]
    #[cfg_attr(feature = "serde", serde(rename = "DENY"))]
    Deny,
    #[yaserde(rename = "PRCS")]
    #[cfg_attr(feature = "serde", serde(rename = "PRCS"))]
    Prcs,
    #[yaserde(rename = "PROP")]
    #[cfg_attr(feature = "serde", serde(rename = "PROP"))]
    Prop,
    #[yaserde(rename = "REQU")]
    #[cfg_attr(feature = "serde", serde(rename = "REQU"))]
    Requ,
    __Unknown__(String),
}

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

impl Validate for LoyaltyHandling1Code {}



#[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:catm.005.001.12")]
pub struct MaintenanceDelegateAction11 {
    #[yaserde(rename = "PrdcActn")]
    #[cfg_attr(feature = "serde", serde(rename = "PrdcActn"))]
    pub prdc_actn: TrueFalseIndicator,

    #[yaserde(rename = "TMRmotAccs")]
    #[cfg_attr(feature = "serde", serde(rename = "TMRmotAccs"))]
    pub tm_rmot_accs: NetworkParameters7,

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

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

    #[yaserde(rename = "DataSetId")]
    #[cfg_attr(feature = "serde", serde(rename = "DataSetId"))]
    pub data_set_id: DataSetIdentification11,

    #[yaserde(rename = "ReTry")]
    #[cfg_attr(feature = "serde", serde(rename = "ReTry"))]
    pub re_try: ProcessRetry3,

    #[yaserde(rename = "AddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
    pub addtl_inf: Vec<Max3000Binary>,

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

impl Validate for MaintenanceDelegateAction11 {}


#[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:catm.005.001.12")]
pub struct MaintenanceDelegation20 {
    #[yaserde(rename = "DlgtnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "DlgtnTp"))]
    pub dlgtn_tp: TerminalManagementAction3Code,

    #[yaserde(rename = "MntncSvc")]
    #[cfg_attr(feature = "serde", serde(rename = "MntncSvc"))]
    pub mntnc_svc: Vec<DataSetCategory19Code>,

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

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

    #[yaserde(rename = "DlgtdActn")]
    #[cfg_attr(feature = "serde", serde(rename = "DlgtdActn"))]
    pub dlgtd_actn: MaintenanceDelegateAction11,

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

    #[yaserde(rename = "DlgtnScpDef")]
    #[cfg_attr(feature = "serde", serde(rename = "DlgtnScpDef"))]
    pub dlgtn_scp_def: Max3000Binary,

    #[yaserde(rename = "Cert")]
    #[cfg_attr(feature = "serde", serde(rename = "Cert"))]
    pub cert: Vec<Max10KBinary>,

    #[yaserde(rename = "POIIdAssoctn")]
    #[cfg_attr(feature = "serde", serde(rename = "POIIdAssoctn"))]
    pub poi_id_assoctn: Vec<MaintenanceIdentificationAssociation1>,

    #[yaserde(rename = "SmmtrcKey")]
    #[cfg_attr(feature = "serde", serde(rename = "SmmtrcKey"))]
    pub smmtrc_key: Vec<CryptographicKey19>,

    #[yaserde(rename = "ParamDataSet")]
    #[cfg_attr(feature = "serde", serde(rename = "ParamDataSet"))]
    pub param_data_set: AcceptorConfigurationDataSet7,
}

impl Validate for MaintenanceDelegation20 {}


#[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:catm.005.001.12")]
pub struct MaintenanceDelegationRequest12 {
    #[yaserde(rename = "TMId")]
    #[cfg_attr(feature = "serde", serde(rename = "TMId"))]
    pub tm_id: GenericIdentification176,

    #[yaserde(rename = "MstrTMId")]
    #[cfg_attr(feature = "serde", serde(rename = "MstrTMId"))]
    pub mstr_tm_id: GenericIdentification176,

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

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

    #[yaserde(rename = "ReqdDlgtn")]
    #[cfg_attr(feature = "serde", serde(rename = "ReqdDlgtn"))]
    pub reqd_dlgtn: Vec<MaintenanceDelegation20>,
}

impl Validate for MaintenanceDelegationRequest12 {}


#[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:catm.005.001.12")]
pub struct MaintenanceDelegationRequestV12 {
    #[yaserde(rename = "Hdr")]
    #[cfg_attr(feature = "serde", serde(rename = "Hdr"))]
    pub hdr: Tmsheader1,

    #[yaserde(rename = "MntncDlgtnReq")]
    #[cfg_attr(feature = "serde", serde(rename = "MntncDlgtnReq"))]
    pub mntnc_dlgtn_req: MaintenanceDelegationRequest12,

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

impl Validate for MaintenanceDelegationRequestV12 {}


#[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:catm.005.001.12")]
pub struct MaintenanceIdentificationAssociation1 {
    #[yaserde(rename = "MstrTMId")]
    #[cfg_attr(feature = "serde", serde(rename = "MstrTMId"))]
    pub mstr_tm_id: Max35Text,

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

impl Validate for MaintenanceIdentificationAssociation1 {}


#[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:catm.005.001.12")]
pub struct MandateRelatedInformation17 {
    #[yaserde(rename = "MndtId")]
    #[cfg_attr(feature = "serde", serde(rename = "MndtId"))]
    pub mndt_id: Max35Text,

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

    #[yaserde(rename = "MndtImg")]
    #[cfg_attr(feature = "serde", serde(rename = "MndtImg"))]
    pub mndt_img: Max2MBBinary,

    #[yaserde(rename = "PrtctdMndtImg")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtctdMndtImg"))]
    pub prtctd_mndt_img: ContentInformationType39,
}

impl Validate for MandateRelatedInformation17 {}


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Validate for Max9NumericText {}
#[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:catm.005.001.12")]
pub struct MemoryCharacteristics1 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

    #[yaserde(rename = "TtlSz")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlSz"))]
    pub ttl_sz: DecimalNumber,

    #[yaserde(rename = "FreeSz")]
    #[cfg_attr(feature = "serde", serde(rename = "FreeSz"))]
    pub free_sz: DecimalNumber,

    #[yaserde(rename = "Unit")]
    #[cfg_attr(feature = "serde", serde(rename = "Unit"))]
    pub unit: MemoryUnit1Code,
}

impl Validate for MemoryCharacteristics1 {}


#[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:catm.005.001.12")]

pub enum MemoryUnit1Code {
    #[yaserde(rename = "BYTE")]
    #[cfg_attr(feature = "serde", serde(rename = "BYTE"))]
    Byte,
    #[yaserde(rename = "EXAB")]
    #[cfg_attr(feature = "serde", serde(rename = "EXAB"))]
    Exab,
    #[yaserde(rename = "GIGA")]
    #[cfg_attr(feature = "serde", serde(rename = "GIGA"))]
    Giga,
    #[yaserde(rename = "KILO")]
    #[cfg_attr(feature = "serde", serde(rename = "KILO"))]
    Kilo,
    #[yaserde(rename = "MEGA")]
    #[cfg_attr(feature = "serde", serde(rename = "MEGA"))]
    Mega,
    #[yaserde(rename = "PETA")]
    #[cfg_attr(feature = "serde", serde(rename = "PETA"))]
    Peta,
    #[yaserde(rename = "TERA")]
    #[cfg_attr(feature = "serde", serde(rename = "TERA"))]
    Tera,
    __Unknown__(String),
}

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

impl Validate for MemoryUnit1Code {}



#[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:catm.005.001.12")]
pub struct MerchantConfigurationParameters6 {
    #[yaserde(rename = "ActnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ActnTp"))]
    pub actn_tp: TerminalManagementAction3Code,

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

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

    #[yaserde(rename = "ParamFrmtIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "ParamFrmtIdr"))]
    pub param_frmt_idr: Max8Text,

    #[yaserde(rename = "Prxy")]
    #[cfg_attr(feature = "serde", serde(rename = "Prxy"))]
    pub prxy: NetworkParameters8,

    #[yaserde(rename = "OthrParamsLngth")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrParamsLngth"))]
    pub othr_params_lngth: PositiveNumber,

    #[yaserde(rename = "OffsetStart")]
    #[cfg_attr(feature = "serde", serde(rename = "OffsetStart"))]
    pub offset_start: PositiveNumber,

    #[yaserde(rename = "OffsetEnd")]
    #[cfg_attr(feature = "serde", serde(rename = "OffsetEnd"))]
    pub offset_end: PositiveNumber,

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

impl Validate for MerchantConfigurationParameters6 {}


#[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:catm.005.001.12")]
pub struct MerchantToken2 {
    #[yaserde(rename = "Tkn")]
    #[cfg_attr(feature = "serde", serde(rename = "Tkn"))]
    pub tkn: Max35Text,

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

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

    #[yaserde(rename = "TknRqstr")]
    #[cfg_attr(feature = "serde", serde(rename = "TknRqstr"))]
    pub tkn_rqstr: PaymentTokenIdentifiers1,

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

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

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

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

impl Validate for MerchantToken2 {}


#[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:catm.005.001.12")]

pub enum MessageFunction47Code {
    #[yaserde(rename = "FAUQ")]
    #[cfg_attr(feature = "serde", serde(rename = "FAUQ"))]
    Fauq,
    #[yaserde(rename = "CCAQ")]
    #[cfg_attr(feature = "serde", serde(rename = "CCAQ"))]
    Ccaq,
    #[yaserde(rename = "CMPV")]
    #[cfg_attr(feature = "serde", serde(rename = "CMPV"))]
    Cmpv,
    #[yaserde(rename = "DGNP")]
    #[cfg_attr(feature = "serde", serde(rename = "DGNP"))]
    Dgnp,
    #[yaserde(rename = "RCLQ")]
    #[cfg_attr(feature = "serde", serde(rename = "RCLQ"))]
    Rclq,
    #[yaserde(rename = "CCAV")]
    #[cfg_attr(feature = "serde", serde(rename = "CCAV"))]
    Ccav,
    #[yaserde(rename = "BTCH")]
    #[cfg_attr(feature = "serde", serde(rename = "BTCH"))]
    Btch,
    #[yaserde(rename = "FRVA")]
    #[cfg_attr(feature = "serde", serde(rename = "FRVA"))]
    Frva,
    #[yaserde(rename = "AUTQ")]
    #[cfg_attr(feature = "serde", serde(rename = "AUTQ"))]
    Autq,
    #[yaserde(rename = "FCMV")]
    #[cfg_attr(feature = "serde", serde(rename = "FCMV"))]
    Fcmv,
    #[yaserde(rename = "DCCQ")]
    #[cfg_attr(feature = "serde", serde(rename = "DCCQ"))]
    Dccq,
    #[yaserde(rename = "RVRA")]
    #[cfg_attr(feature = "serde", serde(rename = "RVRA"))]
    Rvra,
    #[yaserde(rename = "DCAV")]
    #[cfg_attr(feature = "serde", serde(rename = "DCAV"))]
    Dcav,
    #[yaserde(rename = "TRNA")]
    #[cfg_attr(feature = "serde", serde(rename = "TRNA"))]
    Trna,
    #[yaserde(rename = "NFRQ")]
    #[cfg_attr(feature = "serde", serde(rename = "NFRQ"))]
    Nfrq,
    #[yaserde(rename = "TRPQ")]
    #[cfg_attr(feature = "serde", serde(rename = "TRPQ"))]
    Trpq,
    #[yaserde(rename = "ATAF")]
    #[cfg_attr(feature = "serde", serde(rename = "ATAF"))]
    Ataf,
    __Unknown__(String),
}

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

impl Validate for MessageFunction47Code {}



#[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:catm.005.001.12")]
pub struct MessageItemCondition2 {
    #[yaserde(rename = "ItmId")]
    #[cfg_attr(feature = "serde", serde(rename = "ItmId"))]
    pub itm_id: Max140Text,

    #[yaserde(rename = "Cond")]
    #[cfg_attr(feature = "serde", serde(rename = "Cond"))]
    pub cond: MessageItemCondition2Code,

    #[yaserde(rename = "Val")]
    #[cfg_attr(feature = "serde", serde(rename = "Val"))]
    pub val: Vec<Max140Text>,
}

impl Validate for MessageItemCondition2 {}


#[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:catm.005.001.12")]

pub enum MessageItemCondition2Code {
    #[yaserde(rename = "MNDT")]
    #[cfg_attr(feature = "serde", serde(rename = "MNDT"))]
    Mndt,
    #[yaserde(rename = "CFVL")]
    #[cfg_attr(feature = "serde", serde(rename = "CFVL"))]
    Cfvl,
    #[yaserde(rename = "DFLT")]
    #[cfg_attr(feature = "serde", serde(rename = "DFLT"))]
    Dflt,
    #[yaserde(rename = "ALWV")]
    #[cfg_attr(feature = "serde", serde(rename = "ALWV"))]
    Alwv,
    #[yaserde(rename = "IFAV")]
    #[cfg_attr(feature = "serde", serde(rename = "IFAV"))]
    Ifav,
    #[yaserde(rename = "COPY")]
    #[cfg_attr(feature = "serde", serde(rename = "COPY"))]
    Copy,
    #[yaserde(rename = "UNSP")]
    #[cfg_attr(feature = "serde", serde(rename = "UNSP"))]
    Unsp,
    #[yaserde(rename = "LMNV")]
    #[cfg_attr(feature = "serde", serde(rename = "LMNV"))]
    Lmnv,
    __Unknown__(String),
}

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

impl Validate for MessageItemCondition2Code {}



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

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

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

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

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

impl Validate for Min8Max28NumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.005.001.12")]
pub struct MobileData6 {
    #[yaserde(rename = "MobCtryCd")]
    #[cfg_attr(feature = "serde", serde(rename = "MobCtryCd"))]
    pub mob_ctry_cd: Min2Max3AlphaText,

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

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

    #[yaserde(rename = "Glctn")]
    #[cfg_attr(feature = "serde", serde(rename = "Glctn"))]
    pub glctn: Geolocation1,

    #[yaserde(rename = "SnstvMobData")]
    #[cfg_attr(feature = "serde", serde(rename = "SnstvMobData"))]
    pub snstv_mob_data: SensitiveMobileData1,

    #[yaserde(rename = "PrtctdMobData")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtctdMobData"))]
    pub prtctd_mob_data: ContentInformationType40,
}

impl Validate for MobileData6 {}


#[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:catm.005.001.12")]

pub enum NamePrefix2Code {
    #[yaserde(rename = "DOCT")]
    #[cfg_attr(feature = "serde", serde(rename = "DOCT"))]
    Doct,
    #[yaserde(rename = "MADM")]
    #[cfg_attr(feature = "serde", serde(rename = "MADM"))]
    Madm,
    #[yaserde(rename = "MISS")]
    #[cfg_attr(feature = "serde", serde(rename = "MISS"))]
    Miss,
    #[yaserde(rename = "MIST")]
    #[cfg_attr(feature = "serde", serde(rename = "MIST"))]
    Mist,
    #[yaserde(rename = "MIKS")]
    #[cfg_attr(feature = "serde", serde(rename = "MIKS"))]
    Miks,
    __Unknown__(String),
}

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

impl Validate for NamePrefix2Code {}



#[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:catm.005.001.12")]
pub struct NetworkParameters7 {
    #[yaserde(rename = "Adr")]
    #[cfg_attr(feature = "serde", serde(rename = "Adr"))]
    pub adr: Vec<NetworkParameters9>,

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

    #[yaserde(rename = "AccsCd")]
    #[cfg_attr(feature = "serde", serde(rename = "AccsCd"))]
    pub accs_cd: Max35Binary,

    #[yaserde(rename = "SvrCert")]
    #[cfg_attr(feature = "serde", serde(rename = "SvrCert"))]
    pub svr_cert: Vec<Max10KBinary>,

    #[yaserde(rename = "SvrCertIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "SvrCertIdr"))]
    pub svr_cert_idr: Vec<Max140Binary>,

    #[yaserde(rename = "ClntCert")]
    #[cfg_attr(feature = "serde", serde(rename = "ClntCert"))]
    pub clnt_cert: Vec<Max10KBinary>,

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

impl Validate for NetworkParameters7 {}


#[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:catm.005.001.12")]
pub struct NetworkParameters8 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: NetworkType2Code,

    #[yaserde(rename = "Accs")]
    #[cfg_attr(feature = "serde", serde(rename = "Accs"))]
    pub accs: NetworkParameters7,
}

impl Validate for NetworkParameters8 {}


#[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:catm.005.001.12")]
pub struct NetworkParameters9 {
    #[yaserde(rename = "NtwkTp")]
    #[cfg_attr(feature = "serde", serde(rename = "NtwkTp"))]
    pub ntwk_tp: NetworkType1Code,

    #[yaserde(rename = "AdrVal")]
    #[cfg_attr(feature = "serde", serde(rename = "AdrVal"))]
    pub adr_val: Max500Text,
}

impl Validate for NetworkParameters9 {}


#[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:catm.005.001.12")]

pub enum NetworkType1Code {
    #[yaserde(rename = "IPNW")]
    #[cfg_attr(feature = "serde", serde(rename = "IPNW"))]
    Ipnw,
    #[yaserde(rename = "PSTN")]
    #[cfg_attr(feature = "serde", serde(rename = "PSTN"))]
    Pstn,
    __Unknown__(String),
}

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

impl Validate for NetworkType1Code {}



#[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:catm.005.001.12")]

pub enum NetworkType2Code {
    #[yaserde(rename = "SCK5")]
    #[cfg_attr(feature = "serde", serde(rename = "SCK5"))]
    Sck5,
    #[yaserde(rename = "SCK4")]
    #[cfg_attr(feature = "serde", serde(rename = "SCK4"))]
    Sck4,
    #[yaserde(rename = "HTTP")]
    #[cfg_attr(feature = "serde", serde(rename = "HTTP"))]
    Http,
    __Unknown__(String),
}

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

impl Validate for NetworkType2Code {}



#[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:catm.005.001.12")]

pub enum NonFinancialRequestType2Code {
    #[yaserde(rename = "ACQR")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
    Acqr,
    #[yaserde(rename = "PARQ")]
    #[cfg_attr(feature = "serde", serde(rename = "PARQ"))]
    Parq,
    #[yaserde(rename = "RISK")]
    #[cfg_attr(feature = "serde", serde(rename = "RISK"))]
    Risk,
    #[yaserde(rename = "TOKN")]
    #[cfg_attr(feature = "serde", serde(rename = "TOKN"))]
    Tokn,
    #[yaserde(rename = "ADDR")]
    #[cfg_attr(feature = "serde", serde(rename = "ADDR"))]
    Addr,
    #[yaserde(rename = "INSM")]
    #[cfg_attr(feature = "serde", serde(rename = "INSM"))]
    Insm,
    __Unknown__(String),
}

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

impl Validate for NonFinancialRequestType2Code {}



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

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

pub enum OnLineCapability1Code {
    #[yaserde(rename = "OFLN")]
    #[cfg_attr(feature = "serde", serde(rename = "OFLN"))]
    Ofln,
    #[yaserde(rename = "ONLN")]
    #[cfg_attr(feature = "serde", serde(rename = "ONLN"))]
    Onln,
    #[yaserde(rename = "SMON")]
    #[cfg_attr(feature = "serde", serde(rename = "SMON"))]
    Smon,
    __Unknown__(String),
}

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

impl Validate for OnLineCapability1Code {}



#[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:catm.005.001.12")]
pub struct OnLinePIN11 {
    #[yaserde(rename = "NcrptdPINBlck")]
    #[cfg_attr(feature = "serde", serde(rename = "NcrptdPINBlck"))]
    pub ncrptd_pin_blck: ContentInformationType40,

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

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

impl Validate for OnLinePIN11 {}


#[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:catm.005.001.12")]
pub struct Organisation26 {
    #[yaserde(rename = "CmonNm")]
    #[cfg_attr(feature = "serde", serde(rename = "CmonNm"))]
    pub cmon_nm: Max70Text,

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

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

    #[yaserde(rename = "MrchntCtgyCd")]
    #[cfg_attr(feature = "serde", serde(rename = "MrchntCtgyCd"))]
    pub mrchnt_ctgy_cd: Min3Max4Text,

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

impl Validate for Organisation26 {}


#[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:catm.005.001.12")]
pub struct Organisation45 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: GenericIdentification192,

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

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

    #[yaserde(rename = "LctnAndCtct")]
    #[cfg_attr(feature = "serde", serde(rename = "LctnAndCtct"))]
    pub lctn_and_ctct: CommunicationAddress9,

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

impl Validate for Organisation45 {}


#[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:catm.005.001.12")]
pub struct OrganisationIdentification39 {
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_bic: AnyBICDec2014Identifier,

    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Leiidentifier,

    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Vec<GenericOrganisationIdentification3>,
}

impl Validate for OrganisationIdentification39 {}
#[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:catm.005.001.12")]
pub struct OrganisationIdentificationSchemeName1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ExternalOrganisationIdentification1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max35Text>,
}

impl Validate for OrganisationIdentificationSchemeName1Choice {}




#[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:catm.005.001.12")]
pub struct OriginatorInformation1 {
    #[yaserde(rename = "Cert")]
    #[cfg_attr(feature = "serde", serde(rename = "Cert"))]
    pub cert: Vec<Max5000Binary>,
}

impl Validate for OriginatorInformation1 {}


#[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:catm.005.001.12")]
pub struct OtherContact1 {
    #[yaserde(rename = "ChanlTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ChanlTp"))]
    pub chanl_tp: Max4Text,

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

impl Validate for OtherContact1 {}


#[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:catm.005.001.12")]
pub struct OutputBarcode2 {
    #[yaserde(rename = "BrcdTp")]
    #[cfg_attr(feature = "serde", serde(rename = "BrcdTp"))]
    pub brcd_tp: BarcodeType1Code,

    #[yaserde(rename = "BrcdVal")]
    #[cfg_attr(feature = "serde", serde(rename = "BrcdVal"))]
    pub brcd_val: Max8000Text,

    #[yaserde(rename = "QRCdBinryVal")]
    #[cfg_attr(feature = "serde", serde(rename = "QRCdBinryVal"))]
    pub qr_cd_binry_val: Max3000Binary,

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

    #[yaserde(rename = "QRCdNcodgMd")]
    #[cfg_attr(feature = "serde", serde(rename = "QRCdNcodgMd"))]
    pub qr_cd_ncodg_md: QrcodeEncodingMode1Code,

    #[yaserde(rename = "QRCdErrCrrctn")]
    #[cfg_attr(feature = "serde", serde(rename = "QRCdErrCrrctn"))]
    pub qr_cd_err_crrctn: QrcodeErrorCorrection1Code,
}

impl Validate for OutputBarcode2 {}


#[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:catm.005.001.12")]

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

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

impl Validate for OutputFormat1Code {}



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

pub enum OutputFormat3Code {
    #[yaserde(rename = "BARC")]
    #[cfg_attr(feature = "serde", serde(rename = "BARC"))]
    Barc,
    #[yaserde(rename = "MENT")]
    #[cfg_attr(feature = "serde", serde(rename = "MENT"))]
    Ment,
    #[yaserde(rename = "MREF")]
    #[cfg_attr(feature = "serde", serde(rename = "MREF"))]
    Mref,
    #[yaserde(rename = "SREF")]
    #[cfg_attr(feature = "serde", serde(rename = "SREF"))]
    Sref,
    #[yaserde(rename = "TEXT")]
    #[cfg_attr(feature = "serde", serde(rename = "TEXT"))]
    Text,
    #[yaserde(rename = "HTML")]
    #[cfg_attr(feature = "serde", serde(rename = "HTML"))]
    Html,
    __Unknown__(String),
}

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

impl Validate for OutputFormat3Code {}



#[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:catm.005.001.12")]

pub enum Pinformat3Code {
    #[yaserde(rename = "ISO0")]
    #[cfg_attr(feature = "serde", serde(rename = "ISO0"))]
    Iso0,
    #[yaserde(rename = "ISO1")]
    #[cfg_attr(feature = "serde", serde(rename = "ISO1"))]
    Iso1,
    #[yaserde(rename = "ISO2")]
    #[cfg_attr(feature = "serde", serde(rename = "ISO2"))]
    Iso2,
    #[yaserde(rename = "ISO3")]
    #[cfg_attr(feature = "serde", serde(rename = "ISO3"))]
    Iso3,
    #[yaserde(rename = "ISO4")]
    #[cfg_attr(feature = "serde", serde(rename = "ISO4"))]
    Iso4,
    #[yaserde(rename = "ISO5")]
    #[cfg_attr(feature = "serde", serde(rename = "ISO5"))]
    Iso5,
    __Unknown__(String),
}

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

impl Validate for Pinformat3Code {}



#[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:catm.005.001.12")]

pub enum PinrequestType1Code {
    #[yaserde(rename = "PIAE")]
    #[cfg_attr(feature = "serde", serde(rename = "PIAE"))]
    Piae,
    #[yaserde(rename = "PIAV")]
    #[cfg_attr(feature = "serde", serde(rename = "PIAV"))]
    Piav,
    #[yaserde(rename = "PIVO")]
    #[cfg_attr(feature = "serde", serde(rename = "PIVO"))]
    Pivo,
    __Unknown__(String),
}

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

impl Validate for PinrequestType1Code {}



#[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:catm.005.001.12")]

pub enum PoicommunicationType2Code {
    #[yaserde(rename = "BLTH")]
    #[cfg_attr(feature = "serde", serde(rename = "BLTH"))]
    Blth,
    #[yaserde(rename = "ETHR")]
    #[cfg_attr(feature = "serde", serde(rename = "ETHR"))]
    Ethr,
    #[yaserde(rename = "GPRS")]
    #[cfg_attr(feature = "serde", serde(rename = "GPRS"))]
    Gprs,
    #[yaserde(rename = "GSMF")]
    #[cfg_attr(feature = "serde", serde(rename = "GSMF"))]
    Gsmf,
    #[yaserde(rename = "PSTN")]
    #[cfg_attr(feature = "serde", serde(rename = "PSTN"))]
    Pstn,
    #[yaserde(rename = "RS23")]
    #[cfg_attr(feature = "serde", serde(rename = "RS23"))]
    Rs23,
    #[yaserde(rename = "USBD")]
    #[cfg_attr(feature = "serde", serde(rename = "USBD"))]
    Usbd,
    #[yaserde(rename = "USBH")]
    #[cfg_attr(feature = "serde", serde(rename = "USBH"))]
    Usbh,
    #[yaserde(rename = "WIFI")]
    #[cfg_attr(feature = "serde", serde(rename = "WIFI"))]
    Wifi,
    #[yaserde(rename = "WT2G")]
    #[cfg_attr(feature = "serde", serde(rename = "WT2G"))]
    Wt2G,
    #[yaserde(rename = "WT3G")]
    #[cfg_attr(feature = "serde", serde(rename = "WT3G"))]
    Wt3G,
    #[yaserde(rename = "WT4G")]
    #[cfg_attr(feature = "serde", serde(rename = "WT4G"))]
    Wt4G,
    #[yaserde(rename = "WT5G")]
    #[cfg_attr(feature = "serde", serde(rename = "WT5G"))]
    Wt5G,
    __Unknown__(String),
}

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

impl Validate for PoicommunicationType2Code {}



#[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:catm.005.001.12")]

pub enum PoicomponentAssessment1Code {
    #[yaserde(rename = "APPL")]
    #[cfg_attr(feature = "serde", serde(rename = "APPL"))]
    Appl,
    #[yaserde(rename = "CERT")]
    #[cfg_attr(feature = "serde", serde(rename = "CERT"))]
    Cert,
    #[yaserde(rename = "EVAL")]
    #[cfg_attr(feature = "serde", serde(rename = "EVAL"))]
    Eval,
    __Unknown__(String),
}

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

impl Validate for PoicomponentAssessment1Code {}



#[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:catm.005.001.12")]

pub enum PoicomponentStatus1Code {
    #[yaserde(rename = "WAIT")]
    #[cfg_attr(feature = "serde", serde(rename = "WAIT"))]
    Wait,
    #[yaserde(rename = "OUTD")]
    #[cfg_attr(feature = "serde", serde(rename = "OUTD"))]
    Outd,
    #[yaserde(rename = "OPER")]
    #[cfg_attr(feature = "serde", serde(rename = "OPER"))]
    Oper,
    #[yaserde(rename = "DACT")]
    #[cfg_attr(feature = "serde", serde(rename = "DACT"))]
    Dact,
    __Unknown__(String),
}

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

impl Validate for PoicomponentStatus1Code {}



#[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:catm.005.001.12")]

pub enum PoicomponentType7Code {
    #[yaserde(rename = "AQPP")]
    #[cfg_attr(feature = "serde", serde(rename = "AQPP"))]
    Aqpp,
    #[yaserde(rename = "APPR")]
    #[cfg_attr(feature = "serde", serde(rename = "APPR"))]
    Appr,
    #[yaserde(rename = "TLPR")]
    #[cfg_attr(feature = "serde", serde(rename = "TLPR"))]
    Tlpr,
    #[yaserde(rename = "SCPR")]
    #[cfg_attr(feature = "serde", serde(rename = "SCPR"))]
    Scpr,
    #[yaserde(rename = "SERV")]
    #[cfg_attr(feature = "serde", serde(rename = "SERV"))]
    Serv,
    #[yaserde(rename = "TERM")]
    #[cfg_attr(feature = "serde", serde(rename = "TERM"))]
    Term,
    #[yaserde(rename = "DVCE")]
    #[cfg_attr(feature = "serde", serde(rename = "DVCE"))]
    Dvce,
    #[yaserde(rename = "SECM")]
    #[cfg_attr(feature = "serde", serde(rename = "SECM"))]
    Secm,
    #[yaserde(rename = "APLI")]
    #[cfg_attr(feature = "serde", serde(rename = "APLI"))]
    Apli,
    #[yaserde(rename = "EMVK")]
    #[cfg_attr(feature = "serde", serde(rename = "EMVK"))]
    Emvk,
    #[yaserde(rename = "EMVO")]
    #[cfg_attr(feature = "serde", serde(rename = "EMVO"))]
    Emvo,
    #[yaserde(rename = "MDWR")]
    #[cfg_attr(feature = "serde", serde(rename = "MDWR"))]
    Mdwr,
    #[yaserde(rename = "DRVR")]
    #[cfg_attr(feature = "serde", serde(rename = "DRVR"))]
    Drvr,
    #[yaserde(rename = "OPST")]
    #[cfg_attr(feature = "serde", serde(rename = "OPST"))]
    Opst,
    #[yaserde(rename = "MRPR")]
    #[cfg_attr(feature = "serde", serde(rename = "MRPR"))]
    Mrpr,
    #[yaserde(rename = "CRTF")]
    #[cfg_attr(feature = "serde", serde(rename = "CRTF"))]
    Crtf,
    #[yaserde(rename = "TMSP")]
    #[cfg_attr(feature = "serde", serde(rename = "TMSP"))]
    Tmsp,
    #[yaserde(rename = "SACP")]
    #[cfg_attr(feature = "serde", serde(rename = "SACP"))]
    Sacp,
    #[yaserde(rename = "SAPR")]
    #[cfg_attr(feature = "serde", serde(rename = "SAPR"))]
    Sapr,
    #[yaserde(rename = "LOGF")]
    #[cfg_attr(feature = "serde", serde(rename = "LOGF"))]
    Logf,
    #[yaserde(rename = "MDFL")]
    #[cfg_attr(feature = "serde", serde(rename = "MDFL"))]
    Mdfl,
    #[yaserde(rename = "SOFT")]
    #[cfg_attr(feature = "serde", serde(rename = "SOFT"))]
    Soft,
    #[yaserde(rename = "CONF")]
    #[cfg_attr(feature = "serde", serde(rename = "CONF"))]
    Conf,
    #[yaserde(rename = "RPFL")]
    #[cfg_attr(feature = "serde", serde(rename = "RPFL"))]
    Rpfl,
    #[yaserde(rename = "PROB")]
    #[cfg_attr(feature = "serde", serde(rename = "PROB"))]
    Prob,
    __Unknown__(String),
}

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

impl Validate for PoicomponentType7Code {}



#[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:catm.005.001.12")]
pub struct PackageType5 {
    #[yaserde(rename = "PackgId")]
    #[cfg_attr(feature = "serde", serde(rename = "PackgId"))]
    pub packg_id: GenericIdentification176,

    #[yaserde(rename = "PackgLngth")]
    #[cfg_attr(feature = "serde", serde(rename = "PackgLngth"))]
    pub packg_lngth: PositiveNumber,

    #[yaserde(rename = "OffsetStart")]
    #[cfg_attr(feature = "serde", serde(rename = "OffsetStart"))]
    pub offset_start: PositiveNumber,

    #[yaserde(rename = "OffsetEnd")]
    #[cfg_attr(feature = "serde", serde(rename = "OffsetEnd"))]
    pub offset_end: PositiveNumber,

    #[yaserde(rename = "PackgBlck")]
    #[cfg_attr(feature = "serde", serde(rename = "PackgBlck"))]
    pub packg_blck: Vec<ExternallyDefinedData5>,
}

impl Validate for PackageType5 {}


#[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:catm.005.001.12")]
pub struct Parameter12 {
    #[yaserde(rename = "NcrptnFrmt")]
    #[cfg_attr(feature = "serde", serde(rename = "NcrptnFrmt"))]
    pub ncrptn_frmt: EncryptionFormat2Code,

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


#[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:catm.005.001.12")]
pub struct Parameter16 {
    #[yaserde(rename = "DgstAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "DgstAlgo"))]
    pub dgst_algo: Algorithm26Code,

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

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

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

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

impl Validate for Parameter16 {}


#[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:catm.005.001.12")]
pub struct Parameter17 {
    #[yaserde(rename = "NcrptnFrmt")]
    #[cfg_attr(feature = "serde", serde(rename = "NcrptnFrmt"))]
    pub ncrptn_frmt: EncryptionFormat2Code,

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

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

impl Validate for Parameter17 {}


#[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:catm.005.001.12")]
pub struct Parameter18 {
    #[yaserde(rename = "DgstAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "DgstAlgo"))]
    pub dgst_algo: Algorithm26Code,
}

impl Validate for Parameter18 {}


#[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:catm.005.001.12")]
pub struct Parameter7 {
    #[yaserde(rename = "InitlstnVctr")]
    #[cfg_attr(feature = "serde", serde(rename = "InitlstnVctr"))]
    pub initlstn_vctr: Max500Binary,

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

impl Validate for Parameter7 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.005.001.12")]
pub struct Party52Choice {
    #[yaserde(rename = "OrgId")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgId"))]
    pub org_id: Option<OrganisationIdentification39>,
    #[yaserde(rename = "PrvtId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvtId"))]
    pub prvt_id: Option<PersonIdentification18>,
}

impl Validate for Party52Choice {}




#[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:catm.005.001.12")]
pub struct PartyIdentification272 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max140Text,

    #[yaserde(rename = "PstlAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "PstlAdr"))]
    pub pstl_adr: PostalAddress27,

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

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

    #[yaserde(rename = "CtctDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "CtctDtls"))]
    pub ctct_dtls: Contact13,
}

impl Validate for PartyIdentification272 {}


#[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:catm.005.001.12")]

pub enum PartyType15Code {
    #[yaserde(rename = "PGRP")]
    #[cfg_attr(feature = "serde", serde(rename = "PGRP"))]
    Pgrp,
    #[yaserde(rename = "PSYS")]
    #[cfg_attr(feature = "serde", serde(rename = "PSYS"))]
    Psys,
    #[yaserde(rename = "PSNG")]
    #[cfg_attr(feature = "serde", serde(rename = "PSNG"))]
    Psng,
    __Unknown__(String),
}

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

impl Validate for PartyType15Code {}



#[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:catm.005.001.12")]

pub enum PartyType33Code {
    #[yaserde(rename = "OPOI")]
    #[cfg_attr(feature = "serde", serde(rename = "OPOI"))]
    Opoi,
    #[yaserde(rename = "MERC")]
    #[cfg_attr(feature = "serde", serde(rename = "MERC"))]
    Merc,
    #[yaserde(rename = "ACCP")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCP"))]
    Accp,
    #[yaserde(rename = "ITAG")]
    #[cfg_attr(feature = "serde", serde(rename = "ITAG"))]
    Itag,
    #[yaserde(rename = "ACQR")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
    Acqr,
    #[yaserde(rename = "CISS")]
    #[cfg_attr(feature = "serde", serde(rename = "CISS"))]
    Ciss,
    #[yaserde(rename = "DLIS")]
    #[cfg_attr(feature = "serde", serde(rename = "DLIS"))]
    Dlis,
    #[yaserde(rename = "MTMG")]
    #[cfg_attr(feature = "serde", serde(rename = "MTMG"))]
    Mtmg,
    #[yaserde(rename = "TAXH")]
    #[cfg_attr(feature = "serde", serde(rename = "TAXH"))]
    Taxh,
    #[yaserde(rename = "TMGT")]
    #[cfg_attr(feature = "serde", serde(rename = "TMGT"))]
    Tmgt,
    __Unknown__(String),
}

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

impl Validate for PartyType33Code {}



#[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:catm.005.001.12")]

pub enum PartyType35Code {
    #[yaserde(rename = "OPOI")]
    #[cfg_attr(feature = "serde", serde(rename = "OPOI"))]
    Opoi,
    #[yaserde(rename = "MERC")]
    #[cfg_attr(feature = "serde", serde(rename = "MERC"))]
    Merc,
    #[yaserde(rename = "ACCP")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCP"))]
    Accp,
    #[yaserde(rename = "ITAG")]
    #[cfg_attr(feature = "serde", serde(rename = "ITAG"))]
    Itag,
    #[yaserde(rename = "ACQR")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
    Acqr,
    #[yaserde(rename = "CISS")]
    #[cfg_attr(feature = "serde", serde(rename = "CISS"))]
    Ciss,
    #[yaserde(rename = "DLIS")]
    #[cfg_attr(feature = "serde", serde(rename = "DLIS"))]
    Dlis,
    #[yaserde(rename = "MKTP")]
    #[cfg_attr(feature = "serde", serde(rename = "MKTP"))]
    Mktp,
    #[yaserde(rename = "PFAC")]
    #[cfg_attr(feature = "serde", serde(rename = "PFAC"))]
    Pfac,
    __Unknown__(String),
}

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

impl Validate for PartyType35Code {}



#[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:catm.005.001.12")]

pub enum PartyType4Code {
    #[yaserde(rename = "MERC")]
    #[cfg_attr(feature = "serde", serde(rename = "MERC"))]
    Merc,
    #[yaserde(rename = "ACCP")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCP"))]
    Accp,
    #[yaserde(rename = "ITAG")]
    #[cfg_attr(feature = "serde", serde(rename = "ITAG"))]
    Itag,
    #[yaserde(rename = "ACQR")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
    Acqr,
    #[yaserde(rename = "CISS")]
    #[cfg_attr(feature = "serde", serde(rename = "CISS"))]
    Ciss,
    #[yaserde(rename = "TAXH")]
    #[cfg_attr(feature = "serde", serde(rename = "TAXH"))]
    Taxh,
    __Unknown__(String),
}

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

impl Validate for PartyType4Code {}



#[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:catm.005.001.12")]

pub enum PartyType7Code {
    #[yaserde(rename = "ACQR")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
    Acqr,
    #[yaserde(rename = "ITAG")]
    #[cfg_attr(feature = "serde", serde(rename = "ITAG"))]
    Itag,
    #[yaserde(rename = "PCPT")]
    #[cfg_attr(feature = "serde", serde(rename = "PCPT"))]
    Pcpt,
    #[yaserde(rename = "TMGT")]
    #[cfg_attr(feature = "serde", serde(rename = "TMGT"))]
    Tmgt,
    #[yaserde(rename = "SALE")]
    #[cfg_attr(feature = "serde", serde(rename = "SALE"))]
    Sale,
    __Unknown__(String),
}

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

impl Validate for PartyType7Code {}



#[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:catm.005.001.12")]
pub struct PaymentCard35 {
    #[yaserde(rename = "PrtctdCardData")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtctdCardData"))]
    pub prtctd_card_data: ContentInformationType40,

    #[yaserde(rename = "PrvtCardData")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvtCardData"))]
    pub prvt_card_data: Max100KBinary,

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

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

    #[yaserde(rename = "MskdPAN")]
    #[cfg_attr(feature = "serde", serde(rename = "MskdPAN"))]
    pub mskd_pan: Max30Text,

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

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

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

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

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

    #[yaserde(rename = "CardPdctTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CardPdctTp"))]
    pub card_pdct_tp: CardProductType1Code,

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

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

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

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

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

impl Validate for PaymentCard35 {}


#[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:catm.005.001.12")]
pub struct PaymentContext29 {
    #[yaserde(rename = "CardPres")]
    #[cfg_attr(feature = "serde", serde(rename = "CardPres"))]
    pub card_pres: TrueFalseIndicator,

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

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

    #[yaserde(rename = "AttndncCntxt")]
    #[cfg_attr(feature = "serde", serde(rename = "AttndncCntxt"))]
    pub attndnc_cntxt: AttendanceContext1Code,

    #[yaserde(rename = "TxEnvt")]
    #[cfg_attr(feature = "serde", serde(rename = "TxEnvt"))]
    pub tx_envt: TransactionEnvironment1Code,

    #[yaserde(rename = "TxChanl")]
    #[cfg_attr(feature = "serde", serde(rename = "TxChanl"))]
    pub tx_chanl: TransactionChannel5Code,

    #[yaserde(rename = "BizArea")]
    #[cfg_attr(feature = "serde", serde(rename = "BizArea"))]
    pub biz_area: BusinessArea2Code,

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

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

    #[yaserde(rename = "CardDataNtryMd")]
    #[cfg_attr(feature = "serde", serde(rename = "CardDataNtryMd"))]
    pub card_data_ntry_md: CardDataReading8Code,

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

    #[yaserde(rename = "SpprtdOptn")]
    #[cfg_attr(feature = "serde", serde(rename = "SpprtdOptn"))]
    pub spprtd_optn: Vec<SupportedPaymentOption2Code>,
}

impl Validate for PaymentContext29 {}


#[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:catm.005.001.12")]
pub struct PaymentContext30 {
    #[yaserde(rename = "PmtCntxt")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtCntxt"))]
    pub pmt_cntxt: PaymentContext29,

    #[yaserde(rename = "SaleCntxt")]
    #[cfg_attr(feature = "serde", serde(rename = "SaleCntxt"))]
    pub sale_cntxt: SaleContext4,

    #[yaserde(rename = "CdtTrfCntxt")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtTrfCntxt"))]
    pub cdt_trf_cntxt: CreditTransferContext1,

    #[yaserde(rename = "DrctDbtCntxt")]
    #[cfg_attr(feature = "serde", serde(rename = "DrctDbtCntxt"))]
    pub drct_dbt_cntxt: DirectDebitContext1,
}

impl Validate for PaymentContext30 {}


#[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:catm.005.001.12")]
pub struct PaymentTerminalParameters8 {
    #[yaserde(rename = "ActnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ActnTp"))]
    pub actn_tp: TerminalManagementAction3Code,

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

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

    #[yaserde(rename = "ParamFrmtIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "ParamFrmtIdr"))]
    pub param_frmt_idr: Max8Text,

    #[yaserde(rename = "ClckSynctn")]
    #[cfg_attr(feature = "serde", serde(rename = "ClckSynctn"))]
    pub clck_synctn: ClockSynchronisation3,

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

    #[yaserde(rename = "LclDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "LclDtTm"))]
    pub lcl_dt_tm: Vec<LocalDateTime1>,

    #[yaserde(rename = "OthrParamsLngth")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrParamsLngth"))]
    pub othr_params_lngth: PositiveNumber,

    #[yaserde(rename = "OffsetStart")]
    #[cfg_attr(feature = "serde", serde(rename = "OffsetStart"))]
    pub offset_start: PositiveNumber,

    #[yaserde(rename = "OffsetEnd")]
    #[cfg_attr(feature = "serde", serde(rename = "OffsetEnd"))]
    pub offset_end: PositiveNumber,

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

impl Validate for PaymentTerminalParameters8 {}


#[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:catm.005.001.12")]
pub struct PaymentTokenIdentifiers1 {
    #[yaserde(rename = "PrvdrId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvdrId"))]
    pub prvdr_id: Max35Text,

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

impl Validate for PaymentTokenIdentifiers1 {}


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

impl Validate for PercentageRate {}
#[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:catm.005.001.12")]
pub struct PersonIdentification15 {
    #[yaserde(rename = "DrvrLicNb")]
    #[cfg_attr(feature = "serde", serde(rename = "DrvrLicNb"))]
    pub drvr_lic_nb: Max35Text,

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

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

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

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

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

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

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

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

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

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

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

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

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

    #[yaserde(rename = "EmailAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "EmailAdr"))]
    pub email_adr: Max256Text,

    #[yaserde(rename = "DtAndPlcOfBirth")]
    #[cfg_attr(feature = "serde", serde(rename = "DtAndPlcOfBirth"))]
    pub dt_and_plc_of_birth: DateAndPlaceOfBirth1,

    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Vec<GenericIdentification4>,
}

impl Validate for PersonIdentification15 {}


#[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:catm.005.001.12")]
pub struct PersonIdentification18 {
    #[yaserde(rename = "DtAndPlcOfBirth")]
    #[cfg_attr(feature = "serde", serde(rename = "DtAndPlcOfBirth"))]
    pub dt_and_plc_of_birth: DateAndPlaceOfBirth1,

    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Vec<GenericPersonIdentification2>,
}

impl Validate for PersonIdentification18 {}
#[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:catm.005.001.12")]
pub struct PersonIdentificationSchemeName1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ExternalPersonIdentification1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max35Text>,
}

impl Validate for PersonIdentificationSchemeName1Choice {}




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

impl Validate for PhoneNumber {}
#[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:catm.005.001.12")]
pub struct PhysicalInterfaceParameter1 {
    #[yaserde(rename = "IntrfcNm")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrfcNm"))]
    pub intrfc_nm: Max35Text,

    #[yaserde(rename = "IntrfcTp")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrfcTp"))]
    pub intrfc_tp: PoicommunicationType2Code,

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

    #[yaserde(rename = "AccsCd")]
    #[cfg_attr(feature = "serde", serde(rename = "AccsCd"))]
    pub accs_cd: Max35Binary,

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

    #[yaserde(rename = "AddtlParams")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlParams"))]
    pub addtl_params: Max2KBinary,
}

impl Validate for PhysicalInterfaceParameter1 {}


#[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:catm.005.001.12")]
pub struct PlainCardData17 {
    #[yaserde(rename = "PAN")]
    #[cfg_attr(feature = "serde", serde(rename = "PAN"))]
    pub pan: Min8Max28NumericText,

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

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

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

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

    #[yaserde(rename = "NtryMd")]
    #[cfg_attr(feature = "serde", serde(rename = "NtryMd"))]
    pub ntry_md: CardDataReading5Code,
}

impl Validate for PlainCardData17 {}


#[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:catm.005.001.12")]
pub struct PlainCardData22 {
    #[yaserde(rename = "PAN")]
    #[cfg_attr(feature = "serde", serde(rename = "PAN"))]
    pub pan: Min8Max28NumericText,

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

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

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

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

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

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

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

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

impl Validate for PlainCardData22 {}


#[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:catm.005.001.12")]
pub struct PointOfInteraction16 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: GenericIdentification177,

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

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

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

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

    #[yaserde(rename = "TermnlIntgtn")]
    #[cfg_attr(feature = "serde", serde(rename = "TermnlIntgtn"))]
    pub termnl_intgtn: LocationCategory3Code,

    #[yaserde(rename = "Cmpnt")]
    #[cfg_attr(feature = "serde", serde(rename = "Cmpnt"))]
    pub cmpnt: Vec<PointOfInteractionComponent18>,
}

impl Validate for PointOfInteraction16 {}


#[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:catm.005.001.12")]
pub struct PointOfInteractionCapabilities11 {
    #[yaserde(rename = "CardRdngCpblties")]
    #[cfg_attr(feature = "serde", serde(rename = "CardRdngCpblties"))]
    pub card_rdng_cpblties: Vec<CardDataReading8Code>,

    #[yaserde(rename = "CrdhldrVrfctnCpblties")]
    #[cfg_attr(feature = "serde", serde(rename = "CrdhldrVrfctnCpblties"))]
    pub crdhldr_vrfctn_cpblties: Vec<CardholderVerificationCapability4Code>,

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

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

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

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

    #[yaserde(rename = "OnLineCpblties")]
    #[cfg_attr(feature = "serde", serde(rename = "OnLineCpblties"))]
    pub on_line_cpblties: OnLineCapability1Code,

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

impl Validate for PointOfInteractionCapabilities11 {}


#[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:catm.005.001.12")]
pub struct PointOfInteractionComponent18 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: PoicomponentType7Code,

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

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

    #[yaserde(rename = "Sts")]
    #[cfg_attr(feature = "serde", serde(rename = "Sts"))]
    pub sts: PointOfInteractionComponentStatus3,

    #[yaserde(rename = "StdCmplc")]
    #[cfg_attr(feature = "serde", serde(rename = "StdCmplc"))]
    pub std_cmplc: Vec<GenericIdentification48>,

    #[yaserde(rename = "Chrtcs")]
    #[cfg_attr(feature = "serde", serde(rename = "Chrtcs"))]
    pub chrtcs: PointOfInteractionComponentCharacteristics11,

    #[yaserde(rename = "Assmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "Assmnt"))]
    pub assmnt: Vec<PointOfInteractionComponentAssessment1>,

    #[yaserde(rename = "Packg")]
    #[cfg_attr(feature = "serde", serde(rename = "Packg"))]
    pub packg: Vec<PackageType5>,

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

impl Validate for PointOfInteractionComponent18 {}


#[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:catm.005.001.12")]
pub struct PointOfInteractionComponentAssessment1 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: PoicomponentAssessment1Code,

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

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

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

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

impl Validate for PointOfInteractionComponentAssessment1 {}


#[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:catm.005.001.12")]
pub struct PointOfInteractionComponentCharacteristics11 {
    #[yaserde(rename = "Mmry")]
    #[cfg_attr(feature = "serde", serde(rename = "Mmry"))]
    pub mmry: Vec<MemoryCharacteristics1>,

    #[yaserde(rename = "Com")]
    #[cfg_attr(feature = "serde", serde(rename = "Com"))]
    pub com: Vec<CommunicationCharacteristics5>,

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

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

    #[yaserde(rename = "SctyElmt")]
    #[cfg_attr(feature = "serde", serde(rename = "SctyElmt"))]
    pub scty_elmt: Vec<CryptographicKey19>,
}

impl Validate for PointOfInteractionComponentCharacteristics11 {}


#[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:catm.005.001.12")]
pub struct PointOfInteractionComponentIdentification2 {
    #[yaserde(rename = "ItmNb")]
    #[cfg_attr(feature = "serde", serde(rename = "ItmNb"))]
    pub itm_nb: Max35Text,

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

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

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

impl Validate for PointOfInteractionComponentIdentification2 {}


#[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:catm.005.001.12")]
pub struct PointOfInteractionComponentStatus3 {
    #[yaserde(rename = "VrsnNb")]
    #[cfg_attr(feature = "serde", serde(rename = "VrsnNb"))]
    pub vrsn_nb: Max256Text,

    #[yaserde(rename = "Sts")]
    #[cfg_attr(feature = "serde", serde(rename = "Sts"))]
    pub sts: PoicomponentStatus1Code,

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

impl Validate for PointOfInteractionComponentStatus3 {}


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

impl Validate for PositiveNumber {
    fn validate(&self) -> Result<(), String> { 
        if self.0 < "1".parse::<String>().unwrap() {
            return Err(format!("MinInclusive validation error: invalid value of 0! \nExpected: 0 >= 1.\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:catm.005.001.12")]
pub struct PostalAddress22 {
    #[yaserde(rename = "AdrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "AdrTp"))]
    pub adr_tp: AddressType2Code,

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

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

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

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

    #[yaserde(rename = "CtryCd")]
    #[cfg_attr(feature = "serde", serde(rename = "CtryCd"))]
    pub ctry_cd: Min2Max3AlphaText,
}

impl Validate for PostalAddress22 {}


#[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:catm.005.001.12")]
pub struct PostalAddress27 {
    #[yaserde(rename = "AdrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "AdrTp"))]
    pub adr_tp: AddressType3Choice,

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Validate for PostalAddress27 {}


#[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:catm.005.001.12")]

pub enum PreferredContactMethod2Code {
    #[yaserde(rename = "MAIL")]
    #[cfg_attr(feature = "serde", serde(rename = "MAIL"))]
    Mail,
    #[yaserde(rename = "FAXX")]
    #[cfg_attr(feature = "serde", serde(rename = "FAXX"))]
    Faxx,
    #[yaserde(rename = "LETT")]
    #[cfg_attr(feature = "serde", serde(rename = "LETT"))]
    Lett,
    #[yaserde(rename = "CELL")]
    #[cfg_attr(feature = "serde", serde(rename = "CELL"))]
    Cell,
    #[yaserde(rename = "ONLI")]
    #[cfg_attr(feature = "serde", serde(rename = "ONLI"))]
    Onli,
    #[yaserde(rename = "PHON")]
    #[cfg_attr(feature = "serde", serde(rename = "PHON"))]
    Phon,
    __Unknown__(String),
}

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

impl Validate for PreferredContactMethod2Code {}



#[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:catm.005.001.12")]
pub struct ProcessRetry3 {
    #[yaserde(rename = "Dely")]
    #[cfg_attr(feature = "serde", serde(rename = "Dely"))]
    pub dely: Max9NumericText,

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

    #[yaserde(rename = "UnitOfTm")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitOfTm"))]
    pub unit_of_tm: TimeUnit1Code,
}

impl Validate for ProcessRetry3 {}


#[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:catm.005.001.12")]
pub struct ProcessTiming5 {
    #[yaserde(rename = "WtgTm")]
    #[cfg_attr(feature = "serde", serde(rename = "WtgTm"))]
    pub wtg_tm: Max9NumericText,

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

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

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

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

    #[yaserde(rename = "UnitOfTm")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitOfTm"))]
    pub unit_of_tm: TimeUnit1Code,
}

impl Validate for ProcessTiming5 {}


#[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:catm.005.001.12")]
pub struct ProcessTiming6 {
    #[yaserde(rename = "StartTm")]
    #[cfg_attr(feature = "serde", serde(rename = "StartTm"))]
    pub start_tm: IsodateTime,

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

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

    #[yaserde(rename = "UnitOfTm")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitOfTm"))]
    pub unit_of_tm: TimeUnit1Code,
}

impl Validate for ProcessTiming6 {}


#[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:catm.005.001.12")]

pub enum ProcessingPosition2Code {
    #[yaserde(rename = "AFTE")]
    #[cfg_attr(feature = "serde", serde(rename = "AFTE"))]
    Afte,
    #[yaserde(rename = "WITH")]
    #[cfg_attr(feature = "serde", serde(rename = "WITH"))]
    With,
    #[yaserde(rename = "BEFO")]
    #[cfg_attr(feature = "serde", serde(rename = "BEFO"))]
    Befo,
    #[yaserde(rename = "INFO")]
    #[cfg_attr(feature = "serde", serde(rename = "INFO"))]
    Info,
    __Unknown__(String),
}

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

impl Validate for ProcessingPosition2Code {}



#[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:catm.005.001.12")]
pub struct ProxyAccountIdentification1 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: ProxyAccountType1Choice,

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

impl Validate for ProxyAccountIdentification1 {}
#[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:catm.005.001.12")]
pub struct ProxyAccountType1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ExternalProxyAccountType1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max35Text>,
}

impl Validate for ProxyAccountType1Choice {}




#[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:catm.005.001.12")]

pub enum QrcodeEncodingMode1Code {
    #[yaserde(rename = "ALFA")]
    #[cfg_attr(feature = "serde", serde(rename = "ALFA"))]
    Alfa,
    #[yaserde(rename = "BINA")]
    #[cfg_attr(feature = "serde", serde(rename = "BINA"))]
    Bina,
    #[yaserde(rename = "KANJ")]
    #[cfg_attr(feature = "serde", serde(rename = "KANJ"))]
    Kanj,
    #[yaserde(rename = "NUME")]
    #[cfg_attr(feature = "serde", serde(rename = "NUME"))]
    Nume,
    __Unknown__(String),
}

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

impl Validate for QrcodeEncodingMode1Code {}



#[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:catm.005.001.12")]

pub enum QrcodeErrorCorrection1Code {
    M015,
    Q025,
    H030,
    L007,
    __Unknown__(String),
}

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

impl Validate for QrcodeErrorCorrection1Code {}
#[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:catm.005.001.12")]
pub struct Recipient13Choice {
    #[yaserde(rename = "IssrAndSrlNb")]
    #[cfg_attr(feature = "serde", serde(rename = "IssrAndSrlNb"))]
    pub issr_and_srl_nb: Option<IssuerAndSerialNumber2>,
    #[yaserde(rename = "SbjtKeyIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "SbjtKeyIdr"))]
    pub sbjt_key_idr: Option<Max140Binary>,
}

impl Validate for Recipient13Choice {}
#[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:catm.005.001.12")]
pub struct Recipient15Choice {
    #[yaserde(rename = "KeyTrnsprt")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyTrnsprt"))]
    pub key_trnsprt: Option<KeyTransport10>,
    #[yaserde(rename = "KEK")]
    #[cfg_attr(feature = "serde", serde(rename = "KEK"))]
    pub kek: Option<Kek9>,
    #[yaserde(rename = "KeyIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyIdr"))]
    pub key_idr: Option<Kekidentifier7>,
}

impl Validate for Recipient15Choice {}




#[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:catm.005.001.12")]

pub enum ReconciliationCriteria1Code {
    #[yaserde(rename = "BRND")]
    #[cfg_attr(feature = "serde", serde(rename = "BRND"))]
    Brnd,
    #[yaserde(rename = "PROF")]
    #[cfg_attr(feature = "serde", serde(rename = "PROF"))]
    Prof,
    #[yaserde(rename = "GRUP")]
    #[cfg_attr(feature = "serde", serde(rename = "GRUP"))]
    Grup,
    __Unknown__(String),
}

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

impl Validate for ReconciliationCriteria1Code {}



#[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:catm.005.001.12")]
pub struct RelativeDistinguishedName1 {
    #[yaserde(rename = "AttrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "AttrTp"))]
    pub attr_tp: AttributeType1Code,

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

impl Validate for RelativeDistinguishedName1 {}


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

pub enum ResourceAction1Code {
    #[yaserde(rename = "PAUS")]
    #[cfg_attr(feature = "serde", serde(rename = "PAUS"))]
    Paus,
    #[yaserde(rename = "STAS")]
    #[cfg_attr(feature = "serde", serde(rename = "STAS"))]
    Stas,
    #[yaserde(rename = "LOOP")]
    #[cfg_attr(feature = "serde", serde(rename = "LOOP"))]
    Loop,
    #[yaserde(rename = "RESU")]
    #[cfg_attr(feature = "serde", serde(rename = "RESU"))]
    Resu,
    #[yaserde(rename = "DVOL")]
    #[cfg_attr(feature = "serde", serde(rename = "DVOL"))]
    Dvol,
    #[yaserde(rename = "STOS")]
    #[cfg_attr(feature = "serde", serde(rename = "STOS"))]
    Stos,
    __Unknown__(String),
}

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

impl Validate for ResourceAction1Code {}



#[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:catm.005.001.12")]
pub struct ResourceContent1 {
    #[yaserde(rename = "RsrcTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RsrcTp"))]
    pub rsrc_tp: ResourceType1Code,

    #[yaserde(rename = "RsrcFrmt")]
    #[cfg_attr(feature = "serde", serde(rename = "RsrcFrmt"))]
    pub rsrc_frmt: SoundFormat1Code,

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

    #[yaserde(rename = "RsrcRef")]
    #[cfg_attr(feature = "serde", serde(rename = "RsrcRef"))]
    pub rsrc_ref: Max1025Text,
}

impl Validate for ResourceContent1 {}


#[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:catm.005.001.12")]

pub enum ResourceType1Code {
    #[yaserde(rename = "TEXT")]
    #[cfg_attr(feature = "serde", serde(rename = "TEXT"))]
    Text,
    #[yaserde(rename = "URLI")]
    #[cfg_attr(feature = "serde", serde(rename = "URLI"))]
    Urli,
    __Unknown__(String),
}

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

impl Validate for ResourceType1Code {}



#[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:catm.005.001.12")]

pub enum ResponseMode2Code {
    #[yaserde(rename = "SEND")]
    #[cfg_attr(feature = "serde", serde(rename = "SEND"))]
    Send,
    #[yaserde(rename = "IMMD")]
    #[cfg_attr(feature = "serde", serde(rename = "IMMD"))]
    Immd,
    #[yaserde(rename = "NREQ")]
    #[cfg_attr(feature = "serde", serde(rename = "NREQ"))]
    Nreq,
    #[yaserde(rename = "PEND")]
    #[cfg_attr(feature = "serde", serde(rename = "PEND"))]
    Pend,
    __Unknown__(String),
}

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

impl Validate for ResponseMode2Code {}



#[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:catm.005.001.12")]

pub enum RetailerMessage1Code {
    #[yaserde(rename = "SSAB")]
    #[cfg_attr(feature = "serde", serde(rename = "SSAB"))]
    Ssab,
    #[yaserde(rename = "SAAQ")]
    #[cfg_attr(feature = "serde", serde(rename = "SAAQ"))]
    Saaq,
    #[yaserde(rename = "SAAP")]
    #[cfg_attr(feature = "serde", serde(rename = "SAAP"))]
    Saap,
    #[yaserde(rename = "SDDR")]
    #[cfg_attr(feature = "serde", serde(rename = "SDDR"))]
    Sddr,
    #[yaserde(rename = "SDDP")]
    #[cfg_attr(feature = "serde", serde(rename = "SDDP"))]
    Sddp,
    #[yaserde(rename = "SSEN")]
    #[cfg_attr(feature = "serde", serde(rename = "SSEN"))]
    Ssen,
    #[yaserde(rename = "SSMQ")]
    #[cfg_attr(feature = "serde", serde(rename = "SSMQ"))]
    Ssmq,
    #[yaserde(rename = "SSMR")]
    #[cfg_attr(feature = "serde", serde(rename = "SSMR"))]
    Ssmr,
    #[yaserde(rename = "SSRJ")]
    #[cfg_attr(feature = "serde", serde(rename = "SSRJ"))]
    Ssrj,
    #[yaserde(rename = "SARQ")]
    #[cfg_attr(feature = "serde", serde(rename = "SARQ"))]
    Sarq,
    #[yaserde(rename = "SARP")]
    #[cfg_attr(feature = "serde", serde(rename = "SARP"))]
    Sarp,
    #[yaserde(rename = "SFRP")]
    #[cfg_attr(feature = "serde", serde(rename = "SFRP"))]
    Sfrp,
    #[yaserde(rename = "SFRQ")]
    #[cfg_attr(feature = "serde", serde(rename = "SFRQ"))]
    Sfrq,
    #[yaserde(rename = "SFSQ")]
    #[cfg_attr(feature = "serde", serde(rename = "SFSQ"))]
    Sfsq,
    #[yaserde(rename = "SFSP")]
    #[cfg_attr(feature = "serde", serde(rename = "SFSP"))]
    Sfsp,
    #[yaserde(rename = "SASQ")]
    #[cfg_attr(feature = "serde", serde(rename = "SASQ"))]
    Sasq,
    #[yaserde(rename = "SASP")]
    #[cfg_attr(feature = "serde", serde(rename = "SASP"))]
    Sasp,
    __Unknown__(String),
}

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

impl Validate for RetailerMessage1Code {}



#[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:catm.005.001.12")]
pub struct RetailerSaleEnvironment2 {
    #[yaserde(rename = "SaleCpblties")]
    #[cfg_attr(feature = "serde", serde(rename = "SaleCpblties"))]
    pub sale_cpblties: Vec<SaleCapabilities1Code>,

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

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

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

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

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

    #[yaserde(rename = "LltyHdlg")]
    #[cfg_attr(feature = "serde", serde(rename = "LltyHdlg"))]
    pub llty_hdlg: LoyaltyHandling1Code,
}

impl Validate for RetailerSaleEnvironment2 {}


#[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:catm.005.001.12")]

pub enum RetailerService2Code {
    #[yaserde(rename = "FSPQ")]
    #[cfg_attr(feature = "serde", serde(rename = "FSPQ"))]
    Fspq,
    #[yaserde(rename = "FSRQ")]
    #[cfg_attr(feature = "serde", serde(rename = "FSRQ"))]
    Fsrq,
    #[yaserde(rename = "FSIQ")]
    #[cfg_attr(feature = "serde", serde(rename = "FSIQ"))]
    Fsiq,
    #[yaserde(rename = "FSBQ")]
    #[cfg_attr(feature = "serde", serde(rename = "FSBQ"))]
    Fsbq,
    #[yaserde(rename = "FSLQ")]
    #[cfg_attr(feature = "serde", serde(rename = "FSLQ"))]
    Fslq,
    #[yaserde(rename = "FSVQ")]
    #[cfg_attr(feature = "serde", serde(rename = "FSVQ"))]
    Fsvq,
    #[yaserde(rename = "FSEQ")]
    #[cfg_attr(feature = "serde", serde(rename = "FSEQ"))]
    Fseq,
    #[yaserde(rename = "FSAQ")]
    #[cfg_attr(feature = "serde", serde(rename = "FSAQ"))]
    Fsaq,
    #[yaserde(rename = "FSCQ")]
    #[cfg_attr(feature = "serde", serde(rename = "FSCQ"))]
    Fscq,
    __Unknown__(String),
}

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

impl Validate for RetailerService2Code {}



#[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:catm.005.001.12")]

pub enum RetailerService8Code {
    #[yaserde(rename = "DDYQ")]
    #[cfg_attr(feature = "serde", serde(rename = "DDYQ"))]
    Ddyq,
    #[yaserde(rename = "DINQ")]
    #[cfg_attr(feature = "serde", serde(rename = "DINQ"))]
    Dinq,
    #[yaserde(rename = "DPRQ")]
    #[cfg_attr(feature = "serde", serde(rename = "DPRQ"))]
    Dprq,
    #[yaserde(rename = "DSOQ")]
    #[cfg_attr(feature = "serde", serde(rename = "DSOQ"))]
    Dsoq,
    #[yaserde(rename = "DSIQ")]
    #[cfg_attr(feature = "serde", serde(rename = "DSIQ"))]
    Dsiq,
    #[yaserde(rename = "DCIQ")]
    #[cfg_attr(feature = "serde", serde(rename = "DCIQ"))]
    Dciq,
    #[yaserde(rename = "DCAQ")]
    #[cfg_attr(feature = "serde", serde(rename = "DCAQ"))]
    Dcaq,
    #[yaserde(rename = "DCPQ")]
    #[cfg_attr(feature = "serde", serde(rename = "DCPQ"))]
    Dcpq,
    #[yaserde(rename = "DCOQ")]
    #[cfg_attr(feature = "serde", serde(rename = "DCOQ"))]
    Dcoq,
    #[yaserde(rename = "DINO")]
    #[cfg_attr(feature = "serde", serde(rename = "DINO"))]
    Dino,
    __Unknown__(String),
}

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

impl Validate for RetailerService8Code {}



#[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:catm.005.001.12")]

pub enum SaleCapabilities1Code {
    #[yaserde(rename = "CHDI")]
    #[cfg_attr(feature = "serde", serde(rename = "CHDI"))]
    Chdi,
    #[yaserde(rename = "CHER")]
    #[cfg_attr(feature = "serde", serde(rename = "CHER"))]
    Cher,
    #[yaserde(rename = "CHIN")]
    #[cfg_attr(feature = "serde", serde(rename = "CHIN"))]
    Chin,
    #[yaserde(rename = "CHST")]
    #[cfg_attr(feature = "serde", serde(rename = "CHST"))]
    Chst,
    #[yaserde(rename = "CUDI")]
    #[cfg_attr(feature = "serde", serde(rename = "CUDI"))]
    Cudi,
    #[yaserde(rename = "CUAS")]
    #[cfg_attr(feature = "serde", serde(rename = "CUAS"))]
    Cuas,
    #[yaserde(rename = "CUER")]
    #[cfg_attr(feature = "serde", serde(rename = "CUER"))]
    Cuer,
    #[yaserde(rename = "CUIN")]
    #[cfg_attr(feature = "serde", serde(rename = "CUIN"))]
    Cuin,
    #[yaserde(rename = "POIR")]
    #[cfg_attr(feature = "serde", serde(rename = "POIR"))]
    Poir,
    #[yaserde(rename = "PRDC")]
    #[cfg_attr(feature = "serde", serde(rename = "PRDC"))]
    Prdc,
    #[yaserde(rename = "PRRP")]
    #[cfg_attr(feature = "serde", serde(rename = "PRRP"))]
    Prrp,
    #[yaserde(rename = "PRVC")]
    #[cfg_attr(feature = "serde", serde(rename = "PRVC"))]
    Prvc,
    __Unknown__(String),
}

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

impl Validate for SaleCapabilities1Code {}



#[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:catm.005.001.12")]

pub enum SaleCapabilities2Code {
    #[yaserde(rename = "CHIN")]
    #[cfg_attr(feature = "serde", serde(rename = "CHIN"))]
    Chin,
    #[yaserde(rename = "CUIN")]
    #[cfg_attr(feature = "serde", serde(rename = "CUIN"))]
    Cuin,
    __Unknown__(String),
}

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

impl Validate for SaleCapabilities2Code {}



#[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:catm.005.001.12")]
pub struct SaleContext4 {
    #[yaserde(rename = "SaleId")]
    #[cfg_attr(feature = "serde", serde(rename = "SaleId"))]
    pub sale_id: Max35Text,

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

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

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

    #[yaserde(rename = "CshrLang")]
    #[cfg_attr(feature = "serde", serde(rename = "CshrLang"))]
    pub cshr_lang: Vec<LanguageCode>,

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

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

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

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

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

    #[yaserde(rename = "SpnsrdMrchnt")]
    #[cfg_attr(feature = "serde", serde(rename = "SpnsrdMrchnt"))]
    pub spnsrd_mrchnt: Vec<Organisation26>,

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

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

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

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

    #[yaserde(rename = "AllwdNtryMd")]
    #[cfg_attr(feature = "serde", serde(rename = "AllwdNtryMd"))]
    pub allwd_ntry_md: Vec<CardDataReading8Code>,

    #[yaserde(rename = "SaleTknScp")]
    #[cfg_attr(feature = "serde", serde(rename = "SaleTknScp"))]
    pub sale_tkn_scp: SaleTokenScope1Code,

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

impl Validate for SaleContext4 {}


#[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:catm.005.001.12")]
pub struct SaleToPOIProtocolParameter4 {
    #[yaserde(rename = "ActnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ActnTp"))]
    pub actn_tp: TerminalManagementAction3Code,

    #[yaserde(rename = "MrchntId")]
    #[cfg_attr(feature = "serde", serde(rename = "MrchntId"))]
    pub mrchnt_id: Organisation26,

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

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

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

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

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

    #[yaserde(rename = "AllwdSaleMsg")]
    #[cfg_attr(feature = "serde", serde(rename = "AllwdSaleMsg"))]
    pub allwd_sale_msg: Vec<RetailerMessage1Code>,

    #[yaserde(rename = "AllwdPOIMsg")]
    #[cfg_attr(feature = "serde", serde(rename = "AllwdPOIMsg"))]
    pub allwd_poi_msg: Vec<RetailerMessage1Code>,

    #[yaserde(rename = "AllwdPOISvc")]
    #[cfg_attr(feature = "serde", serde(rename = "AllwdPOISvc"))]
    pub allwd_poi_svc: Vec<RetailerService2Code>,

    #[yaserde(rename = "AllwdSaleDvc")]
    #[cfg_attr(feature = "serde", serde(rename = "AllwdSaleDvc"))]
    pub allwd_sale_dvc: Vec<RetailerService8Code>,

    #[yaserde(rename = "XtrnlyTpSpprtd")]
    #[cfg_attr(feature = "serde", serde(rename = "XtrnlyTpSpprtd"))]
    pub xtrnly_tp_spprtd: Vec<Max1025Text>,
}

impl Validate for SaleToPOIProtocolParameter4 {}


#[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:catm.005.001.12")]

pub enum SaleTokenScope1Code {
    #[yaserde(rename = "MULT")]
    #[cfg_attr(feature = "serde", serde(rename = "MULT"))]
    Mult,
    #[yaserde(rename = "SNGL")]
    #[cfg_attr(feature = "serde", serde(rename = "SNGL"))]
    Sngl,
    __Unknown__(String),
}

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

impl Validate for SaleTokenScope1Code {}



#[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:catm.005.001.12")]
pub struct SecurityParameters17 {
    #[yaserde(rename = "ActnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ActnTp"))]
    pub actn_tp: TerminalManagementAction3Code,

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

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

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

    #[yaserde(rename = "SctyElmt")]
    #[cfg_attr(feature = "serde", serde(rename = "SctyElmt"))]
    pub scty_elmt: Vec<CryptographicKey19>,
}

impl Validate for SecurityParameters17 {}


#[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:catm.005.001.12")]
pub struct SensitiveMobileData1 {
    #[yaserde(rename = "MSISDN")]
    #[cfg_attr(feature = "serde", serde(rename = "MSISDN"))]
    pub msisdn: Max35NumericText,

    #[yaserde(rename = "IMSI")]
    #[cfg_attr(feature = "serde", serde(rename = "IMSI"))]
    pub imsi: Max35NumericText,

    #[yaserde(rename = "IMEI")]
    #[cfg_attr(feature = "serde", serde(rename = "IMEI"))]
    pub imei: Max35NumericText,
}

impl Validate for SensitiveMobileData1 {}


#[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:catm.005.001.12")]
pub struct ServiceProviderParameters5 {
    #[yaserde(rename = "ActnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ActnTp"))]
    pub actn_tp: TerminalManagementAction3Code,

    #[yaserde(rename = "SvcPrvdrId")]
    #[cfg_attr(feature = "serde", serde(rename = "SvcPrvdrId"))]
    pub svc_prvdr_id: Vec<GenericIdentification176>,

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

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

    #[yaserde(rename = "Hst")]
    #[cfg_attr(feature = "serde", serde(rename = "Hst"))]
    pub hst: Vec<AcquirerHostConfiguration11>,

    #[yaserde(rename = "NonFinActnSpprtd")]
    #[cfg_attr(feature = "serde", serde(rename = "NonFinActnSpprtd"))]
    pub non_fin_actn_spprtd: Vec<NonFinancialRequestType2Code>,
}

impl Validate for ServiceProviderParameters5 {}


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

    #[yaserde(rename = "DgstAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "DgstAlgo"))]
    pub dgst_algo: Vec<AlgorithmIdentification36>,

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

    #[yaserde(rename = "Cert")]
    #[cfg_attr(feature = "serde", serde(rename = "Cert"))]
    pub cert: Vec<Max5000Binary>,

    #[yaserde(rename = "Sgnr")]
    #[cfg_attr(feature = "serde", serde(rename = "Sgnr"))]
    pub sgnr: Vec<Signer8>,
}

impl Validate for SignedData9 {}


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

    #[yaserde(rename = "SgnrId")]
    #[cfg_attr(feature = "serde", serde(rename = "SgnrId"))]
    pub sgnr_id: Recipient13Choice,

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

    #[yaserde(rename = "SgndAttrbts")]
    #[cfg_attr(feature = "serde", serde(rename = "SgndAttrbts"))]
    pub sgnd_attrbts: Vec<GenericInformation1>,

    #[yaserde(rename = "SgntrAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "SgntrAlgo"))]
    pub sgntr_algo: AlgorithmIdentification33,

    #[yaserde(rename = "Sgntr")]
    #[cfg_attr(feature = "serde", serde(rename = "Sgntr"))]
    pub sgntr: Max3000Binary,
}

impl Validate for Signer8 {}


#[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:catm.005.001.12")]

pub enum SoundFormat1Code {
    #[yaserde(rename = "MSGR")]
    #[cfg_attr(feature = "serde", serde(rename = "MSGR"))]
    Msgr,
    #[yaserde(rename = "SNDR")]
    #[cfg_attr(feature = "serde", serde(rename = "SNDR"))]
    Sndr,
    #[yaserde(rename = "TEXT")]
    #[cfg_attr(feature = "serde", serde(rename = "TEXT"))]
    Text,
    __Unknown__(String),
}

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

impl Validate for SoundFormat1Code {}



#[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:catm.005.001.12")]
pub struct StoredValueAccount2 {
    #[yaserde(rename = "AcctTp")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctTp"))]
    pub acct_tp: StoredValueAccountType1Code,

    #[yaserde(rename = "IdTp")]
    #[cfg_attr(feature = "serde", serde(rename = "IdTp"))]
    pub id_tp: CardIdentificationType1Code,

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

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

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

    #[yaserde(rename = "OwnrNm")]
    #[cfg_attr(feature = "serde", serde(rename = "OwnrNm"))]
    pub ownr_nm: Max45Text,

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

    #[yaserde(rename = "NtryMd")]
    #[cfg_attr(feature = "serde", serde(rename = "NtryMd"))]
    pub ntry_md: CardDataReading8Code,

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

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

impl Validate for StoredValueAccount2 {}


#[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:catm.005.001.12")]

pub enum StoredValueAccountType1Code {
    #[yaserde(rename = "BNKA")]
    #[cfg_attr(feature = "serde", serde(rename = "BNKA"))]
    Bnka,
    #[yaserde(rename = "CWVC")]
    #[cfg_attr(feature = "serde", serde(rename = "CWVC"))]
    Cwvc,
    #[yaserde(rename = "CPYA")]
    #[cfg_attr(feature = "serde", serde(rename = "CPYA"))]
    Cpya,
    #[yaserde(rename = "ELMY")]
    #[cfg_attr(feature = "serde", serde(rename = "ELMY"))]
    Elmy,
    #[yaserde(rename = "GIFT")]
    #[cfg_attr(feature = "serde", serde(rename = "GIFT"))]
    Gift,
    #[yaserde(rename = "GCER")]
    #[cfg_attr(feature = "serde", serde(rename = "GCER"))]
    Gcer,
    #[yaserde(rename = "MLVC")]
    #[cfg_attr(feature = "serde", serde(rename = "MLVC"))]
    Mlvc,
    #[yaserde(rename = "OLVC")]
    #[cfg_attr(feature = "serde", serde(rename = "OLVC"))]
    Olvc,
    #[yaserde(rename = "MERC")]
    #[cfg_attr(feature = "serde", serde(rename = "MERC"))]
    Merc,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "PHON")]
    #[cfg_attr(feature = "serde", serde(rename = "PHON"))]
    Phon,
    #[yaserde(rename = "CARD")]
    #[cfg_attr(feature = "serde", serde(rename = "CARD"))]
    Card,
    #[yaserde(rename = "TRVL")]
    #[cfg_attr(feature = "serde", serde(rename = "TRVL"))]
    Trvl,
    __Unknown__(String),
}

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

impl Validate for StoredValueAccountType1Code {}



#[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:catm.005.001.12")]
pub struct SupplementaryData1 {
    #[yaserde(rename = "PlcAndNm")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcAndNm"))]
    pub plc_and_nm: Max350Text,

    #[yaserde(rename = "Envlp")]
    #[cfg_attr(feature = "serde", serde(rename = "Envlp"))]
    pub envlp: SupplementaryDataEnvelope1,
}

impl Validate for SupplementaryData1 {}


#[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:catm.005.001.12")]
pub struct SupplementaryDataEnvelope1 {}

impl Validate for SupplementaryDataEnvelope1 {}


#[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:catm.005.001.12")]

pub enum SupportedPaymentOption2Code {
    #[yaserde(rename = "PART")]
    #[cfg_attr(feature = "serde", serde(rename = "PART"))]
    Part,
    #[yaserde(rename = "MSRV")]
    #[cfg_attr(feature = "serde", serde(rename = "MSRV"))]
    Msrv,
    #[yaserde(rename = "INSI")]
    #[cfg_attr(feature = "serde", serde(rename = "INSI"))]
    Insi,
    #[yaserde(rename = "PINQ")]
    #[cfg_attr(feature = "serde", serde(rename = "PINQ"))]
    Pinq,
    __Unknown__(String),
}

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

impl Validate for SupportedPaymentOption2Code {}



#[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:catm.005.001.12")]
pub struct Tmsaction14 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: TerminalManagementAction5Code,

    #[yaserde(rename = "RmotAccs")]
    #[cfg_attr(feature = "serde", serde(rename = "RmotAccs"))]
    pub rmot_accs: NetworkParameters7,

    #[yaserde(rename = "Key")]
    #[cfg_attr(feature = "serde", serde(rename = "Key"))]
    pub key: Vec<CryptographicKey19>,

    #[yaserde(rename = "TermnlMgrId")]
    #[cfg_attr(feature = "serde", serde(rename = "TermnlMgrId"))]
    pub termnl_mgr_id: GenericIdentification176,

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

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

    #[yaserde(rename = "DataSetId")]
    #[cfg_attr(feature = "serde", serde(rename = "DataSetId"))]
    pub data_set_id: DataSetIdentification11,

    #[yaserde(rename = "CmpntTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CmpntTp"))]
    pub cmpnt_tp: Vec<DataSetCategory20Code>,

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

    #[yaserde(rename = "DlgtnScpDef")]
    #[cfg_attr(feature = "serde", serde(rename = "DlgtnScpDef"))]
    pub dlgtn_scp_def: Max3000Binary,

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

    #[yaserde(rename = "PrtctdDlgtnProof")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtctdDlgtnProof"))]
    pub prtctd_dlgtn_proof: ContentInformationType39,

    #[yaserde(rename = "Trggr")]
    #[cfg_attr(feature = "serde", serde(rename = "Trggr"))]
    pub trggr: TerminalManagementActionTrigger1Code,

    #[yaserde(rename = "AddtlPrc")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlPrc"))]
    pub addtl_prc: Vec<TerminalManagementAdditionalProcess1Code>,

    #[yaserde(rename = "ReTry")]
    #[cfg_attr(feature = "serde", serde(rename = "ReTry"))]
    pub re_try: ProcessRetry3,

    #[yaserde(rename = "TmCond")]
    #[cfg_attr(feature = "serde", serde(rename = "TmCond"))]
    pub tm_cond: ProcessTiming5,

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

    #[yaserde(rename = "KeyNcphrmntCert")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyNcphrmntCert"))]
    pub key_ncphrmnt_cert: Vec<Max10KBinary>,

    #[yaserde(rename = "ErrActn")]
    #[cfg_attr(feature = "serde", serde(rename = "ErrActn"))]
    pub err_actn: Vec<ErrorAction5>,

    #[yaserde(rename = "AddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
    pub addtl_inf: Vec<Max3000Binary>,

    #[yaserde(rename = "MsgItm")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgItm"))]
    pub msg_itm: Vec<MessageItemCondition2>,

    #[yaserde(rename = "DvcReq")]
    #[cfg_attr(feature = "serde", serde(rename = "DvcReq"))]
    pub dvc_req: DeviceRequest9,
}

impl Validate for Tmsaction14 {}


#[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:catm.005.001.12")]
pub struct Tmsheader1 {
    #[yaserde(rename = "DwnldTrf")]
    #[cfg_attr(feature = "serde", serde(rename = "DwnldTrf"))]
    pub dwnld_trf: TrueFalseIndicator,

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

    #[yaserde(rename = "XchgId")]
    #[cfg_attr(feature = "serde", serde(rename = "XchgId"))]
    pub xchg_id: 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: GenericIdentification176,

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

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

impl Validate for Tmsheader1 {}


#[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:catm.005.001.12")]
pub struct TmsprotocolParameters8 {
    #[yaserde(rename = "ActnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ActnTp"))]
    pub actn_tp: TerminalManagementAction3Code,

    #[yaserde(rename = "TermnlMgrId")]
    #[cfg_attr(feature = "serde", serde(rename = "TermnlMgrId"))]
    pub termnl_mgr_id: GenericIdentification176,

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

    #[yaserde(rename = "MntncSvc")]
    #[cfg_attr(feature = "serde", serde(rename = "MntncSvc"))]
    pub mntnc_svc: Vec<DataSetCategory10Code>,

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

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

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

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

    #[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 = "FileTrf")]
    #[cfg_attr(feature = "serde", serde(rename = "FileTrf"))]
    pub file_trf: TrueFalseIndicator,

    #[yaserde(rename = "MsgItm")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgItm"))]
    pub msg_itm: Vec<MessageItemCondition2>,

    #[yaserde(rename = "XtrnlyTpSpprtd")]
    #[cfg_attr(feature = "serde", serde(rename = "XtrnlyTpSpprtd"))]
    pub xtrnly_tp_spprtd: Vec<Max1025Text>,
}

impl Validate for TmsprotocolParameters8 {}


#[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:catm.005.001.12")]

pub enum TerminalManagementAction3Code {
    #[yaserde(rename = "CREA")]
    #[cfg_attr(feature = "serde", serde(rename = "CREA"))]
    Crea,
    #[yaserde(rename = "DELT")]
    #[cfg_attr(feature = "serde", serde(rename = "DELT"))]
    Delt,
    #[yaserde(rename = "UPDT")]
    #[cfg_attr(feature = "serde", serde(rename = "UPDT"))]
    Updt,
    __Unknown__(String),
}

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

impl Validate for TerminalManagementAction3Code {}



#[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:catm.005.001.12")]

pub enum TerminalManagementAction5Code {
    #[yaserde(rename = "DCTV")]
    #[cfg_attr(feature = "serde", serde(rename = "DCTV"))]
    Dctv,
    #[yaserde(rename = "DELT")]
    #[cfg_attr(feature = "serde", serde(rename = "DELT"))]
    Delt,
    #[yaserde(rename = "DWNL")]
    #[cfg_attr(feature = "serde", serde(rename = "DWNL"))]
    Dwnl,
    #[yaserde(rename = "INST")]
    #[cfg_attr(feature = "serde", serde(rename = "INST"))]
    Inst,
    #[yaserde(rename = "RSTR")]
    #[cfg_attr(feature = "serde", serde(rename = "RSTR"))]
    Rstr,
    #[yaserde(rename = "UPLD")]
    #[cfg_attr(feature = "serde", serde(rename = "UPLD"))]
    Upld,
    #[yaserde(rename = "UPDT")]
    #[cfg_attr(feature = "serde", serde(rename = "UPDT"))]
    Updt,
    #[yaserde(rename = "BIND")]
    #[cfg_attr(feature = "serde", serde(rename = "BIND"))]
    Bind,
    #[yaserde(rename = "RBND")]
    #[cfg_attr(feature = "serde", serde(rename = "RBND"))]
    Rbnd,
    #[yaserde(rename = "UBND")]
    #[cfg_attr(feature = "serde", serde(rename = "UBND"))]
    Ubnd,
    #[yaserde(rename = "ACTV")]
    #[cfg_attr(feature = "serde", serde(rename = "ACTV"))]
    Actv,
    #[yaserde(rename = "DEVR")]
    #[cfg_attr(feature = "serde", serde(rename = "DEVR"))]
    Devr,
    __Unknown__(String),
}

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

impl Validate for TerminalManagementAction5Code {}



#[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:catm.005.001.12")]

pub enum TerminalManagementActionResult5Code {
    #[yaserde(rename = "ACCD")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCD"))]
    Accd,
    #[yaserde(rename = "CNTE")]
    #[cfg_attr(feature = "serde", serde(rename = "CNTE"))]
    Cnte,
    #[yaserde(rename = "FMTE")]
    #[cfg_attr(feature = "serde", serde(rename = "FMTE"))]
    Fmte,
    #[yaserde(rename = "INVC")]
    #[cfg_attr(feature = "serde", serde(rename = "INVC"))]
    Invc,
    #[yaserde(rename = "LENE")]
    #[cfg_attr(feature = "serde", serde(rename = "LENE"))]
    Lene,
    #[yaserde(rename = "OVER")]
    #[cfg_attr(feature = "serde", serde(rename = "OVER"))]
    Over,
    #[yaserde(rename = "MISS")]
    #[cfg_attr(feature = "serde", serde(rename = "MISS"))]
    Miss,
    #[yaserde(rename = "NSUP")]
    #[cfg_attr(feature = "serde", serde(rename = "NSUP"))]
    Nsup,
    #[yaserde(rename = "SIGE")]
    #[cfg_attr(feature = "serde", serde(rename = "SIGE"))]
    Sige,
    #[yaserde(rename = "WARN")]
    #[cfg_attr(feature = "serde", serde(rename = "WARN"))]
    Warn,
    #[yaserde(rename = "SYNE")]
    #[cfg_attr(feature = "serde", serde(rename = "SYNE"))]
    Syne,
    #[yaserde(rename = "TIMO")]
    #[cfg_attr(feature = "serde", serde(rename = "TIMO"))]
    Timo,
    #[yaserde(rename = "UKDT")]
    #[cfg_attr(feature = "serde", serde(rename = "UKDT"))]
    Ukdt,
    #[yaserde(rename = "UKRF")]
    #[cfg_attr(feature = "serde", serde(rename = "UKRF"))]
    Ukrf,
    #[yaserde(rename = "INDP")]
    #[cfg_attr(feature = "serde", serde(rename = "INDP"))]
    Indp,
    #[yaserde(rename = "IDMP")]
    #[cfg_attr(feature = "serde", serde(rename = "IDMP"))]
    Idmp,
    #[yaserde(rename = "DPRU")]
    #[cfg_attr(feature = "serde", serde(rename = "DPRU"))]
    Dpru,
    #[yaserde(rename = "AERR")]
    #[cfg_attr(feature = "serde", serde(rename = "AERR"))]
    Aerr,
    #[yaserde(rename = "CMER")]
    #[cfg_attr(feature = "serde", serde(rename = "CMER"))]
    Cmer,
    #[yaserde(rename = "ULER")]
    #[cfg_attr(feature = "serde", serde(rename = "ULER"))]
    Uler,
    #[yaserde(rename = "SUCC")]
    #[cfg_attr(feature = "serde", serde(rename = "SUCC"))]
    Succ,
    __Unknown__(String),
}

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

impl Validate for TerminalManagementActionResult5Code {}



#[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:catm.005.001.12")]

pub enum TerminalManagementActionTrigger1Code {
    #[yaserde(rename = "DATE")]
    #[cfg_attr(feature = "serde", serde(rename = "DATE"))]
    Date,
    #[yaserde(rename = "HOST")]
    #[cfg_attr(feature = "serde", serde(rename = "HOST"))]
    Host,
    #[yaserde(rename = "MANU")]
    #[cfg_attr(feature = "serde", serde(rename = "MANU"))]
    Manu,
    #[yaserde(rename = "SALE")]
    #[cfg_attr(feature = "serde", serde(rename = "SALE"))]
    Sale,
    __Unknown__(String),
}

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

impl Validate for TerminalManagementActionTrigger1Code {}



#[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:catm.005.001.12")]

pub enum TerminalManagementAdditionalProcess1Code {
    #[yaserde(rename = "MANC")]
    #[cfg_attr(feature = "serde", serde(rename = "MANC"))]
    Manc,
    #[yaserde(rename = "RCNC")]
    #[cfg_attr(feature = "serde", serde(rename = "RCNC"))]
    Rcnc,
    #[yaserde(rename = "RSRT")]
    #[cfg_attr(feature = "serde", serde(rename = "RSRT"))]
    Rsrt,
    __Unknown__(String),
}

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

impl Validate for TerminalManagementAdditionalProcess1Code {}



#[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:catm.005.001.12")]

pub enum TerminalManagementErrorAction2Code {
    #[yaserde(rename = "SDSR")]
    #[cfg_attr(feature = "serde", serde(rename = "SDSR"))]
    Sdsr,
    #[yaserde(rename = "STOP")]
    #[cfg_attr(feature = "serde", serde(rename = "STOP"))]
    Stop,
    __Unknown__(String),
}

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

impl Validate for TerminalManagementErrorAction2Code {}



#[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:catm.005.001.12")]
pub struct TerminalPackageType5 {
    #[yaserde(rename = "POICmpntId")]
    #[cfg_attr(feature = "serde", serde(rename = "POICmpntId"))]
    pub poi_cmpnt_id: Vec<PointOfInteractionComponentIdentification2>,

    #[yaserde(rename = "Packg")]
    #[cfg_attr(feature = "serde", serde(rename = "Packg"))]
    pub packg: Vec<PackageType5>,
}

impl Validate for TerminalPackageType5 {}


#[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:catm.005.001.12")]

pub enum TimeUnit1Code {
    #[yaserde(rename = "DAYC")]
    #[cfg_attr(feature = "serde", serde(rename = "DAYC"))]
    Dayc,
    #[yaserde(rename = "HOUR")]
    #[cfg_attr(feature = "serde", serde(rename = "HOUR"))]
    Hour,
    #[yaserde(rename = "MINU")]
    #[cfg_attr(feature = "serde", serde(rename = "MINU"))]
    Minu,
    #[yaserde(rename = "MNTH")]
    #[cfg_attr(feature = "serde", serde(rename = "MNTH"))]
    Mnth,
    #[yaserde(rename = "SECO")]
    #[cfg_attr(feature = "serde", serde(rename = "SECO"))]
    Seco,
    #[yaserde(rename = "WEEK")]
    #[cfg_attr(feature = "serde", serde(rename = "WEEK"))]
    Week,
    #[yaserde(rename = "YEAR")]
    #[cfg_attr(feature = "serde", serde(rename = "YEAR"))]
    Year,
    __Unknown__(String),
}

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

impl Validate for TimeUnit1Code {}



#[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:catm.005.001.12")]
pub struct Token1 {
    #[yaserde(rename = "PmtTkn")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtTkn"))]
    pub pmt_tkn: Max19NumericText,

    #[yaserde(rename = "TknXpryDt")]
    #[cfg_attr(feature = "serde", serde(rename = "TknXpryDt"))]
    pub tkn_xpry_dt: Exact4NumericText,

    #[yaserde(rename = "TknRqstrId")]
    #[cfg_attr(feature = "serde", serde(rename = "TknRqstrId"))]
    pub tkn_rqstr_id: Max11NumericText,

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

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

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

impl Validate for Token1 {}


#[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:catm.005.001.12")]
pub struct Traceability8 {
    #[yaserde(rename = "RlayId")]
    #[cfg_attr(feature = "serde", serde(rename = "RlayId"))]
    pub rlay_id: GenericIdentification177,

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

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

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


#[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:catm.005.001.12")]
pub struct TrackData2 {
    #[yaserde(rename = "TrckNb")]
    #[cfg_attr(feature = "serde", serde(rename = "TrckNb"))]
    pub trck_nb: Number,

    #[yaserde(rename = "TrckFrmt")]
    #[cfg_attr(feature = "serde", serde(rename = "TrckFrmt"))]
    pub trck_frmt: TrackFormat1Code,

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

impl Validate for TrackData2 {}


#[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:catm.005.001.12")]

pub enum TrackFormat1Code {
    #[yaserde(rename = "AAMV")]
    #[cfg_attr(feature = "serde", serde(rename = "AAMV"))]
    Aamv,
    #[yaserde(rename = "CMC7")]
    #[cfg_attr(feature = "serde", serde(rename = "CMC7"))]
    Cmc7,
    E13B,
    #[yaserde(rename = "ISOF")]
    #[cfg_attr(feature = "serde", serde(rename = "ISOF"))]
    Isof,
    #[yaserde(rename = "JIS1")]
    #[cfg_attr(feature = "serde", serde(rename = "JIS1"))]
    Jis1,
    #[yaserde(rename = "JIS2")]
    #[cfg_attr(feature = "serde", serde(rename = "JIS2"))]
    Jis2,
    __Unknown__(String),
}

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

impl Validate for TrackFormat1Code {}



#[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:catm.005.001.12")]

pub enum TransactionChannel5Code {
    #[yaserde(rename = "MAIL")]
    #[cfg_attr(feature = "serde", serde(rename = "MAIL"))]
    Mail,
    #[yaserde(rename = "TLPH")]
    #[cfg_attr(feature = "serde", serde(rename = "TLPH"))]
    Tlph,
    #[yaserde(rename = "ECOM")]
    #[cfg_attr(feature = "serde", serde(rename = "ECOM"))]
    Ecom,
    #[yaserde(rename = "TVPY")]
    #[cfg_attr(feature = "serde", serde(rename = "TVPY"))]
    Tvpy,
    #[yaserde(rename = "SECM")]
    #[cfg_attr(feature = "serde", serde(rename = "SECM"))]
    Secm,
    #[yaserde(rename = "MOBL")]
    #[cfg_attr(feature = "serde", serde(rename = "MOBL"))]
    Mobl,
    #[yaserde(rename = "MPOS")]
    #[cfg_attr(feature = "serde", serde(rename = "MPOS"))]
    Mpos,
    __Unknown__(String),
}

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

impl Validate for TransactionChannel5Code {}



#[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:catm.005.001.12")]

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

impl Validate for TransactionEnvironment1Code {}



#[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:catm.005.001.12")]
pub struct TransactionVerificationResult4 {
    #[yaserde(rename = "Mtd")]
    #[cfg_attr(feature = "serde", serde(rename = "Mtd"))]
    pub mtd: AuthenticationMethod6Code,

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

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

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

impl Validate for TransactionVerificationResult4 {}


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

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

pub enum TypeOfAmount8Code {
    #[yaserde(rename = "ACTL")]
    #[cfg_attr(feature = "serde", serde(rename = "ACTL"))]
    Actl,
    #[yaserde(rename = "ESTM")]
    #[cfg_attr(feature = "serde", serde(rename = "ESTM"))]
    Estm,
    #[yaserde(rename = "MAXI")]
    #[cfg_attr(feature = "serde", serde(rename = "MAXI"))]
    Maxi,
    #[yaserde(rename = "DFLT")]
    #[cfg_attr(feature = "serde", serde(rename = "DFLT"))]
    Dflt,
    #[yaserde(rename = "RPLT")]
    #[cfg_attr(feature = "serde", serde(rename = "RPLT"))]
    Rplt,
    #[yaserde(rename = "INCR")]
    #[cfg_attr(feature = "serde", serde(rename = "INCR"))]
    Incr,
    #[yaserde(rename = "DECR")]
    #[cfg_attr(feature = "serde", serde(rename = "DECR"))]
    Decr,
    #[yaserde(rename = "RESD")]
    #[cfg_attr(feature = "serde", serde(rename = "RESD"))]
    Resd,
    __Unknown__(String),
}

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

impl Validate for TypeOfAmount8Code {}



#[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:catm.005.001.12")]

pub enum UserInterface9Code {
    #[yaserde(rename = "CDSP")]
    #[cfg_attr(feature = "serde", serde(rename = "CDSP"))]
    Cdsp,
    #[yaserde(rename = "CRCP")]
    #[cfg_attr(feature = "serde", serde(rename = "CRCP"))]
    Crcp,
    #[yaserde(rename = "MDSP")]
    #[cfg_attr(feature = "serde", serde(rename = "MDSP"))]
    Mdsp,
    #[yaserde(rename = "MRCP")]
    #[cfg_attr(feature = "serde", serde(rename = "MRCP"))]
    Mrcp,
    #[yaserde(rename = "CRDO")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDO"))]
    Crdo,
    #[yaserde(rename = "CSTM")]
    #[cfg_attr(feature = "serde", serde(rename = "CSTM"))]
    Cstm,
    __Unknown__(String),
}

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

impl Validate for UserInterface9Code {}



#[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:catm.005.001.12")]
pub struct Vehicle1 {
    #[yaserde(rename = "VhclNb")]
    #[cfg_attr(feature = "serde", serde(rename = "VhclNb"))]
    pub vhcl_nb: Max35NumericText,

    #[yaserde(rename = "TrlrNb")]
    #[cfg_attr(feature = "serde", serde(rename = "TrlrNb"))]
    pub trlr_nb: Max35NumericText,

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

    #[yaserde(rename = "VhclTagNtryMd")]
    #[cfg_attr(feature = "serde", serde(rename = "VhclTagNtryMd"))]
    pub vhcl_tag_ntry_md: CardDataReading5Code,

    #[yaserde(rename = "UnitNb")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitNb"))]
    pub unit_nb: Max35NumericText,

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

    #[yaserde(rename = "Odmtr")]
    #[cfg_attr(feature = "serde", serde(rename = "Odmtr"))]
    pub odmtr: DecimalNumber,

    #[yaserde(rename = "Hbmtr")]
    #[cfg_attr(feature = "serde", serde(rename = "Hbmtr"))]
    pub hbmtr: DecimalNumber,

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

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

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

    #[yaserde(rename = "DrvrOrVhclCard")]
    #[cfg_attr(feature = "serde", serde(rename = "DrvrOrVhclCard"))]
    pub drvr_or_vhcl_card: PlainCardData17,

    #[yaserde(rename = "AddtlVhclData")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlVhclData"))]
    pub addtl_vhcl_data: Vec<Vehicle2>,
}

impl Validate for Vehicle1 {}


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

    #[yaserde(rename = "NtryMd")]
    #[cfg_attr(feature = "serde", serde(rename = "NtryMd"))]
    pub ntry_md: CardDataReading5Code,

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

impl Validate for Vehicle2 {}


#[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:catm.005.001.12")]

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

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

impl Validate for Verification1Code {}

impl crate::MxMessage for Document {
    const BUSINESS_AREA: crate::BusinessArea = crate::BusinessArea::catm;
    const FUNCTIONALITY: &'static str = "005";
    const VARIANT: &'static str = "001";
    const VERSION: &'static str = "12";
    const MESSAGE_NAME: &'static str = "catm.005.001.12";
    const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:catm.005.001.12";
}