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

iso_20022_caad/
caad_006_001_03.rs
