#![allow(clippy::all)]
#![allow(non_snake_case, non_camel_case_types, dead_code, unused_imports)]
#![allow(non_local_definitions)]
use std::str::FromStr;
use crate::validate::Validate;
use yaserde_derive::{YaDeserialize, YaSerialize};
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.003.001.15")]
pub struct AcceptorConfiguration15 {
#[yaserde(rename = "TermnlMgrId")]
#[cfg_attr(feature = "serde", serde(rename = "TermnlMgrId"))]
pub termnl_mgr_id: GenericIdentification176,
#[yaserde(rename = "POIGrpId")]
#[cfg_attr(feature = "serde", serde(rename = "POIGrpId"))]
pub poi_grp_id: Vec<Max35Text>,
#[yaserde(rename = "DataSet")]
#[cfg_attr(feature = "serde", serde(rename = "DataSet"))]
pub data_set: Vec<AcceptorConfigurationDataSet7>,
}
impl Validate for AcceptorConfiguration15 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
pub struct AcceptorConfigurationUpdateV15 {
#[yaserde(rename = "Hdr")]
#[cfg_attr(feature = "serde", serde(rename = "Hdr"))]
pub hdr: Tmsheader1,
#[yaserde(rename = "AccptrCfgtn")]
#[cfg_attr(feature = "serde", serde(rename = "AccptrCfgtn"))]
pub accptr_cfgtn: AcceptorConfiguration15,
#[yaserde(rename = "SctyTrlr")]
#[cfg_attr(feature = "serde", serde(rename = "SctyTrlr"))]
pub scty_trlr: ContentInformationType38,
}
impl Validate for AcceptorConfigurationUpdateV15 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.003.001.15")]
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.003.001.15")]
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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
pub struct Document {
#[yaserde(rename = "AccptrCfgtnUpd")]
#[cfg_attr(feature = "serde", serde(rename = "AccptrCfgtnUpd"))]
pub accptr_cfgtn_upd: AcceptorConfigurationUpdateV15,
}
impl Validate for Document {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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 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 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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.003.001.15")]
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(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 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 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 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 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 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 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 Max5000Binary (pub String);
crate::simple_type!(Max5000Binary);
impl Validate for Max5000Binary {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 5000 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 5000 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max500Binary (pub String);
crate::simple_type!(Max500Binary);
impl Validate for Max500Binary {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 500 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 500 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max500Text (pub String);
crate::simple_type!(Max500Text);
impl Validate for Max500Text {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 500 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 500 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max6Text (pub String);
crate::simple_type!(Max6Text);
impl Validate for Max6Text {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 6 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 6 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max70Text (pub String);
crate::simple_type!(Max70Text);
impl Validate for Max70Text {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 70 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 70 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct 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.003.001.15")]
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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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 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 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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.003.001.15")]
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.003.001.15")]
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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.003.001.15")]
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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
pub struct Parameter7 {
#[yaserde(rename = "InitlstnVctr")]
#[cfg_attr(feature = "serde", serde(rename = "InitlstnVctr"))]
pub initlstn_vctr: Max500Binary,
#[yaserde(rename = "BPddg")]
#[cfg_attr(feature = "serde", serde(rename = "BPddg"))]
pub b_pddg: BytePadding1Code,
}
impl Validate for Parameter7 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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)]
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.003.001.15")]
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.003.001.15")]
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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.003.001.15")]
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.003.001.15")]
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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.003.001.15")]
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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.003.001.15")]
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.003.001.15")]
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.003.001.15")]
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)]
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.003.001.15")]
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 {}
impl crate::MxMessage for Document {
const BUSINESS_AREA: crate::BusinessArea = crate::BusinessArea::catm;
const FUNCTIONALITY: &'static str = "003";
const VARIANT: &'static str = "001";
const VERSION: &'static str = "15";
const MESSAGE_NAME: &'static str = "catm.003.001.15";
const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:catm.003.001.15";
}