iso_20022_caad/
caad_002_001_02.rs

1// Copyright 2023 Emergent Financial, LLC - All Rights Reserved
2//
3//
4// This software is licensed under the Emergent Financial Limited Public License Version 1.0
5// (EF-LPLv1). You may use, copy, modify, and distribute this software under the terms and
6// conditions of the EF-LPL. For more information, please refer to the full text of the license
7// at https://github.com/emergentfinancial/ef-lpl.
8//
9//
10// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS
11// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
12// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
13// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
14// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
15// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
16//
17// See ISO-20022 Intellectual Property Rights Policy at
18// <https://www.iso20022.org/intellectual-property-rights>
19// for more information.
20
21use validator::Validate;
22
23::lazy_static::lazy_static! {
24    static ref EXACT_6_ALPHA_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[a-zA-Z0-9\s]{6}"#).unwrap();
25}
26
27::lazy_static::lazy_static! {
28    static ref MAX_15_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,15}"#).unwrap();
29}
30
31::lazy_static::lazy_static! {
32    static ref MAX_2_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,2}"#).unwrap();
33}
34
35::lazy_static::lazy_static! {
36    static ref MAX_8_HEX_BINARY_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"([0-9A-F][0-9A-F]){1,8}"#).unwrap();
37}
38
39::lazy_static::lazy_static! {
40    static ref ISO_MAX_3_A_LANGUAGE_CODE_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[a-z]{2,3}"#).unwrap();
41}
42
43::lazy_static::lazy_static! {
44    static ref EXTERNAL_ENCRYPTED_ELEMENT_IDENTIFICATION_1_CODE_REGEX: ::regex::Regex = ::regex::Regex::new(r#"([0-9A-F][0-9A-F]){1,3}"#).unwrap();
45}
46
47::lazy_static::lazy_static! {
48    static ref ISO_8583_RESPONSE_CODE_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9A-Z]{2,2}"#).unwrap();
49}
50
51::lazy_static::lazy_static! {
52    static ref MAX_8_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,8}"#).unwrap();
53}
54
55::lazy_static::lazy_static! {
56    static ref MAX_3_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,3}"#).unwrap();
57}
58
59::lazy_static::lazy_static! {
60    static ref MAX_5000_BINARY_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Za-z0-9+/]{4}*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?"#).unwrap();
61}
62
63::lazy_static::lazy_static! {
64    static ref MAX_500_BINARY_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Za-z0-9+/]{4}*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?"#).unwrap();
65}
66
67::lazy_static::lazy_static! {
68    static ref ISO_3_NUMERIC_CURRENCY_CODE_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{3,3}"#).unwrap();
69}
70
71::lazy_static::lazy_static! {
72    static ref EXACT_1_HEX_BINARY_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"([0-9A-F][0-9A-F]){1}"#).unwrap();
73}
74
75::lazy_static::lazy_static! {
76    static ref MAX_9999_HEX_BINARY_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"([0-9A-F][0-9A-F]){1,9999}"#).unwrap();
77}
78
79::lazy_static::lazy_static! {
80    static ref MAX_11_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,11}"#).unwrap();
81}
82
83::lazy_static::lazy_static! {
84    static ref MAX_4_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,4}"#).unwrap();
85}
86
87::lazy_static::lazy_static! {
88    static ref MAX_100_K_BINARY_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Za-z0-9+/]{4}*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?"#).unwrap();
89}
90
91::lazy_static::lazy_static! {
92    static ref MAX_5_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,5}"#).unwrap();
93}
94
95::lazy_static::lazy_static! {
96    static ref MIN_5_MAX_16_BINARY_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Za-z0-9+/]{4}*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?"#).unwrap();
97}
98
99::lazy_static::lazy_static! {
100    static ref MAX_35_BINARY_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Za-z0-9+/]{4}*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?"#).unwrap();
101}
102
103::lazy_static::lazy_static! {
104    static ref ISO_3_NUMERIC_COUNTRY_CODE_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{3,3}"#).unwrap();
105}
106
107::lazy_static::lazy_static! {
108    static ref MAX_32_HEX_BINARY_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"([0-9A-F][0-9A-F]){1,32}"#).unwrap();
109}
110
111::lazy_static::lazy_static! {
112    static ref MAX_12_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,12}"#).unwrap();
113}
114
115::lazy_static::lazy_static! {
116    static ref ISO_MAX_3_A_COUNTRY_CODE_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Z]{2,3}"#).unwrap();
117}
118
119/// Returns the namespace of the schema
120pub fn namespace() -> String {
121    "urn:iso:std:iso:20022:tech:xsd:caad.002.001.02".to_string()
122}
123
124#[derive(
125    Debug,
126    Default,
127    Clone,
128    PartialEq,
129    ::serde::Serialize,
130    ::serde::Deserialize,
131    ::derive_builder::Builder,
132    ::validator::Validate,
133)]
134pub struct Context17 {
135    #[serde(rename = "TxCntxt", skip_serializing_if = "Option::is_none")]
136    pub tx_cntxt: Option<TransactionContext10>,
137}
138#[derive(
139    Debug,
140    Default,
141    Clone,
142    PartialEq,
143    ::serde::Serialize,
144    ::serde::Deserialize,
145    ::derive_builder::Builder,
146    ::validator::Validate,
147)]
148pub struct Max20KText {
149    #[validate(length(min = 1, max = 20000,))]
150    #[serde(rename = "$text")]
151    pub value: String,
152}
153#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
154pub enum PartyType17Code {
155    #[serde(rename = "OTHN")]
156    Othn,
157    #[serde(rename = "OTHP")]
158    Othp,
159    #[serde(rename = "ACQR")]
160    Acqr,
161    #[serde(rename = "ACQP")]
162    Acqp,
163    #[serde(rename = "CISS")]
164    Ciss,
165    #[serde(rename = "CISP")]
166    Cisp,
167    #[serde(rename = "AGNT")]
168    Agnt,
169    #[default]
170    Unknown,
171}
172#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
173pub enum PartyType26Code {
174    #[serde(rename = "ACCP")]
175    Accp,
176    #[serde(rename = "ACQR")]
177    Acqr,
178    #[serde(rename = "ICCA")]
179    Icca,
180    #[serde(rename = "CISS")]
181    Ciss,
182    #[serde(rename = "DLIS")]
183    Dlis,
184    #[serde(rename = "AGNT")]
185    Agnt,
186    #[serde(rename = "OTHN")]
187    Othn,
188    #[serde(rename = "OTHP")]
189    Othp,
190    #[default]
191    Unknown,
192}
193#[derive(
194    Debug,
195    Default,
196    Clone,
197    PartialEq,
198    ::serde::Serialize,
199    ::serde::Deserialize,
200    ::derive_builder::Builder,
201    ::validator::Validate,
202)]
203pub struct SettlementService4 {
204    #[serde(rename = "SttlmSvcApld", skip_serializing_if = "Option::is_none")]
205    pub sttlm_svc_apld: Option<SettlementServiceMode1>,
206    #[serde(rename = "SttlmSvcDts", skip_serializing_if = "Option::is_none")]
207    pub sttlm_svc_dts: Option<SettlementServiceDate2>,
208    #[serde(rename = "SttlmRptgNtty", skip_serializing_if = "Option::is_none")]
209    pub sttlm_rptg_ntty: Option<SettlementReportingEntity1>,
210    #[validate(length(min = 0,))]
211    #[serde(rename = "AddtlSttlmInf", default)]
212    pub addtl_sttlm_inf: Vec<AdditionalData1>,
213}
214#[derive(
215    Debug,
216    Default,
217    Clone,
218    PartialEq,
219    ::serde::Serialize,
220    ::serde::Deserialize,
221    ::derive_builder::Builder,
222    ::validator::Validate,
223)]
224pub struct Traceability9 {
225    #[validate]
226    #[serde(rename = "RlayId")]
227    pub rlay_id: GenericIdentification183,
228    #[serde(rename = "TracDtTmIn", skip_serializing_if = "Option::is_none")]
229    pub trac_dt_tm_in: Option<IsoDateTime>,
230    #[serde(rename = "TracDtTmOut", skip_serializing_if = "Option::is_none")]
231    pub trac_dt_tm_out: Option<IsoDateTime>,
232}
233#[derive(
234    Debug,
235    Default,
236    Clone,
237    PartialEq,
238    ::serde::Serialize,
239    ::serde::Deserialize,
240    ::derive_builder::Builder,
241    ::validator::Validate,
242)]
243pub struct BatchManagementResponse2<
244    A: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
245> {
246    #[validate]
247    #[serde(rename = "Envt")]
248    pub envt: Environment33,
249    #[serde(rename = "Cntxt", skip_serializing_if = "Option::is_none")]
250    pub cntxt: Option<Context17>,
251    #[validate]
252    #[serde(rename = "Tx")]
253    pub tx: Transaction151,
254    #[validate]
255    #[serde(rename = "PrcgRslt")]
256    pub prcg_rslt: ProcessingResult13,
257    #[validate(length(min = 0,))]
258    #[serde(rename = "PrtctdData", default)]
259    pub prtctd_data: Vec<ProtectedData1>,
260    #[validate(length(min = 0,))]
261    #[serde(rename = "SplmtryData", default)]
262    pub splmtry_data: Vec<SupplementaryData1<A>>,
263}
264#[derive(
265    Debug,
266    Default,
267    Clone,
268    PartialEq,
269    ::serde::Serialize,
270    ::serde::Deserialize,
271    ::derive_builder::Builder,
272    ::validator::Validate,
273)]
274pub struct Exact6AlphaNumericText {
275    #[validate(regex = "EXACT_6_ALPHA_NUMERIC_TEXT_REGEX")]
276    #[serde(rename = "$text")]
277    pub value: String,
278}
279#[derive(
280    Debug,
281    Default,
282    Clone,
283    PartialEq,
284    ::serde::Serialize,
285    ::serde::Deserialize,
286    ::derive_builder::Builder,
287    ::validator::Validate,
288)]
289pub struct Kek6 {
290    #[serde(rename = "Vrsn", skip_serializing_if = "Option::is_none")]
291    pub vrsn: Option<Number>,
292    #[validate]
293    #[serde(rename = "KEKId")]
294    pub kek_id: KekIdentifier6,
295    #[validate]
296    #[serde(rename = "KeyNcrptnAlgo")]
297    pub key_ncrptn_algo: AlgorithmIdentification28,
298    #[serde(rename = "NcrptdKey", skip_serializing_if = "Option::is_none")]
299    pub ncrptd_key: Option<Max500Binary>,
300}
301#[derive(
302    Debug,
303    Default,
304    Clone,
305    PartialEq,
306    ::serde::Serialize,
307    ::serde::Deserialize,
308    ::derive_builder::Builder,
309    ::validator::Validate,
310)]
311pub struct EnvelopedData6 {
312    #[serde(rename = "Vrsn", skip_serializing_if = "Option::is_none")]
313    pub vrsn: Option<Number>,
314    #[validate(length(min = 1,))]
315    #[serde(rename = "Rcpt", default)]
316    pub rcpt: Vec<Recipient7Choice>,
317    #[serde(rename = "NcrptdCntt", skip_serializing_if = "Option::is_none")]
318    pub ncrptd_cntt: Option<EncryptedContent5>,
319}
320#[derive(
321    Debug,
322    Default,
323    Clone,
324    PartialEq,
325    ::serde::Serialize,
326    ::serde::Deserialize,
327    ::derive_builder::Builder,
328    ::validator::Validate,
329)]
330pub struct TrueFalseIndicator {
331    #[serde(rename = "$text")]
332    pub value: bool,
333}
334#[derive(
335    Debug,
336    Default,
337    Clone,
338    PartialEq,
339    ::serde::Serialize,
340    ::serde::Deserialize,
341    ::derive_builder::Builder,
342    ::validator::Validate,
343)]
344pub struct Jurisdiction2 {
345    #[serde(rename = "DmstInd", skip_serializing_if = "Option::is_none")]
346    pub dmst_ind: Option<TrueFalseIndicator>,
347    #[serde(rename = "DmstQlfctn", skip_serializing_if = "Option::is_none")]
348    pub dmst_qlfctn: Option<Max35Text>,
349}
350#[derive(
351    Debug,
352    Default,
353    Clone,
354    PartialEq,
355    ::serde::Serialize,
356    ::serde::Deserialize,
357    ::derive_builder::Builder,
358    ::validator::Validate,
359)]
360pub struct Max15NumericText {
361    #[validate(regex = "MAX_15_NUMERIC_TEXT_REGEX")]
362    #[serde(rename = "$text")]
363    pub value: String,
364}
365#[derive(
366    Debug,
367    Default,
368    Clone,
369    PartialEq,
370    ::serde::Serialize,
371    ::serde::Deserialize,
372    ::derive_builder::Builder,
373    ::validator::Validate,
374)]
375pub struct EncryptedContent5 {
376    #[serde(rename = "CnttTp")]
377    pub cntt_tp: ContentType2Code,
378    #[validate]
379    #[serde(rename = "CnttNcrptnAlgo")]
380    pub cntt_ncrptn_algo: AlgorithmIdentification25,
381    #[validate(length(min = 1,))]
382    #[serde(rename = "NcrptdDataElmt", default)]
383    pub ncrptd_data_elmt: Vec<EncryptedDataElement1>,
384}
385#[derive(
386    Debug,
387    Default,
388    Clone,
389    PartialEq,
390    ::serde::Serialize,
391    ::serde::Deserialize,
392    ::derive_builder::Builder,
393    ::validator::Validate,
394)]
395pub struct Max2NumericText {
396    #[validate(regex = "MAX_2_NUMERIC_TEXT_REGEX")]
397    #[serde(rename = "$text")]
398    pub value: String,
399}
400#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
401pub enum Algorithm20Code {
402    #[serde(rename = "HS25")]
403    Hs25,
404    #[serde(rename = "HS38")]
405    Hs38,
406    #[serde(rename = "HS51")]
407    Hs51,
408    #[default]
409    Unknown,
410}
411#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
412pub enum Response8Code {
413    #[serde(rename = "PRCS")]
414    Prcs,
415    #[serde(rename = "UNPR")]
416    Unpr,
417    #[serde(rename = "UNRV")]
418    Unrv,
419    #[serde(rename = "REJT")]
420    Rejt,
421    #[serde(rename = "TECH")]
422    Tech,
423    #[serde(rename = "OTHN")]
424    Othn,
425    #[serde(rename = "OTHP")]
426    Othp,
427    #[default]
428    Unknown,
429}
430#[derive(
431    Debug,
432    Default,
433    Clone,
434    PartialEq,
435    ::serde::Serialize,
436    ::serde::Deserialize,
437    ::derive_builder::Builder,
438    ::validator::Validate,
439)]
440pub struct IsoTime {
441    #[serde(rename = "$value")]
442    pub value: ::chrono::naive::NaiveTime,
443}
444#[derive(
445    Debug,
446    Default,
447    Clone,
448    PartialEq,
449    ::serde::Serialize,
450    ::serde::Deserialize,
451    ::derive_builder::Builder,
452    ::validator::Validate,
453)]
454pub struct Max140Text {
455    #[validate(length(min = 1, max = 140,))]
456    #[serde(rename = "$text")]
457    pub value: String,
458}
459#[derive(
460    Debug,
461    Default,
462    Clone,
463    PartialEq,
464    ::serde::Serialize,
465    ::serde::Deserialize,
466    ::derive_builder::Builder,
467    ::validator::Validate,
468)]
469pub struct TransactionContext10 {
470    #[serde(rename = "CardPrgrmmApld", skip_serializing_if = "Option::is_none")]
471    pub card_prgrmm_apld: Option<CardProgrammeMode3>,
472    #[serde(rename = "Jursdctn", skip_serializing_if = "Option::is_none")]
473    pub jursdctn: Option<Jurisdiction2>,
474    #[serde(rename = "SttlmSvc", skip_serializing_if = "Option::is_none")]
475    pub sttlm_svc: Option<SettlementService4>,
476    #[serde(rename = "Rcncltn", skip_serializing_if = "Option::is_none")]
477    pub rcncltn: Option<Reconciliation3>,
478    #[validate(length(min = 0,))]
479    #[serde(rename = "AddtlData", default)]
480    pub addtl_data: Vec<AdditionalData1>,
481}
482#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
483pub enum TypeOfAmount21Code {
484    #[serde(rename = "INTC")]
485    Intc,
486    #[serde(rename = "FEEP")]
487    Feep,
488    #[serde(rename = "OTHN")]
489    Othn,
490    #[serde(rename = "OTHP")]
491    Othp,
492    #[serde(rename = "FEEA")]
493    Feea,
494    #[serde(rename = "CSIF")]
495    Csif,
496    #[serde(rename = "MXIF")]
497    Mxif,
498    #[serde(rename = "MNIF")]
499    Mnif,
500    #[default]
501    Unknown,
502}
503#[derive(
504    Debug,
505    Default,
506    Clone,
507    PartialEq,
508    ::serde::Serialize,
509    ::serde::Deserialize,
510    ::derive_builder::Builder,
511    ::validator::Validate,
512)]
513pub struct SettlementServiceDate2 {
514    #[serde(rename = "ReqdSttlmDt", skip_serializing_if = "Option::is_none")]
515    pub reqd_sttlm_dt: Option<IsoDate>,
516    #[serde(rename = "DfrrdSttlmInd", skip_serializing_if = "Option::is_none")]
517    pub dfrrd_sttlm_ind: Option<TrueFalseIndicator>,
518    #[serde(rename = "SttlmDt", skip_serializing_if = "Option::is_none")]
519    pub sttlm_dt: Option<IsoDate>,
520    #[serde(rename = "SttlmTm", skip_serializing_if = "Option::is_none")]
521    pub sttlm_tm: Option<IsoTime>,
522    #[serde(rename = "SttlmPrd", skip_serializing_if = "Option::is_none")]
523    pub sttlm_prd: Option<Max35Text>,
524    #[serde(rename = "SttlmCutOffTm", skip_serializing_if = "Option::is_none")]
525    pub sttlm_cut_off_tm: Option<IsoDateTime>,
526}
527#[derive(
528    Debug,
529    Default,
530    Clone,
531    PartialEq,
532    ::serde::Serialize,
533    ::serde::Deserialize,
534    ::derive_builder::Builder,
535    ::validator::Validate,
536)]
537pub struct SupplementaryData1<
538    A: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
539> {
540    #[serde(rename = "PlcAndNm", skip_serializing_if = "Option::is_none")]
541    pub plc_and_nm: Option<Max350Text>,
542    #[validate]
543    #[serde(rename = "Envlp")]
544    pub envlp: SupplementaryDataEnvelope1<A>,
545}
546#[derive(
547    Debug,
548    Default,
549    Clone,
550    PartialEq,
551    ::serde::Serialize,
552    ::serde::Deserialize,
553    ::derive_builder::Builder,
554    ::validator::Validate,
555)]
556pub struct Exact12Text {
557    #[serde(rename = "$text")]
558    pub value: String,
559}
560#[derive(
561    Debug,
562    Default,
563    Clone,
564    PartialEq,
565    ::serde::Serialize,
566    ::serde::Deserialize,
567    ::derive_builder::Builder,
568    ::validator::Validate,
569)]
570pub struct Max8HexBinaryText {
571    #[validate(regex = "MAX_8_HEX_BINARY_TEXT_REGEX")]
572    #[serde(rename = "$text")]
573    pub value: String,
574}
575#[derive(
576    Debug,
577    Default,
578    Clone,
579    PartialEq,
580    ::serde::Serialize,
581    ::serde::Deserialize,
582    ::derive_builder::Builder,
583    ::validator::Validate,
584)]
585pub struct Parameter14 {
586    #[serde(rename = "NcrptnFrmt", skip_serializing_if = "Option::is_none")]
587    pub ncrptn_frmt: Option<EncryptionFormat3Code>,
588    #[serde(rename = "InitlstnVctr", skip_serializing_if = "Option::is_none")]
589    pub initlstn_vctr: Option<Max500Binary>,
590    #[serde(rename = "BPddg", skip_serializing_if = "Option::is_none")]
591    pub b_pddg: Option<BytePadding1Code>,
592}
593#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
594pub enum AttributeType1Code {
595    #[serde(rename = "CNAT")]
596    Cnat,
597    #[serde(rename = "LATT")]
598    Latt,
599    #[serde(rename = "OATT")]
600    Oatt,
601    #[serde(rename = "OUAT")]
602    Ouat,
603    #[serde(rename = "CATT")]
604    Catt,
605    #[default]
606    Unknown,
607}
608#[derive(
609    Debug,
610    Default,
611    Clone,
612    PartialEq,
613    ::serde::Serialize,
614    ::serde::Deserialize,
615    ::derive_builder::Builder,
616    ::validator::Validate,
617)]
618pub struct IsoMax3ALanguageCode {
619    #[validate(regex = "ISO_MAX_3_A_LANGUAGE_CODE_REGEX")]
620    #[serde(rename = "$text")]
621    pub value: String,
622}
623#[derive(
624    Debug,
625    Default,
626    Clone,
627    PartialEq,
628    ::serde::Serialize,
629    ::serde::Deserialize,
630    ::derive_builder::Builder,
631    ::validator::Validate,
632)]
633pub struct Max500Text {
634    #[validate(length(min = 1, max = 500,))]
635    #[serde(rename = "$text")]
636    pub value: String,
637}
638#[derive(
639    Debug,
640    Default,
641    Clone,
642    PartialEq,
643    ::serde::Serialize,
644    ::serde::Deserialize,
645    ::derive_builder::Builder,
646    ::validator::Validate,
647)]
648pub struct CorrectionIdentification1 {
649    #[serde(rename = "Ind", skip_serializing_if = "Option::is_none")]
650    pub ind: Option<TrueFalseIndicator>,
651    #[serde(rename = "Dt", skip_serializing_if = "Option::is_none")]
652    pub dt: Option<IsoDate>,
653    #[serde(rename = "Tm", skip_serializing_if = "Option::is_none")]
654    pub tm: Option<IsoTime>,
655}
656#[derive(
657    Debug,
658    Default,
659    Clone,
660    PartialEq,
661    ::serde::Serialize,
662    ::serde::Deserialize,
663    ::derive_builder::Builder,
664    ::validator::Validate,
665)]
666pub struct ExternalEncryptedElementIdentification1Code {
667    #[validate(regex = "EXTERNAL_ENCRYPTED_ELEMENT_IDENTIFICATION_1_CODE_REGEX")]
668    #[serde(rename = "$text")]
669    pub value: String,
670}
671#[derive(
672    Debug,
673    Default,
674    Clone,
675    PartialEq,
676    ::serde::Serialize,
677    ::serde::Deserialize,
678    ::derive_builder::Builder,
679    ::validator::Validate,
680)]
681pub struct Max70Text {
682    #[validate(length(min = 1, max = 70,))]
683    #[serde(rename = "$text")]
684    pub value: String,
685}
686#[derive(
687    Debug,
688    Default,
689    Clone,
690    PartialEq,
691    ::serde::Serialize,
692    ::serde::Deserialize,
693    ::derive_builder::Builder,
694    ::validator::Validate,
695)]
696pub struct TransactionLifeCycleIdentification2 {
697    #[validate]
698    #[serde(rename = "Id")]
699    pub id: Exact15Text,
700}
701#[derive(
702    Debug,
703    Default,
704    Clone,
705    PartialEq,
706    ::serde::Serialize,
707    ::serde::Deserialize,
708    ::derive_builder::Builder,
709    ::validator::Validate,
710)]
711pub struct Iso8583ResponseCode {
712    #[validate(regex = "ISO_8583_RESPONSE_CODE_REGEX")]
713    #[serde(rename = "$text")]
714    pub value: String,
715}
716#[derive(
717    Debug,
718    Default,
719    Clone,
720    PartialEq,
721    ::serde::Serialize,
722    ::serde::Deserialize,
723    ::derive_builder::Builder,
724    ::validator::Validate,
725)]
726pub struct Max8NumericText {
727    #[validate(regex = "MAX_8_NUMERIC_TEXT_REGEX")]
728    #[serde(rename = "$text")]
729    pub value: String,
730}
731#[derive(
732    Debug,
733    Default,
734    Clone,
735    PartialEq,
736    ::serde::Serialize,
737    ::serde::Deserialize,
738    ::derive_builder::Builder,
739    ::validator::Validate,
740)]
741pub struct ContentInformationType20 {
742    #[validate]
743    #[serde(rename = "MACData")]
744    pub mac_data: MacData1,
745    #[validate]
746    #[serde(rename = "MAC")]
747    pub mac: Max8HexBinaryText,
748}
749#[derive(
750    Debug,
751    Default,
752    Clone,
753    PartialEq,
754    ::serde::Serialize,
755    ::serde::Deserialize,
756    ::derive_builder::Builder,
757    ::validator::Validate,
758)]
759pub struct Max350Text {
760    #[validate(length(min = 1, max = 350,))]
761    #[serde(rename = "$text")]
762    pub value: String,
763}
764#[derive(
765    Debug,
766    Default,
767    Clone,
768    PartialEq,
769    ::serde::Serialize,
770    ::serde::Deserialize,
771    ::derive_builder::Builder,
772    ::validator::Validate,
773)]
774pub struct Max35Text {
775    #[validate(length(min = 1, max = 35,))]
776    #[serde(rename = "$text")]
777    pub value: String,
778}
779#[derive(
780    Debug,
781    Default,
782    Clone,
783    PartialEq,
784    ::serde::Serialize,
785    ::serde::Deserialize,
786    ::derive_builder::Builder,
787    ::validator::Validate,
788)]
789pub struct MacData1 {
790    #[validate]
791    #[serde(rename = "Ctrl")]
792    pub ctrl: Exact1HexBinaryText,
793    #[validate]
794    #[serde(rename = "KeySetIdr")]
795    pub key_set_idr: Max8NumericText,
796    #[serde(rename = "DrvdInf", skip_serializing_if = "Option::is_none")]
797    pub drvd_inf: Option<Max32HexBinaryText>,
798    #[validate]
799    #[serde(rename = "Algo")]
800    pub algo: Max2NumericText,
801    #[serde(rename = "KeyLngth", skip_serializing_if = "Option::is_none")]
802    pub key_lngth: Option<Max4NumericText>,
803    #[serde(rename = "KeyPrtcn", skip_serializing_if = "Option::is_none")]
804    pub key_prtcn: Option<Max2NumericText>,
805    #[serde(rename = "KeyIndx", skip_serializing_if = "Option::is_none")]
806    pub key_indx: Option<Max5NumericText>,
807    #[serde(rename = "PddgMtd", skip_serializing_if = "Option::is_none")]
808    pub pddg_mtd: Option<Max2NumericText>,
809    #[serde(rename = "InitlstnVctr", skip_serializing_if = "Option::is_none")]
810    pub initlstn_vctr: Option<Max32HexBinaryText>,
811}
812#[derive(
813    Debug,
814    Default,
815    Clone,
816    PartialEq,
817    ::serde::Serialize,
818    ::serde::Deserialize,
819    ::derive_builder::Builder,
820    ::validator::Validate,
821)]
822pub struct Max99Text {
823    #[validate(length(min = 1, max = 99,))]
824    #[serde(rename = "$text")]
825    pub value: String,
826}
827#[derive(
828    Debug,
829    Default,
830    Clone,
831    PartialEq,
832    ::serde::Serialize,
833    ::serde::Deserialize,
834    ::derive_builder::Builder,
835    ::validator::Validate,
836)]
837pub struct ErrorDetails2 {
838    #[serde(rename = "MsgErrTp")]
839    pub msg_err_tp: MessageError1Code,
840    #[serde(rename = "OthrMsgErrTp", skip_serializing_if = "Option::is_none")]
841    pub othr_msg_err_tp: Option<Max35Text>,
842    #[serde(rename = "ErrCd", skip_serializing_if = "Option::is_none")]
843    pub err_cd: Option<Max35Text>,
844    #[serde(rename = "ErrDesc", skip_serializing_if = "Option::is_none")]
845    pub err_desc: Option<Max500Text>,
846    #[validate(length(min = 0,))]
847    #[serde(rename = "DataElmtInErr", default)]
848    pub data_elmt_in_err: Vec<Max4000Text>,
849}
850#[derive(
851    Debug,
852    Default,
853    Clone,
854    PartialEq,
855    ::serde::Serialize,
856    ::serde::Deserialize,
857    ::derive_builder::Builder,
858    ::validator::Validate,
859)]
860pub struct AdditionalInformation29 {
861    #[serde(rename = "Rcpt", skip_serializing_if = "Option::is_none")]
862    pub rcpt: Option<PartyType22Code>,
863    #[serde(rename = "OthrRcpt", skip_serializing_if = "Option::is_none")]
864    pub othr_rcpt: Option<Max35Text>,
865    #[validate(length(min = 0,))]
866    #[serde(rename = "Trgt", default)]
867    pub trgt: Vec<UserInterface6Code>,
868    #[serde(rename = "OthrTrgt", skip_serializing_if = "Option::is_none")]
869    pub othr_trgt: Option<Max35Text>,
870    #[serde(rename = "Frmt", skip_serializing_if = "Option::is_none")]
871    pub frmt: Option<OutputFormat4Code>,
872    #[serde(rename = "OthrFrmt", skip_serializing_if = "Option::is_none")]
873    pub othr_frmt: Option<Max35Text>,
874    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
875    pub tp: Option<Max35Text>,
876    #[serde(rename = "Lang")]
877    pub lang: IsoMax3ALanguageCode,
878    #[validate]
879    #[serde(rename = "Val")]
880    pub val: Max20KText,
881}
882#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
883pub enum Algorithm5Code {
884    #[serde(rename = "HS25")]
885    Hs25,
886    #[serde(rename = "HS38")]
887    Hs38,
888    #[serde(rename = "HS51")]
889    Hs51,
890    #[default]
891    Unknown,
892}
893#[derive(
894    Debug,
895    Default,
896    Clone,
897    PartialEq,
898    ::serde::Serialize,
899    ::serde::Deserialize,
900    ::derive_builder::Builder,
901    ::validator::Validate,
902)]
903pub struct Max3NumericText {
904    #[validate(regex = "MAX_3_NUMERIC_TEXT_REGEX")]
905    #[serde(rename = "$text")]
906    pub value: String,
907}
908#[derive(
909    Debug,
910    Default,
911    Clone,
912    PartialEq,
913    ::serde::Serialize,
914    ::serde::Deserialize,
915    ::derive_builder::Builder,
916    ::validator::Validate,
917)]
918pub struct KekIdentifier2 {
919    #[validate]
920    #[serde(rename = "KeyId")]
921    pub key_id: Max140Text,
922    #[validate]
923    #[serde(rename = "KeyVrsn")]
924    pub key_vrsn: Max140Text,
925    #[serde(rename = "SeqNb", skip_serializing_if = "Option::is_none")]
926    pub seq_nb: Option<Number>,
927    #[serde(rename = "DerivtnId", skip_serializing_if = "Option::is_none")]
928    pub derivtn_id: Option<Min5Max16Binary>,
929}
930#[derive(
931    Debug,
932    Default,
933    Clone,
934    PartialEq,
935    ::serde::Serialize,
936    ::serde::Deserialize,
937    ::derive_builder::Builder,
938    ::validator::Validate,
939)]
940pub struct Max5000Binary {
941    #[validate(length(min = 1, max = 5000,), regex = "MAX_5000_BINARY_REGEX")]
942    pub value: String,
943}
944#[derive(
945    Debug,
946    Default,
947    Clone,
948    PartialEq,
949    ::serde::Serialize,
950    ::serde::Deserialize,
951    ::derive_builder::Builder,
952    ::validator::Validate,
953)]
954pub struct Max500Binary {
955    #[validate(length(min = 1, max = 500,), regex = "MAX_500_BINARY_REGEX")]
956    pub value: String,
957}
958#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
959pub enum BatchManagementType2Code {
960    #[serde(rename = "AKRQ")]
961    Akrq,
962    #[serde(rename = "AKRP")]
963    Akrp,
964    #[serde(rename = "ENDB")]
965    Endb,
966    #[serde(rename = "IDNT")]
967    Idnt,
968    #[serde(rename = "OTHN")]
969    Othn,
970    #[serde(rename = "OTHP")]
971    Othp,
972    #[serde(rename = "RERQ")]
973    Rerq,
974    #[serde(rename = "STRT")]
975    Strt,
976    #[default]
977    Unknown,
978}
979#[derive(
980    Debug,
981    Default,
982    Clone,
983    PartialEq,
984    ::serde::Serialize,
985    ::serde::Deserialize,
986    ::derive_builder::Builder,
987    ::validator::Validate,
988)]
989pub struct FeeAmount3 {
990    #[validate]
991    #[serde(rename = "Amt")]
992    pub amt: ImpliedCurrencyAndAmount,
993    #[serde(rename = "CdtDbt", skip_serializing_if = "Option::is_none")]
994    pub cdt_dbt: Option<CreditDebit3Code>,
995    #[serde(rename = "Ccy", skip_serializing_if = "Option::is_none")]
996    pub ccy: Option<Iso3NumericCurrencyCode>,
997    #[serde(rename = "FctvXchgRate", skip_serializing_if = "Option::is_none")]
998    pub fctv_xchg_rate: Option<BaseOne25Rate>,
999    #[serde(rename = "ConvsDt", skip_serializing_if = "Option::is_none")]
1000    pub convs_dt: Option<IsoDate>,
1001    #[serde(rename = "ConvsTm", skip_serializing_if = "Option::is_none")]
1002    pub convs_tm: Option<IsoTime>,
1003}
1004#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1005pub enum Algorithm8Code {
1006    #[serde(rename = "MGF1")]
1007    Mgf1,
1008    #[default]
1009    Unknown,
1010}
1011#[derive(
1012    Debug,
1013    Default,
1014    Clone,
1015    PartialEq,
1016    ::serde::Serialize,
1017    ::serde::Deserialize,
1018    ::derive_builder::Builder,
1019    ::validator::Validate,
1020)]
1021pub struct TransactionIdentification12 {
1022    #[validate]
1023    #[serde(rename = "SysTracAudtNb")]
1024    pub sys_trac_audt_nb: Max12NumericText,
1025    #[validate]
1026    #[serde(rename = "TrnsmssnDtTm")]
1027    pub trnsmssn_dt_tm: IsoDateTime,
1028    #[serde(rename = "RtrvlRefNb", skip_serializing_if = "Option::is_none")]
1029    pub rtrvl_ref_nb: Option<Exact12Text>,
1030    #[serde(rename = "LifeCyclTracIdData", skip_serializing_if = "Option::is_none")]
1031    pub life_cycl_trac_id_data: Option<TransactionLifeCycleIdentification2>,
1032}
1033#[derive(
1034    Debug,
1035    Default,
1036    Clone,
1037    PartialEq,
1038    ::serde::Serialize,
1039    ::serde::Deserialize,
1040    ::derive_builder::Builder,
1041    ::validator::Validate,
1042)]
1043pub struct LocalData1 {
1044    #[serde(rename = "Lang")]
1045    pub lang: IsoMax3ALanguageCode,
1046    #[serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none")]
1047    pub shrt_nm: Option<Max70Text>,
1048    #[serde(rename = "LglCorpNm", skip_serializing_if = "Option::is_none")]
1049    pub lgl_corp_nm: Option<Max210Text>,
1050    #[validate(length(min = 0,))]
1051    #[serde(rename = "AddtlData", default)]
1052    pub addtl_data: Vec<AdditionalData1>,
1053}
1054#[derive(
1055    Debug,
1056    Default,
1057    Clone,
1058    PartialEq,
1059    ::serde::Serialize,
1060    ::serde::Deserialize,
1061    ::derive_builder::Builder,
1062    ::validator::Validate,
1063)]
1064pub struct Parameter7 {
1065    #[serde(rename = "InitlstnVctr", skip_serializing_if = "Option::is_none")]
1066    pub initlstn_vctr: Option<Max500Binary>,
1067    #[serde(rename = "BPddg", skip_serializing_if = "Option::is_none")]
1068    pub b_pddg: Option<BytePadding1Code>,
1069}
1070#[derive(
1071    Debug,
1072    Default,
1073    Clone,
1074    PartialEq,
1075    ::serde::Serialize,
1076    ::serde::Deserialize,
1077    ::derive_builder::Builder,
1078    ::validator::Validate,
1079)]
1080pub struct EncryptedDataElement1 {
1081    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
1082    pub id: Option<ExternalEncryptedElementIdentification1Code>,
1083    #[serde(rename = "OthrId", skip_serializing_if = "Option::is_none")]
1084    pub othr_id: Option<Max35Text>,
1085    #[serde(rename = "NcrptdData")]
1086    pub ncrptd_data: EncryptedData1Choice,
1087    #[serde(rename = "ClearTxtDataFrmt", skip_serializing_if = "Option::is_none")]
1088    pub clear_txt_data_frmt: Option<EncryptedDataFormat1Code>,
1089    #[serde(
1090        rename = "OthrClearTxtDataFrmt",
1091        skip_serializing_if = "Option::is_none"
1092    )]
1093    pub othr_clear_txt_data_frmt: Option<Max35Text>,
1094}
1095#[derive(
1096    Debug,
1097    Default,
1098    Clone,
1099    PartialEq,
1100    ::serde::Serialize,
1101    ::serde::Deserialize,
1102    ::derive_builder::Builder,
1103    ::validator::Validate,
1104)]
1105pub struct AlgorithmIdentification28 {
1106    #[serde(rename = "Algo")]
1107    pub algo: Algorithm13Code,
1108    #[serde(rename = "Param", skip_serializing_if = "Option::is_none")]
1109    pub param: Option<Parameter14>,
1110}
1111#[derive(
1112    Debug,
1113    Default,
1114    Clone,
1115    PartialEq,
1116    ::serde::Serialize,
1117    ::serde::Deserialize,
1118    ::derive_builder::Builder,
1119    ::validator::Validate,
1120)]
1121pub struct Recipient7ChoiceEnum {
1122    #[serde(rename = "KeyTrnsprt", skip_serializing_if = "Option::is_none")]
1123    pub key_trnsprt: Option<KeyTransport6>,
1124    #[serde(rename = "KEK", skip_serializing_if = "Option::is_none")]
1125    pub kek: Option<Kek6>,
1126    #[serde(rename = "KeyIdr", skip_serializing_if = "Option::is_none")]
1127    pub key_idr: Option<KekIdentifier6>,
1128}
1129#[derive(
1130    Debug,
1131    Default,
1132    Clone,
1133    PartialEq,
1134    ::serde::Serialize,
1135    ::serde::Deserialize,
1136    ::derive_builder::Builder,
1137    ::validator::Validate,
1138)]
1139pub struct Recipient7Choice {
1140    #[serde(flatten)]
1141    pub value: Recipient7ChoiceEnum,
1142}
1143#[derive(
1144    Debug,
1145    Default,
1146    Clone,
1147    PartialEq,
1148    ::serde::Serialize,
1149    ::serde::Deserialize,
1150    ::derive_builder::Builder,
1151    ::validator::Validate,
1152)]
1153pub struct KeyTransport6 {
1154    #[serde(rename = "Vrsn", skip_serializing_if = "Option::is_none")]
1155    pub vrsn: Option<Number>,
1156    #[serde(rename = "RcptId")]
1157    pub rcpt_id: Recipient5Choice,
1158    #[validate]
1159    #[serde(rename = "KeyNcrptnAlgo")]
1160    pub key_ncrptn_algo: AlgorithmIdentification27,
1161    #[validate]
1162    #[serde(rename = "NcrptdKey")]
1163    pub ncrptd_key: Max5000Binary,
1164}
1165#[derive(
1166    Debug,
1167    Default,
1168    Clone,
1169    PartialEq,
1170    ::serde::Serialize,
1171    ::serde::Deserialize,
1172    ::derive_builder::Builder,
1173    ::validator::Validate,
1174)]
1175pub struct Max4000Text {
1176    #[validate(length(min = 1, max = 4000,))]
1177    #[serde(rename = "$text")]
1178    pub value: String,
1179}
1180#[derive(
1181    Debug,
1182    Default,
1183    Clone,
1184    PartialEq,
1185    ::serde::Serialize,
1186    ::serde::Deserialize,
1187    ::derive_builder::Builder,
1188    ::validator::Validate,
1189)]
1190pub struct Number {
1191    #[serde(rename = "$text")]
1192    pub value: f64,
1193}
1194#[derive(
1195    Debug,
1196    Default,
1197    Clone,
1198    PartialEq,
1199    ::serde::Serialize,
1200    ::serde::Deserialize,
1201    ::derive_builder::Builder,
1202    ::validator::Validate,
1203)]
1204pub struct SupplementaryDataEnvelope1<
1205    A: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
1206> {
1207    #[validate]
1208    #[serde(flatten)]
1209    pub value: A,
1210}
1211#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1212pub enum CreditDebit3Code {
1213    #[serde(rename = "CRDT")]
1214    Crdt,
1215    #[serde(rename = "DBIT")]
1216    Dbit,
1217    #[default]
1218    Unknown,
1219}
1220#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1221pub enum PartyType18Code {
1222    #[serde(rename = "ACQR")]
1223    Acqr,
1224    #[serde(rename = "CISS")]
1225    Ciss,
1226    #[serde(rename = "CSCH")]
1227    Csch,
1228    #[serde(rename = "AGNT")]
1229    Agnt,
1230    #[default]
1231    Unknown,
1232}
1233#[derive(
1234    Debug,
1235    Default,
1236    Clone,
1237    PartialEq,
1238    ::serde::Serialize,
1239    ::serde::Deserialize,
1240    ::derive_builder::Builder,
1241    ::validator::Validate,
1242)]
1243pub struct AdditionalFee2 {
1244    #[serde(rename = "Tp")]
1245    pub tp: TypeOfAmount21Code,
1246    #[serde(rename = "OthrTp", skip_serializing_if = "Option::is_none")]
1247    pub othr_tp: Option<Max35Text>,
1248    #[serde(rename = "FeePrgm", skip_serializing_if = "Option::is_none")]
1249    pub fee_prgm: Option<Max35Text>,
1250    #[serde(rename = "FeeDscrptr", skip_serializing_if = "Option::is_none")]
1251    pub fee_dscrptr: Option<Max35Text>,
1252    #[validate]
1253    #[serde(rename = "FeeAmt")]
1254    pub fee_amt: FeeAmount3,
1255    #[serde(rename = "FeeRcncltnAmt", skip_serializing_if = "Option::is_none")]
1256    pub fee_rcncltn_amt: Option<FeeAmount3>,
1257    #[serde(rename = "Desc", skip_serializing_if = "Option::is_none")]
1258    pub desc: Option<Max140Text>,
1259    #[validate(length(min = 0,))]
1260    #[serde(rename = "AddtlData", default)]
1261    pub addtl_data: Vec<AdditionalData1>,
1262}
1263#[derive(
1264    Debug,
1265    Default,
1266    Clone,
1267    PartialEq,
1268    ::serde::Serialize,
1269    ::serde::Deserialize,
1270    ::derive_builder::Builder,
1271    ::validator::Validate,
1272)]
1273pub struct Header69 {
1274    #[serde(rename = "MsgFctn")]
1275    pub msg_fctn: MessageFunction18Code,
1276    #[validate]
1277    #[serde(rename = "PrtcolVrsn")]
1278    pub prtcol_vrsn: Max2048Text,
1279    #[serde(rename = "XchgId", skip_serializing_if = "Option::is_none")]
1280    pub xchg_id: Option<Max35Text>,
1281    #[serde(rename = "ReTrnsmssnCntr", skip_serializing_if = "Option::is_none")]
1282    pub re_trnsmssn_cntr: Option<Max3NumericText>,
1283    #[validate]
1284    #[serde(rename = "CreDtTm")]
1285    pub cre_dt_tm: IsoDateTime,
1286    #[validate]
1287    #[serde(rename = "InitgPty")]
1288    pub initg_pty: GenericIdentification183,
1289    #[serde(rename = "RcptPty", skip_serializing_if = "Option::is_none")]
1290    pub rcpt_pty: Option<GenericIdentification183>,
1291    #[validate(length(min = 0,))]
1292    #[serde(rename = "TracData", default)]
1293    pub trac_data: Vec<AdditionalData1>,
1294    #[validate(length(min = 0,))]
1295    #[serde(rename = "Tracblt", default)]
1296    pub tracblt: Vec<Traceability9>,
1297}
1298#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1299pub enum PartyType9Code {
1300    #[serde(rename = "ACQR")]
1301    Acqr,
1302    #[serde(rename = "ACQP")]
1303    Acqp,
1304    #[serde(rename = "CISS")]
1305    Ciss,
1306    #[serde(rename = "CISP")]
1307    Cisp,
1308    #[serde(rename = "CSCH")]
1309    Csch,
1310    #[serde(rename = "SCHP")]
1311    Schp,
1312    #[default]
1313    Unknown,
1314}
1315#[derive(
1316    Debug,
1317    Default,
1318    Clone,
1319    PartialEq,
1320    ::serde::Serialize,
1321    ::serde::Deserialize,
1322    ::derive_builder::Builder,
1323    ::validator::Validate,
1324)]
1325pub struct Iso3NumericCurrencyCode {
1326    #[validate(regex = "ISO_3_NUMERIC_CURRENCY_CODE_REGEX")]
1327    #[serde(rename = "$text")]
1328    pub value: String,
1329}
1330#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1331pub enum EncryptedDataFormat1Code {
1332    #[serde(rename = "ASCI")]
1333    Asci,
1334    #[serde(rename = "BINF")]
1335    Binf,
1336    #[serde(rename = "EBCD")]
1337    Ebcd,
1338    #[serde(rename = "HEXF")]
1339    Hexf,
1340    #[serde(rename = "OTHN")]
1341    Othn,
1342    #[serde(rename = "OTHP")]
1343    Othp,
1344    #[default]
1345    Unknown,
1346}
1347#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1348pub enum Algorithm23Code {
1349    #[serde(rename = "EA2C")]
1350    Ea2C,
1351    #[serde(rename = "E3DC")]
1352    E3Dc,
1353    #[serde(rename = "EA9C")]
1354    Ea9C,
1355    #[serde(rename = "EA5C")]
1356    Ea5C,
1357    #[serde(rename = "EA2R")]
1358    Ea2R,
1359    #[serde(rename = "EA9R")]
1360    Ea9R,
1361    #[serde(rename = "EA5R")]
1362    Ea5R,
1363    #[serde(rename = "E3DR")]
1364    E3Dr,
1365    #[serde(rename = "E36C")]
1366    E36C,
1367    #[serde(rename = "E36R")]
1368    E36R,
1369    #[serde(rename = "SD5C")]
1370    Sd5C,
1371    #[default]
1372    Unknown,
1373}
1374#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1375pub enum ContentType3Code {
1376    #[serde(rename = "EVLP")]
1377    Evlp,
1378    #[serde(rename = "IFSE")]
1379    Ifse,
1380    #[default]
1381    Unknown,
1382}
1383#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1384pub enum MessageError1Code {
1385    #[serde(rename = "IDEF")]
1386    Idef,
1387    #[serde(rename = "IDEL")]
1388    Idel,
1389    #[serde(rename = "IDEV")]
1390    Idev,
1391    #[serde(rename = "INME")]
1392    Inme,
1393    #[serde(rename = "INMF")]
1394    Inmf,
1395    #[serde(rename = "MEPE")]
1396    Mepe,
1397    #[serde(rename = "OTHP")]
1398    Othp,
1399    #[serde(rename = "PRVE")]
1400    Prve,
1401    #[serde(rename = "RDEM")]
1402    Rdem,
1403    #[serde(rename = "SECU")]
1404    Secu,
1405    #[serde(rename = "UDFD")]
1406    Udfd,
1407    #[serde(rename = "OTHN")]
1408    Othn,
1409    #[serde(rename = "ITDE")]
1410    Itde,
1411    #[serde(rename = "DUME")]
1412    Dume,
1413    #[serde(rename = "IDWM")]
1414    Idwm,
1415    #[serde(rename = "IDRM")]
1416    Idrm,
1417    #[serde(rename = "IBAT")]
1418    Ibat,
1419    #[serde(rename = "ICOL")]
1420    Icol,
1421    #[default]
1422    Unknown,
1423}
1424#[derive(
1425    Debug,
1426    Default,
1427    Clone,
1428    PartialEq,
1429    ::serde::Serialize,
1430    ::serde::Deserialize,
1431    ::derive_builder::Builder,
1432    ::validator::Validate,
1433)]
1434#[serde(rename = "Document")]
1435pub struct Document<
1436    A: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
1437> {
1438    #[validate]
1439    #[serde(rename = "BtchMgmtRspn")]
1440    pub btch_mgmt_rspn: BatchManagementResponseV02<A>,
1441    #[serde(rename = "@xmlns", default = "namespace")]
1442    pub xmlns: String,
1443}
1444#[derive(
1445    Debug,
1446    Default,
1447    Clone,
1448    PartialEq,
1449    ::serde::Serialize,
1450    ::serde::Deserialize,
1451    ::derive_builder::Builder,
1452    ::validator::Validate,
1453)]
1454pub struct Environment33 {
1455    #[serde(rename = "Orgtr", skip_serializing_if = "Option::is_none")]
1456    pub orgtr: Option<PartyIdentification263>,
1457    #[serde(rename = "Sndr", skip_serializing_if = "Option::is_none")]
1458    pub sndr: Option<PartyIdentification263>,
1459    #[serde(rename = "Rcvr", skip_serializing_if = "Option::is_none")]
1460    pub rcvr: Option<PartyIdentification263>,
1461    #[serde(rename = "Dstn", skip_serializing_if = "Option::is_none")]
1462    pub dstn: Option<PartyIdentification263>,
1463}
1464#[derive(
1465    Debug,
1466    Default,
1467    Clone,
1468    PartialEq,
1469    ::serde::Serialize,
1470    ::serde::Deserialize,
1471    ::derive_builder::Builder,
1472    ::validator::Validate,
1473)]
1474pub struct GenericIdentification183 {
1475    #[validate]
1476    #[serde(rename = "Id")]
1477    pub id: Max35Text,
1478    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
1479    pub tp: Option<PartyType17Code>,
1480    #[serde(rename = "OthrTp", skip_serializing_if = "Option::is_none")]
1481    pub othr_tp: Option<Max35Text>,
1482    #[serde(rename = "Assgnr", skip_serializing_if = "Option::is_none")]
1483    pub assgnr: Option<PartyType18Code>,
1484    #[serde(rename = "Ctry", skip_serializing_if = "Option::is_none")]
1485    pub ctry: Option<IsoMax3ACountryCode>,
1486    #[serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none")]
1487    pub shrt_nm: Option<Max35Text>,
1488}
1489#[derive(
1490    Debug,
1491    Default,
1492    Clone,
1493    PartialEq,
1494    ::serde::Serialize,
1495    ::serde::Deserialize,
1496    ::derive_builder::Builder,
1497    ::validator::Validate,
1498)]
1499pub struct IsoDate {
1500    #[serde(rename = "$text")]
1501    pub value: ::chrono::NaiveDate,
1502}
1503#[derive(
1504    Debug,
1505    Default,
1506    Clone,
1507    PartialEq,
1508    ::serde::Serialize,
1509    ::serde::Deserialize,
1510    ::derive_builder::Builder,
1511    ::validator::Validate,
1512)]
1513pub struct Transaction151 {
1514    #[serde(rename = "BtchMgmtTp")]
1515    pub btch_mgmt_tp: BatchManagementType2Code,
1516    #[serde(rename = "OthrBtchMgmtTp", skip_serializing_if = "Option::is_none")]
1517    pub othr_btch_mgmt_tp: Option<Max35Text>,
1518    #[serde(rename = "TxId", skip_serializing_if = "Option::is_none")]
1519    pub tx_id: Option<TransactionIdentification12>,
1520    #[validate(length(min = 0,))]
1521    #[serde(rename = "AddtlFee", default)]
1522    pub addtl_fee: Vec<AdditionalFee2>,
1523    #[serde(rename = "ColltnId", skip_serializing_if = "Option::is_none")]
1524    pub colltn_id: Option<Max70Text>,
1525    #[serde(rename = "BtchId", skip_serializing_if = "Option::is_none")]
1526    pub btch_id: Option<Max70Text>,
1527    #[serde(rename = "ColltnSz", skip_serializing_if = "Option::is_none")]
1528    pub colltn_sz: Option<Number>,
1529    #[serde(rename = "OrgnlColltnId", skip_serializing_if = "Option::is_none")]
1530    pub orgnl_colltn_id: Option<Max70Text>,
1531    #[serde(rename = "OrgnlBtchId", skip_serializing_if = "Option::is_none")]
1532    pub orgnl_btch_id: Option<Max70Text>,
1533    #[serde(rename = "NbOfBtchsInColltn", skip_serializing_if = "Option::is_none")]
1534    pub nb_of_btchs_in_colltn: Option<Number>,
1535    #[serde(rename = "NbOfMsgs", skip_serializing_if = "Option::is_none")]
1536    pub nb_of_msgs: Option<Number>,
1537    #[serde(rename = "RmngMsgsInColltn", skip_serializing_if = "Option::is_none")]
1538    pub rmng_msgs_in_colltn: Option<Number>,
1539    #[serde(rename = "MsgSeqNb", skip_serializing_if = "Option::is_none")]
1540    pub msg_seq_nb: Option<Max15NumericText>,
1541    #[validate(length(min = 0,))]
1542    #[serde(rename = "ColltnIdList", default)]
1543    pub colltn_id_list: Vec<Max70Text>,
1544    #[validate(length(min = 0,))]
1545    #[serde(rename = "BtchIdList", default)]
1546    pub btch_id_list: Vec<Max70Text>,
1547    #[serde(rename = "ChckptId", skip_serializing_if = "Option::is_none")]
1548    pub chckpt_id: Option<Max70Text>,
1549    #[serde(rename = "ColltnChcksm", skip_serializing_if = "Option::is_none")]
1550    pub colltn_chcksm: Option<Max35Binary>,
1551    #[serde(rename = "BtchChcksm", skip_serializing_if = "Option::is_none")]
1552    pub btch_chcksm: Option<Max35Binary>,
1553    #[serde(rename = "ReqAck", skip_serializing_if = "Option::is_none")]
1554    pub req_ack: Option<TrueFalseIndicator>,
1555    #[serde(rename = "MsgsBfrAck", skip_serializing_if = "Option::is_none")]
1556    pub msgs_bfr_ack: Option<Number>,
1557    #[serde(rename = "PostvAck", skip_serializing_if = "Option::is_none")]
1558    pub postv_ack: Option<TrueFalseIndicator>,
1559    #[validate(length(min = 0,))]
1560    #[serde(rename = "AddtlData", default)]
1561    pub addtl_data: Vec<AdditionalData1>,
1562    #[serde(rename = "Crrctn", skip_serializing_if = "Option::is_none")]
1563    pub crrctn: Option<CorrectionIdentification1>,
1564    #[serde(rename = "ConttnInd", skip_serializing_if = "Option::is_none")]
1565    pub conttn_ind: Option<TrueFalseIndicator>,
1566}
1567#[derive(
1568    Debug,
1569    Default,
1570    Clone,
1571    PartialEq,
1572    ::serde::Serialize,
1573    ::serde::Deserialize,
1574    ::derive_builder::Builder,
1575    ::validator::Validate,
1576)]
1577pub struct ApprovalEntity2 {
1578    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
1579    pub id: Option<Max35Text>,
1580    #[serde(rename = "Tp")]
1581    pub tp: PartyType26Code,
1582    #[serde(rename = "OthrTp", skip_serializing_if = "Option::is_none")]
1583    pub othr_tp: Option<Max35Text>,
1584    #[serde(rename = "Assgnr", skip_serializing_if = "Option::is_none")]
1585    pub assgnr: Option<PartyType9Code>,
1586    #[serde(rename = "Ctry", skip_serializing_if = "Option::is_none")]
1587    pub ctry: Option<IsoMax3ACountryCode>,
1588    #[serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none")]
1589    pub shrt_nm: Option<Max35Text>,
1590}
1591#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1592pub enum EncryptionFormat3Code {
1593    #[serde(rename = "TR34")]
1594    Tr34,
1595    #[serde(rename = "TR31")]
1596    Tr31,
1597    #[serde(rename = "CTCE")]
1598    Ctce,
1599    #[serde(rename = "CBCE")]
1600    Cbce,
1601    #[default]
1602    Unknown,
1603}
1604#[derive(
1605    Debug,
1606    Default,
1607    Clone,
1608    PartialEq,
1609    ::serde::Serialize,
1610    ::serde::Deserialize,
1611    ::derive_builder::Builder,
1612    ::validator::Validate,
1613)]
1614pub struct Exact1HexBinaryText {
1615    #[validate(regex = "EXACT_1_HEX_BINARY_TEXT_REGEX")]
1616    #[serde(rename = "$text")]
1617    pub value: String,
1618}
1619#[derive(
1620    Debug,
1621    Default,
1622    Clone,
1623    PartialEq,
1624    ::serde::Serialize,
1625    ::serde::Deserialize,
1626    ::derive_builder::Builder,
1627    ::validator::Validate,
1628)]
1629pub struct Max9999HexBinaryText {
1630    #[validate(regex = "MAX_9999_HEX_BINARY_TEXT_REGEX")]
1631    #[serde(rename = "$text")]
1632    pub value: String,
1633}
1634#[derive(
1635    Debug,
1636    Default,
1637    Clone,
1638    PartialEq,
1639    ::serde::Serialize,
1640    ::serde::Deserialize,
1641    ::derive_builder::Builder,
1642    ::validator::Validate,
1643)]
1644pub struct ResultData8 {
1645    #[serde(rename = "Rslt", skip_serializing_if = "Option::is_none")]
1646    pub rslt: Option<Response6Code>,
1647    #[serde(rename = "OthrRslt", skip_serializing_if = "Option::is_none")]
1648    pub othr_rslt: Option<Max35Text>,
1649    #[serde(rename = "RsltDtls")]
1650    pub rslt_dtls: Iso8583ResponseCode,
1651    #[serde(rename = "OthrRsltDtls", skip_serializing_if = "Option::is_none")]
1652    pub othr_rslt_dtls: Option<Max35Text>,
1653    #[validate(length(min = 0,))]
1654    #[serde(rename = "AddtlRsltInf", default)]
1655    pub addtl_rslt_inf: Vec<AdditionalData1>,
1656}
1657#[derive(
1658    Debug,
1659    Default,
1660    Clone,
1661    PartialEq,
1662    ::serde::Serialize,
1663    ::serde::Deserialize,
1664    ::derive_builder::Builder,
1665    ::validator::Validate,
1666)]
1667pub struct SettlementServiceMode1 {
1668    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
1669    pub tp: Option<Max35Text>,
1670    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
1671    pub id: Option<Max35Text>,
1672    #[serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none")]
1673    pub shrt_nm: Option<Max35Text>,
1674    #[serde(rename = "SttlmPrty", skip_serializing_if = "Option::is_none")]
1675    pub sttlm_prty: Option<Priority3Code>,
1676}
1677#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1678pub enum UserInterface6Code {
1679    #[serde(rename = "CDSP")]
1680    Cdsp,
1681    #[serde(rename = "CRCP")]
1682    Crcp,
1683    #[serde(rename = "MDSP")]
1684    Mdsp,
1685    #[serde(rename = "MRCP")]
1686    Mrcp,
1687    #[serde(rename = "CRDO")]
1688    Crdo,
1689    #[serde(rename = "FILE")]
1690    File,
1691    #[serde(rename = "CHAP")]
1692    Chap,
1693    #[serde(rename = "MRAP")]
1694    Mrap,
1695    #[serde(rename = "MRIN")]
1696    Mrin,
1697    #[default]
1698    Unknown,
1699}
1700#[derive(
1701    Debug,
1702    Default,
1703    Clone,
1704    PartialEq,
1705    ::serde::Serialize,
1706    ::serde::Deserialize,
1707    ::derive_builder::Builder,
1708    ::validator::Validate,
1709)]
1710pub struct Max11NumericText {
1711    #[validate(regex = "MAX_11_NUMERIC_TEXT_REGEX")]
1712    #[serde(rename = "$text")]
1713    pub value: String,
1714}
1715#[derive(
1716    Debug,
1717    Default,
1718    Clone,
1719    PartialEq,
1720    ::serde::Serialize,
1721    ::serde::Deserialize,
1722    ::derive_builder::Builder,
1723    ::validator::Validate,
1724)]
1725pub struct BatchManagementResponseV02<
1726    A: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
1727> {
1728    #[validate]
1729    #[serde(rename = "Hdr")]
1730    pub hdr: Header69,
1731    #[validate]
1732    #[serde(rename = "Body")]
1733    pub body: BatchManagementResponse2<A>,
1734    #[serde(rename = "SctyTrlr", skip_serializing_if = "Option::is_none")]
1735    pub scty_trlr: Option<ContentInformationType20>,
1736}
1737#[derive(
1738    Debug,
1739    Default,
1740    Clone,
1741    PartialEq,
1742    ::serde::Serialize,
1743    ::serde::Deserialize,
1744    ::derive_builder::Builder,
1745    ::validator::Validate,
1746)]
1747pub struct BaseOne25Rate {
1748    #[serde(rename = "$text")]
1749    pub value: f64,
1750}
1751#[derive(
1752    Debug,
1753    Default,
1754    Clone,
1755    PartialEq,
1756    ::serde::Serialize,
1757    ::serde::Deserialize,
1758    ::derive_builder::Builder,
1759    ::validator::Validate,
1760)]
1761pub struct Max2048Text {
1762    #[validate(length(min = 1, max = 2048,))]
1763    #[serde(rename = "$text")]
1764    pub value: String,
1765}
1766#[derive(
1767    Debug,
1768    Default,
1769    Clone,
1770    PartialEq,
1771    ::serde::Serialize,
1772    ::serde::Deserialize,
1773    ::derive_builder::Builder,
1774    ::validator::Validate,
1775)]
1776pub struct Max4NumericText {
1777    #[validate(regex = "MAX_4_NUMERIC_TEXT_REGEX")]
1778    #[serde(rename = "$text")]
1779    pub value: String,
1780}
1781#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1782pub enum Response6Code {
1783    #[serde(rename = "UNPR")]
1784    Unpr,
1785    #[serde(rename = "PPRC")]
1786    Pprc,
1787    #[serde(rename = "PRCS")]
1788    Prcs,
1789    #[serde(rename = "REJT")]
1790    Rejt,
1791    #[serde(rename = "OTHP")]
1792    Othp,
1793    #[serde(rename = "OTHN")]
1794    Othn,
1795    #[serde(rename = "TECH")]
1796    Tech,
1797    #[serde(rename = "UNRV")]
1798    Unrv,
1799    #[default]
1800    Unknown,
1801}
1802#[derive(
1803    Debug,
1804    Default,
1805    Clone,
1806    PartialEq,
1807    ::serde::Serialize,
1808    ::serde::Deserialize,
1809    ::derive_builder::Builder,
1810    ::validator::Validate,
1811)]
1812pub struct Max100KBinary {
1813    #[validate(length(min = 1, max = 102400,), regex = "MAX_100_K_BINARY_REGEX")]
1814    pub value: String,
1815}
1816#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1817pub enum Algorithm13Code {
1818    #[serde(rename = "EA2C")]
1819    Ea2C,
1820    #[serde(rename = "E3DC")]
1821    E3Dc,
1822    #[serde(rename = "DKP9")]
1823    Dkp9,
1824    #[serde(rename = "UKPT")]
1825    Ukpt,
1826    #[serde(rename = "UKA1")]
1827    Uka1,
1828    #[serde(rename = "EA9C")]
1829    Ea9C,
1830    #[serde(rename = "EA5C")]
1831    Ea5C,
1832    #[default]
1833    Unknown,
1834}
1835#[derive(
1836    Debug,
1837    Default,
1838    Clone,
1839    PartialEq,
1840    ::serde::Serialize,
1841    ::serde::Deserialize,
1842    ::derive_builder::Builder,
1843    ::validator::Validate,
1844)]
1845pub struct Max5NumericText {
1846    #[validate(regex = "MAX_5_NUMERIC_TEXT_REGEX")]
1847    #[serde(rename = "$text")]
1848    pub value: String,
1849}
1850#[derive(
1851    Debug,
1852    Default,
1853    Clone,
1854    PartialEq,
1855    ::serde::Serialize,
1856    ::serde::Deserialize,
1857    ::derive_builder::Builder,
1858    ::validator::Validate,
1859)]
1860pub struct Min5Max16Binary {
1861    #[validate(length(min = 5, max = 16,), regex = "MIN_5_MAX_16_BINARY_REGEX")]
1862    pub value: String,
1863}
1864#[derive(
1865    Debug,
1866    Default,
1867    Clone,
1868    PartialEq,
1869    ::serde::Serialize,
1870    ::serde::Deserialize,
1871    ::derive_builder::Builder,
1872    ::validator::Validate,
1873)]
1874pub struct IsoDateTime {
1875    #[serde(rename = "$text")]
1876    pub value: ::chrono::DateTime<::chrono::Utc>,
1877}
1878#[derive(
1879    Debug,
1880    Default,
1881    Clone,
1882    PartialEq,
1883    ::serde::Serialize,
1884    ::serde::Deserialize,
1885    ::derive_builder::Builder,
1886    ::validator::Validate,
1887)]
1888pub struct CardProgrammeMode3 {
1889    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
1890    pub tp: Option<Max35Text>,
1891    #[validate]
1892    #[serde(rename = "Id")]
1893    pub id: Max35Text,
1894    #[validate(length(min = 0,))]
1895    #[serde(rename = "AddtlId", default)]
1896    pub addtl_id: Vec<AdditionalData1>,
1897}
1898#[derive(
1899    Debug,
1900    Default,
1901    Clone,
1902    PartialEq,
1903    ::serde::Serialize,
1904    ::serde::Deserialize,
1905    ::derive_builder::Builder,
1906    ::validator::Validate,
1907)]
1908pub struct Exact15Text {
1909    #[serde(rename = "$text")]
1910    pub value: String,
1911}
1912#[derive(
1913    Debug,
1914    Default,
1915    Clone,
1916    PartialEq,
1917    ::serde::Serialize,
1918    ::serde::Deserialize,
1919    ::derive_builder::Builder,
1920    ::validator::Validate,
1921)]
1922pub struct EncryptedData1ChoiceEnum {
1923    #[serde(rename = "HexBinryVal", skip_serializing_if = "Option::is_none")]
1924    pub hex_binry_val: Option<Max9999HexBinaryText>,
1925    #[serde(rename = "BinryData", skip_serializing_if = "Option::is_none")]
1926    pub binry_data: Option<Max100KBinary>,
1927}
1928#[derive(
1929    Debug,
1930    Default,
1931    Clone,
1932    PartialEq,
1933    ::serde::Serialize,
1934    ::serde::Deserialize,
1935    ::derive_builder::Builder,
1936    ::validator::Validate,
1937)]
1938pub struct EncryptedData1Choice {
1939    #[serde(flatten)]
1940    pub value: EncryptedData1ChoiceEnum,
1941}
1942#[derive(
1943    Debug,
1944    Default,
1945    Clone,
1946    PartialEq,
1947    ::serde::Serialize,
1948    ::serde::Deserialize,
1949    ::derive_builder::Builder,
1950    ::validator::Validate,
1951)]
1952pub struct Max35Binary {
1953    #[validate(length(min = 1, max = 35,), regex = "MAX_35_BINARY_REGEX")]
1954    pub value: String,
1955}
1956#[derive(
1957    Debug,
1958    Default,
1959    Clone,
1960    PartialEq,
1961    ::serde::Serialize,
1962    ::serde::Deserialize,
1963    ::derive_builder::Builder,
1964    ::validator::Validate,
1965)]
1966pub struct Reconciliation3 {
1967    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
1968    pub id: Option<Max35Text>,
1969    #[serde(rename = "Dt", skip_serializing_if = "Option::is_none")]
1970    pub dt: Option<IsoDate>,
1971    #[serde(rename = "ChckptRef", skip_serializing_if = "Option::is_none")]
1972    pub chckpt_ref: Option<Max35Text>,
1973}
1974#[derive(
1975    Debug,
1976    Default,
1977    Clone,
1978    PartialEq,
1979    ::serde::Serialize,
1980    ::serde::Deserialize,
1981    ::derive_builder::Builder,
1982    ::validator::Validate,
1983)]
1984pub struct EncryptedData1 {
1985    #[serde(rename = "Ctrl", skip_serializing_if = "Option::is_none")]
1986    pub ctrl: Option<Exact1HexBinaryText>,
1987    #[serde(rename = "KeySetIdr", skip_serializing_if = "Option::is_none")]
1988    pub key_set_idr: Option<Max8NumericText>,
1989    #[serde(rename = "DrvdInf", skip_serializing_if = "Option::is_none")]
1990    pub drvd_inf: Option<Max32HexBinaryText>,
1991    #[serde(rename = "Algo", skip_serializing_if = "Option::is_none")]
1992    pub algo: Option<Max2NumericText>,
1993    #[serde(rename = "KeyLngth", skip_serializing_if = "Option::is_none")]
1994    pub key_lngth: Option<Max4NumericText>,
1995    #[serde(rename = "KeyPrtcn", skip_serializing_if = "Option::is_none")]
1996    pub key_prtcn: Option<Max2NumericText>,
1997    #[serde(rename = "KeyIndx", skip_serializing_if = "Option::is_none")]
1998    pub key_indx: Option<Max5NumericText>,
1999    #[serde(rename = "PddgMtd", skip_serializing_if = "Option::is_none")]
2000    pub pddg_mtd: Option<Max2NumericText>,
2001    #[serde(rename = "NcrptdDataFrmt", skip_serializing_if = "Option::is_none")]
2002    pub ncrptd_data_frmt: Option<Max2NumericText>,
2003    #[validate(length(min = 1,))]
2004    #[serde(rename = "NcrptdDataElmt", default)]
2005    pub ncrptd_data_elmt: Vec<EncryptedDataElement1>,
2006}
2007#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2008pub enum Algorithm7Code {
2009    #[serde(rename = "ERSA")]
2010    Ersa,
2011    #[serde(rename = "RSAO")]
2012    Rsao,
2013    #[default]
2014    Unknown,
2015}
2016#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2017pub enum PartyType22Code {
2018    #[serde(rename = "CRDH")]
2019    Crdh,
2020    #[serde(rename = "MERC")]
2021    Merc,
2022    #[serde(rename = "OTHN")]
2023    Othn,
2024    #[serde(rename = "OTHP")]
2025    Othp,
2026    #[serde(rename = "AGNT")]
2027    Agnt,
2028    #[default]
2029    Unknown,
2030}
2031#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2032pub enum ContentType2Code {
2033    #[serde(rename = "DATA")]
2034    Data,
2035    #[serde(rename = "SIGN")]
2036    Sign,
2037    #[serde(rename = "EVLP")]
2038    Evlp,
2039    #[serde(rename = "DGST")]
2040    Dgst,
2041    #[serde(rename = "AUTH")]
2042    Auth,
2043    #[default]
2044    Unknown,
2045}
2046#[derive(
2047    Debug,
2048    Default,
2049    Clone,
2050    PartialEq,
2051    ::serde::Serialize,
2052    ::serde::Deserialize,
2053    ::derive_builder::Builder,
2054    ::validator::Validate,
2055)]
2056pub struct ImpliedCurrencyAndAmount {
2057    #[validate(range(min = 0,))]
2058    #[serde(rename = "$text")]
2059    pub value: f64,
2060}
2061#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2062pub enum BytePadding1Code {
2063    #[serde(rename = "LNGT")]
2064    Lngt,
2065    #[serde(rename = "NUL8")]
2066    Nul8,
2067    #[serde(rename = "NULG")]
2068    Nulg,
2069    #[serde(rename = "NULL")]
2070    Null,
2071    #[serde(rename = "RAND")]
2072    Rand,
2073    #[default]
2074    Unknown,
2075}
2076#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2077pub enum Priority3Code {
2078    #[serde(rename = "URGT")]
2079    Urgt,
2080    #[serde(rename = "HIGH")]
2081    High,
2082    #[serde(rename = "NORM")]
2083    Norm,
2084    #[default]
2085    Unknown,
2086}
2087#[derive(
2088    Debug,
2089    Default,
2090    Clone,
2091    PartialEq,
2092    ::serde::Serialize,
2093    ::serde::Deserialize,
2094    ::derive_builder::Builder,
2095    ::validator::Validate,
2096)]
2097pub struct CertificateIssuer1 {
2098    #[validate(length(min = 1,))]
2099    #[serde(rename = "RltvDstngshdNm", default)]
2100    pub rltv_dstngshd_nm: Vec<RelativeDistinguishedName1>,
2101}
2102#[derive(
2103    Debug,
2104    Default,
2105    Clone,
2106    PartialEq,
2107    ::serde::Serialize,
2108    ::serde::Deserialize,
2109    ::derive_builder::Builder,
2110    ::validator::Validate,
2111)]
2112pub struct ProcessingResult13 {
2113    #[serde(rename = "RspnSrc", skip_serializing_if = "Option::is_none")]
2114    pub rspn_src: Option<ApprovalEntity2>,
2115    #[validate]
2116    #[serde(rename = "RsltData")]
2117    pub rslt_data: ResultData8,
2118    #[serde(rename = "ApprvlCd", skip_serializing_if = "Option::is_none")]
2119    pub apprvl_cd: Option<Exact6AlphaNumericText>,
2120    #[validate(length(min = 0,))]
2121    #[serde(rename = "ErrDtl", default)]
2122    pub err_dtl: Vec<ErrorDetails2>,
2123    #[serde(rename = "OrgnlRsltData", skip_serializing_if = "Option::is_none")]
2124    pub orgnl_rslt_data: Option<ResultData7>,
2125    #[validate(length(min = 0,))]
2126    #[serde(rename = "AddtlInf", default)]
2127    pub addtl_inf: Vec<AdditionalInformation29>,
2128}
2129#[derive(
2130    Debug,
2131    Default,
2132    Clone,
2133    PartialEq,
2134    ::serde::Serialize,
2135    ::serde::Deserialize,
2136    ::derive_builder::Builder,
2137    ::validator::Validate,
2138)]
2139pub struct RelativeDistinguishedName1 {
2140    #[serde(rename = "AttrTp")]
2141    pub attr_tp: AttributeType1Code,
2142    #[validate]
2143    #[serde(rename = "AttrVal")]
2144    pub attr_val: Max140Text,
2145}
2146#[derive(
2147    Debug,
2148    Default,
2149    Clone,
2150    PartialEq,
2151    ::serde::Serialize,
2152    ::serde::Deserialize,
2153    ::derive_builder::Builder,
2154    ::validator::Validate,
2155)]
2156pub struct AlgorithmIdentification26 {
2157    #[serde(rename = "Algo")]
2158    pub algo: Algorithm8Code,
2159    #[serde(rename = "Param", skip_serializing_if = "Option::is_none")]
2160    pub param: Option<Algorithm5Code>,
2161}
2162#[derive(
2163    Debug,
2164    Default,
2165    Clone,
2166    PartialEq,
2167    ::serde::Serialize,
2168    ::serde::Deserialize,
2169    ::derive_builder::Builder,
2170    ::validator::Validate,
2171)]
2172pub struct AlgorithmIdentification25 {
2173    #[serde(rename = "Algo")]
2174    pub algo: Algorithm23Code,
2175    #[serde(rename = "Param", skip_serializing_if = "Option::is_none")]
2176    pub param: Option<Parameter7>,
2177}
2178#[derive(
2179    Debug,
2180    Default,
2181    Clone,
2182    PartialEq,
2183    ::serde::Serialize,
2184    ::serde::Deserialize,
2185    ::derive_builder::Builder,
2186    ::validator::Validate,
2187)]
2188pub struct Iso3NumericCountryCode {
2189    #[validate(regex = "ISO_3_NUMERIC_COUNTRY_CODE_REGEX")]
2190    #[serde(rename = "$text")]
2191    pub value: String,
2192}
2193#[derive(
2194    Debug,
2195    Default,
2196    Clone,
2197    PartialEq,
2198    ::serde::Serialize,
2199    ::serde::Deserialize,
2200    ::derive_builder::Builder,
2201    ::validator::Validate,
2202)]
2203pub struct Recipient5ChoiceEnum {
2204    #[serde(rename = "KeyIdr", skip_serializing_if = "Option::is_none")]
2205    pub key_idr: Option<KekIdentifier2>,
2206    #[serde(rename = "IssrAndSrlNb", skip_serializing_if = "Option::is_none")]
2207    pub issr_and_srl_nb: Option<IssuerAndSerialNumber1>,
2208}
2209#[derive(
2210    Debug,
2211    Default,
2212    Clone,
2213    PartialEq,
2214    ::serde::Serialize,
2215    ::serde::Deserialize,
2216    ::derive_builder::Builder,
2217    ::validator::Validate,
2218)]
2219pub struct Recipient5Choice {
2220    #[serde(flatten)]
2221    pub value: Recipient5ChoiceEnum,
2222}
2223#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2224pub enum MessageFunction18Code {
2225    #[serde(rename = "BTRQ")]
2226    Btrq,
2227    #[serde(rename = "BTNF")]
2228    Btnf,
2229    #[serde(rename = "CLNF")]
2230    Clnf,
2231    #[serde(rename = "CLRQ")]
2232    Clrq,
2233    #[default]
2234    Unknown,
2235}
2236#[derive(
2237    Debug,
2238    Default,
2239    Clone,
2240    PartialEq,
2241    ::serde::Serialize,
2242    ::serde::Deserialize,
2243    ::derive_builder::Builder,
2244    ::validator::Validate,
2245)]
2246pub struct AlgorithmIdentification27 {
2247    #[serde(rename = "Algo")]
2248    pub algo: Algorithm7Code,
2249    #[serde(rename = "Param", skip_serializing_if = "Option::is_none")]
2250    pub param: Option<Parameter13>,
2251}
2252#[derive(
2253    Debug,
2254    Default,
2255    Clone,
2256    PartialEq,
2257    ::serde::Serialize,
2258    ::serde::Deserialize,
2259    ::derive_builder::Builder,
2260    ::validator::Validate,
2261)]
2262pub struct Max32HexBinaryText {
2263    #[validate(regex = "MAX_32_HEX_BINARY_TEXT_REGEX")]
2264    #[serde(rename = "$text")]
2265    pub value: String,
2266}
2267#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2268pub enum OutputFormat4Code {
2269    #[serde(rename = "FLNM")]
2270    Flnm,
2271    #[serde(rename = "MREF")]
2272    Mref,
2273    #[serde(rename = "OTHN")]
2274    Othn,
2275    #[serde(rename = "OTHP")]
2276    Othp,
2277    #[serde(rename = "SMSI")]
2278    Smsi,
2279    #[serde(rename = "TEXT")]
2280    Text,
2281    #[serde(rename = "URLI")]
2282    Urli,
2283    #[serde(rename = "HTML")]
2284    Html,
2285    #[default]
2286    Unknown,
2287}
2288#[derive(
2289    Debug,
2290    Default,
2291    Clone,
2292    PartialEq,
2293    ::serde::Serialize,
2294    ::serde::Deserialize,
2295    ::derive_builder::Builder,
2296    ::validator::Validate,
2297)]
2298pub struct ProtectedData1 {
2299    #[serde(rename = "CnttTp")]
2300    pub cntt_tp: ContentType3Code,
2301    #[serde(rename = "EnvlpdData", skip_serializing_if = "Option::is_none")]
2302    pub envlpd_data: Option<EnvelopedData6>,
2303    #[serde(rename = "NcrptdData", skip_serializing_if = "Option::is_none")]
2304    pub ncrptd_data: Option<EncryptedData1>,
2305}
2306#[derive(
2307    Debug,
2308    Default,
2309    Clone,
2310    PartialEq,
2311    ::serde::Serialize,
2312    ::serde::Deserialize,
2313    ::derive_builder::Builder,
2314    ::validator::Validate,
2315)]
2316pub struct Max12NumericText {
2317    #[validate(regex = "MAX_12_NUMERIC_TEXT_REGEX")]
2318    #[serde(rename = "$text")]
2319    pub value: String,
2320}
2321#[derive(
2322    Debug,
2323    Default,
2324    Clone,
2325    PartialEq,
2326    ::serde::Serialize,
2327    ::serde::Deserialize,
2328    ::derive_builder::Builder,
2329    ::validator::Validate,
2330)]
2331pub struct PartyIdentification263 {
2332    #[validate]
2333    #[serde(rename = "Id")]
2334    pub id: Max11NumericText,
2335    #[serde(rename = "Assgnr", skip_serializing_if = "Option::is_none")]
2336    pub assgnr: Option<Max35Text>,
2337    #[serde(rename = "Ctry", skip_serializing_if = "Option::is_none")]
2338    pub ctry: Option<Iso3NumericCountryCode>,
2339    #[serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none")]
2340    pub shrt_nm: Option<Max35Text>,
2341    #[serde(rename = "LglCorpNm", skip_serializing_if = "Option::is_none")]
2342    pub lgl_corp_nm: Option<Max99Text>,
2343    #[serde(rename = "AddtlId", skip_serializing_if = "Option::is_none")]
2344    pub addtl_id: Option<AdditionalData1>,
2345    #[serde(rename = "LclData", skip_serializing_if = "Option::is_none")]
2346    pub lcl_data: Option<LocalData1>,
2347}
2348#[derive(
2349    Debug,
2350    Default,
2351    Clone,
2352    PartialEq,
2353    ::serde::Serialize,
2354    ::serde::Deserialize,
2355    ::derive_builder::Builder,
2356    ::validator::Validate,
2357)]
2358pub struct KekIdentifier6 {
2359    #[validate]
2360    #[serde(rename = "KeyId")]
2361    pub key_id: Max140Text,
2362    #[serde(rename = "KeyVrsn", skip_serializing_if = "Option::is_none")]
2363    pub key_vrsn: Option<Max140Text>,
2364    #[serde(rename = "SeqNb", skip_serializing_if = "Option::is_none")]
2365    pub seq_nb: Option<Number>,
2366    #[serde(rename = "DerivtnId", skip_serializing_if = "Option::is_none")]
2367    pub derivtn_id: Option<Min5Max16Binary>,
2368}
2369#[derive(
2370    Debug,
2371    Default,
2372    Clone,
2373    PartialEq,
2374    ::serde::Serialize,
2375    ::serde::Deserialize,
2376    ::derive_builder::Builder,
2377    ::validator::Validate,
2378)]
2379pub struct IsoMax3ACountryCode {
2380    #[validate(regex = "ISO_MAX_3_A_COUNTRY_CODE_REGEX")]
2381    #[serde(rename = "$text")]
2382    pub value: String,
2383}
2384#[derive(
2385    Debug,
2386    Default,
2387    Clone,
2388    PartialEq,
2389    ::serde::Serialize,
2390    ::serde::Deserialize,
2391    ::derive_builder::Builder,
2392    ::validator::Validate,
2393)]
2394pub struct IssuerAndSerialNumber1 {
2395    #[validate]
2396    #[serde(rename = "Issr")]
2397    pub issr: CertificateIssuer1,
2398    #[validate]
2399    #[serde(rename = "SrlNb")]
2400    pub srl_nb: Max35Binary,
2401}
2402#[derive(
2403    Debug,
2404    Default,
2405    Clone,
2406    PartialEq,
2407    ::serde::Serialize,
2408    ::serde::Deserialize,
2409    ::derive_builder::Builder,
2410    ::validator::Validate,
2411)]
2412pub struct Parameter13 {
2413    #[serde(rename = "DgstAlgo", skip_serializing_if = "Option::is_none")]
2414    pub dgst_algo: Option<Algorithm20Code>,
2415    #[serde(rename = "MskGnrtrAlgo", skip_serializing_if = "Option::is_none")]
2416    pub msk_gnrtr_algo: Option<AlgorithmIdentification26>,
2417}
2418#[derive(
2419    Debug,
2420    Default,
2421    Clone,
2422    PartialEq,
2423    ::serde::Serialize,
2424    ::serde::Deserialize,
2425    ::derive_builder::Builder,
2426    ::validator::Validate,
2427)]
2428pub struct ResultData7 {
2429    #[serde(rename = "Rslt", skip_serializing_if = "Option::is_none")]
2430    pub rslt: Option<Response8Code>,
2431    #[serde(rename = "OthrRslt", skip_serializing_if = "Option::is_none")]
2432    pub othr_rslt: Option<Max35Text>,
2433    #[serde(rename = "RsltDtls")]
2434    pub rslt_dtls: Iso8583ResponseCode,
2435    #[serde(rename = "OthrRsltDtls", skip_serializing_if = "Option::is_none")]
2436    pub othr_rslt_dtls: Option<Max35Text>,
2437    #[serde(
2438        rename = "TempScrCardDataReusePrtd",
2439        skip_serializing_if = "Option::is_none"
2440    )]
2441    pub temp_scr_card_data_reuse_prtd: Option<TrueFalseIndicator>,
2442    #[validate(length(min = 0,))]
2443    #[serde(rename = "AddtlRsltInf", default)]
2444    pub addtl_rslt_inf: Vec<AdditionalData1>,
2445}
2446#[derive(
2447    Debug,
2448    Default,
2449    Clone,
2450    PartialEq,
2451    ::serde::Serialize,
2452    ::serde::Deserialize,
2453    ::derive_builder::Builder,
2454    ::validator::Validate,
2455)]
2456pub struct Max210Text {
2457    #[validate(length(min = 1, max = 210,))]
2458    #[serde(rename = "$text")]
2459    pub value: String,
2460}
2461#[derive(
2462    Debug,
2463    Default,
2464    Clone,
2465    PartialEq,
2466    ::serde::Serialize,
2467    ::serde::Deserialize,
2468    ::derive_builder::Builder,
2469    ::validator::Validate,
2470)]
2471pub struct AdditionalData1 {
2472    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
2473    pub tp: Option<Max35Text>,
2474    #[serde(rename = "Val", skip_serializing_if = "Option::is_none")]
2475    pub val: Option<Max2048Text>,
2476}
2477#[derive(
2478    Debug,
2479    Default,
2480    Clone,
2481    PartialEq,
2482    ::serde::Serialize,
2483    ::serde::Deserialize,
2484    ::derive_builder::Builder,
2485    ::validator::Validate,
2486)]
2487pub struct SettlementReportingEntity1 {
2488    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
2489    pub tp: Option<Max35Text>,
2490    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
2491    pub id: Option<Max35Text>,
2492}
iso_20022_caad/caad_002_001_02.rs

iso_20022_caad/
caad_002_001_02.rs
