iso_20022_caad/
caad_010_001_01.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 ISO_MAX_3_A_LANGUAGE_CODE_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[a-z]{2,3}"#).unwrap();
25}
26
27::lazy_static::lazy_static! {
28    static ref ISO_3_NUMERIC_COUNTRY_CODE_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{3,3}"#).unwrap();
29}
30
31::lazy_static::lazy_static! {
32    static ref MAX_4_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,4}"#).unwrap();
33}
34
35::lazy_static::lazy_static! {
36    static ref MAX_32_HEX_BINARY_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"([0-9A-F][0-9A-F]){1,32}"#).unwrap();
37}
38
39::lazy_static::lazy_static! {
40    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();
41}
42
43::lazy_static::lazy_static! {
44    static ref MAX_10_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,10}"#).unwrap();
45}
46
47::lazy_static::lazy_static! {
48    static ref ISO_MAX_3_A_COUNTRY_CODE_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Z]{2,3}"#).unwrap();
49}
50
51::lazy_static::lazy_static! {
52    static ref MAX_5_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,5}"#).unwrap();
53}
54
55::lazy_static::lazy_static! {
56    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();
57}
58
59::lazy_static::lazy_static! {
60    static ref MAX_3_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,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 EXACT_1_HEX_BINARY_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"([0-9A-F][0-9A-F]){1}"#).unwrap();
69}
70
71::lazy_static::lazy_static! {
72    static ref MAX_15_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,15}"#).unwrap();
73}
74
75::lazy_static::lazy_static! {
76    static ref MAX_2_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,2}"#).unwrap();
77}
78
79::lazy_static::lazy_static! {
80    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();
81}
82
83::lazy_static::lazy_static! {
84    static ref MAX_20_MB_BINARY_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Za-z0-9+/]{4}*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?"#).unwrap();
85}
86
87::lazy_static::lazy_static! {
88    static ref MAX_8_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,8}"#).unwrap();
89}
90
91::lazy_static::lazy_static! {
92    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();
93}
94
95::lazy_static::lazy_static! {
96    static ref EXTERNAL_ENCRYPTED_ELEMENT_IDENTIFICATION_1_CODE_REGEX: ::regex::Regex = ::regex::Regex::new(r#"([0-9A-F][0-9A-F]){1,3}"#).unwrap();
97}
98
99::lazy_static::lazy_static! {
100    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();
101}
102
103::lazy_static::lazy_static! {
104    static ref MAX_8_HEX_BINARY_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"([0-9A-F][0-9A-F]){1,8}"#).unwrap();
105}
106
107::lazy_static::lazy_static! {
108    static ref MAX_9999_HEX_BINARY_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"([0-9A-F][0-9A-F]){1,9999}"#).unwrap();
109}
110
111::lazy_static::lazy_static! {
112    static ref MAX_11_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,11}"#).unwrap();
113}
114
115/// Returns the namespace of the schema
116pub fn namespace() -> String {
117    "urn:iso:std:iso:20022:tech:xsd:caad.010.001.01".to_string()
118}
119
120#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
121pub enum Algorithm13Code {
122    #[serde(rename = "EA2C")]
123    Ea2C,
124    #[serde(rename = "E3DC")]
125    E3Dc,
126    #[serde(rename = "DKP9")]
127    Dkp9,
128    #[serde(rename = "UKPT")]
129    Ukpt,
130    #[serde(rename = "UKA1")]
131    Uka1,
132    #[serde(rename = "EA9C")]
133    Ea9C,
134    #[serde(rename = "EA5C")]
135    Ea5C,
136    #[default]
137    Unknown,
138}
139#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
140pub enum Algorithm5Code {
141    #[serde(rename = "HS25")]
142    Hs25,
143    #[serde(rename = "HS38")]
144    Hs38,
145    #[serde(rename = "HS51")]
146    Hs51,
147    #[default]
148    Unknown,
149}
150#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
151pub enum PartyType18Code {
152    #[serde(rename = "ACQR")]
153    Acqr,
154    #[serde(rename = "CISS")]
155    Ciss,
156    #[serde(rename = "CSCH")]
157    Csch,
158    #[serde(rename = "AGNT")]
159    Agnt,
160    #[default]
161    Unknown,
162}
163#[derive(
164    Debug,
165    Default,
166    Clone,
167    PartialEq,
168    ::serde::Serialize,
169    ::serde::Deserialize,
170    ::derive_builder::Builder,
171    ::validator::Validate,
172)]
173pub struct CustomReportV01<
174    A: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
175> {
176    #[validate]
177    #[serde(rename = "Hdr")]
178    pub hdr: Header65,
179    #[validate]
180    #[serde(rename = "Body")]
181    pub body: CustomReport1<A>,
182    #[serde(rename = "SctyTrlr", skip_serializing_if = "Option::is_none")]
183    pub scty_trlr: Option<ContentInformationType20>,
184}
185#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
186pub enum EncryptedDataFormat1Code {
187    #[serde(rename = "ASCI")]
188    Asci,
189    #[serde(rename = "BINF")]
190    Binf,
191    #[serde(rename = "EBCD")]
192    Ebcd,
193    #[serde(rename = "HEXF")]
194    Hexf,
195    #[serde(rename = "OTHN")]
196    Othn,
197    #[serde(rename = "OTHP")]
198    Othp,
199    #[default]
200    Unknown,
201}
202#[derive(
203    Debug,
204    Default,
205    Clone,
206    PartialEq,
207    ::serde::Serialize,
208    ::serde::Deserialize,
209    ::derive_builder::Builder,
210    ::validator::Validate,
211)]
212pub struct IsoMax3ALanguageCode {
213    #[validate(regex = "ISO_MAX_3_A_LANGUAGE_CODE_REGEX")]
214    #[serde(rename = "$text")]
215    pub value: String,
216}
217#[derive(
218    Debug,
219    Default,
220    Clone,
221    PartialEq,
222    ::serde::Serialize,
223    ::serde::Deserialize,
224    ::derive_builder::Builder,
225    ::validator::Validate,
226)]
227pub struct IsoTime {
228    #[serde(rename = "$value")]
229    pub value: ::chrono::naive::NaiveTime,
230}
231#[derive(
232    Debug,
233    Default,
234    Clone,
235    PartialEq,
236    ::serde::Serialize,
237    ::serde::Deserialize,
238    ::derive_builder::Builder,
239    ::validator::Validate,
240)]
241pub struct Iso3NumericCountryCode {
242    #[validate(regex = "ISO_3_NUMERIC_COUNTRY_CODE_REGEX")]
243    #[serde(rename = "$text")]
244    pub value: String,
245}
246#[derive(
247    Debug,
248    Default,
249    Clone,
250    PartialEq,
251    ::serde::Serialize,
252    ::serde::Deserialize,
253    ::derive_builder::Builder,
254    ::validator::Validate,
255)]
256pub struct AlgorithmIdentification27 {
257    #[serde(rename = "Algo")]
258    pub algo: Algorithm7Code,
259    #[serde(rename = "Param", skip_serializing_if = "Option::is_none")]
260    pub param: Option<Parameter13>,
261}
262#[derive(
263    Debug,
264    Default,
265    Clone,
266    PartialEq,
267    ::serde::Serialize,
268    ::serde::Deserialize,
269    ::derive_builder::Builder,
270    ::validator::Validate,
271)]
272pub struct Jurisdiction2 {
273    #[serde(rename = "DmstInd", skip_serializing_if = "Option::is_none")]
274    pub dmst_ind: Option<TrueFalseIndicator>,
275    #[serde(rename = "DmstQlfctn", skip_serializing_if = "Option::is_none")]
276    pub dmst_qlfctn: Option<Max35Text>,
277}
278#[derive(
279    Debug,
280    Default,
281    Clone,
282    PartialEq,
283    ::serde::Serialize,
284    ::serde::Deserialize,
285    ::derive_builder::Builder,
286    ::validator::Validate,
287)]
288pub struct Max4NumericText {
289    #[validate(regex = "MAX_4_NUMERIC_TEXT_REGEX")]
290    #[serde(rename = "$text")]
291    pub value: String,
292}
293#[derive(
294    Debug,
295    Default,
296    Clone,
297    PartialEq,
298    ::serde::Serialize,
299    ::serde::Deserialize,
300    ::derive_builder::Builder,
301    ::validator::Validate,
302)]
303pub struct Parameter7 {
304    #[serde(rename = "InitlstnVctr", skip_serializing_if = "Option::is_none")]
305    pub initlstn_vctr: Option<Max500Binary>,
306    #[serde(rename = "BPddg", skip_serializing_if = "Option::is_none")]
307    pub b_pddg: Option<BytePadding1Code>,
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 Max32HexBinaryText {
320    #[validate(regex = "MAX_32_HEX_BINARY_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 ProtectedData1 {
335    #[serde(rename = "CnttTp")]
336    pub cntt_tp: ContentType3Code,
337    #[serde(rename = "EnvlpdData", skip_serializing_if = "Option::is_none")]
338    pub envlpd_data: Option<EnvelopedData6>,
339    #[serde(rename = "NcrptdData", skip_serializing_if = "Option::is_none")]
340    pub ncrptd_data: Option<EncryptedData1>,
341}
342#[derive(
343    Debug,
344    Default,
345    Clone,
346    PartialEq,
347    ::serde::Serialize,
348    ::serde::Deserialize,
349    ::derive_builder::Builder,
350    ::validator::Validate,
351)]
352pub struct Number {
353    #[serde(rename = "$text")]
354    pub value: f64,
355}
356#[derive(
357    Debug,
358    Default,
359    Clone,
360    PartialEq,
361    ::serde::Serialize,
362    ::serde::Deserialize,
363    ::derive_builder::Builder,
364    ::validator::Validate,
365)]
366pub struct Max100KBinary {
367    #[validate(length(min = 1, max = 102400,), regex = "MAX_100_K_BINARY_REGEX")]
368    pub value: String,
369}
370#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
371pub enum Algorithm20Code {
372    #[serde(rename = "HS25")]
373    Hs25,
374    #[serde(rename = "HS38")]
375    Hs38,
376    #[serde(rename = "HS51")]
377    Hs51,
378    #[default]
379    Unknown,
380}
381#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
382pub enum Algorithm7Code {
383    #[serde(rename = "ERSA")]
384    Ersa,
385    #[serde(rename = "RSAO")]
386    Rsao,
387    #[default]
388    Unknown,
389}
390#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
391pub enum ContentType2Code {
392    #[serde(rename = "DATA")]
393    Data,
394    #[serde(rename = "SIGN")]
395    Sign,
396    #[serde(rename = "EVLP")]
397    Evlp,
398    #[serde(rename = "DGST")]
399    Dgst,
400    #[serde(rename = "AUTH")]
401    Auth,
402    #[default]
403    Unknown,
404}
405#[derive(
406    Debug,
407    Default,
408    Clone,
409    PartialEq,
410    ::serde::Serialize,
411    ::serde::Deserialize,
412    ::derive_builder::Builder,
413    ::validator::Validate,
414)]
415pub struct EncryptedData1ChoiceEnum {
416    #[serde(rename = "BinryData", skip_serializing_if = "Option::is_none")]
417    pub binry_data: Option<Max100KBinary>,
418    #[serde(rename = "HexBinryVal", skip_serializing_if = "Option::is_none")]
419    pub hex_binry_val: Option<Max9999HexBinaryText>,
420}
421#[derive(
422    Debug,
423    Default,
424    Clone,
425    PartialEq,
426    ::serde::Serialize,
427    ::serde::Deserialize,
428    ::derive_builder::Builder,
429    ::validator::Validate,
430)]
431pub struct EncryptedData1Choice {
432    #[serde(flatten)]
433    pub value: EncryptedData1ChoiceEnum,
434}
435#[derive(
436    Debug,
437    Default,
438    Clone,
439    PartialEq,
440    ::serde::Serialize,
441    ::serde::Deserialize,
442    ::derive_builder::Builder,
443    ::validator::Validate,
444)]
445pub struct IsoDateTime {
446    #[serde(rename = "$text")]
447    pub value: ::chrono::DateTime<::chrono::Utc>,
448}
449#[derive(
450    Debug,
451    Default,
452    Clone,
453    PartialEq,
454    ::serde::Serialize,
455    ::serde::Deserialize,
456    ::derive_builder::Builder,
457    ::validator::Validate,
458)]
459pub struct Max10NumericText {
460    #[validate(regex = "MAX_10_NUMERIC_TEXT_REGEX")]
461    #[serde(rename = "$text")]
462    pub value: String,
463}
464#[derive(
465    Debug,
466    Default,
467    Clone,
468    PartialEq,
469    ::serde::Serialize,
470    ::serde::Deserialize,
471    ::derive_builder::Builder,
472    ::validator::Validate,
473)]
474pub struct IsoMax3ACountryCode {
475    #[validate(regex = "ISO_MAX_3_A_COUNTRY_CODE_REGEX")]
476    #[serde(rename = "$text")]
477    pub value: String,
478}
479#[derive(
480    Debug,
481    Default,
482    Clone,
483    PartialEq,
484    ::serde::Serialize,
485    ::serde::Deserialize,
486    ::derive_builder::Builder,
487    ::validator::Validate,
488)]
489pub struct Max5NumericText {
490    #[validate(regex = "MAX_5_NUMERIC_TEXT_REGEX")]
491    #[serde(rename = "$text")]
492    pub value: String,
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 ReportContent1 {
505    #[serde(rename = "RptLineSeq", skip_serializing_if = "Option::is_none")]
506    pub rpt_line_seq: Option<Max10NumericText>,
507    #[serde(rename = "FrmtdCntt")]
508    pub frmtd_cntt: ReportContent1Choice,
509}
510#[derive(
511    Debug,
512    Default,
513    Clone,
514    PartialEq,
515    ::serde::Serialize,
516    ::serde::Deserialize,
517    ::derive_builder::Builder,
518    ::validator::Validate,
519)]
520pub struct ContentInformationType20 {
521    #[validate]
522    #[serde(rename = "MACData")]
523    pub mac_data: MacData1,
524    #[validate]
525    #[serde(rename = "MAC")]
526    pub mac: Max8HexBinaryText,
527}
528#[derive(
529    Debug,
530    Default,
531    Clone,
532    PartialEq,
533    ::serde::Serialize,
534    ::serde::Deserialize,
535    ::derive_builder::Builder,
536    ::validator::Validate,
537)]
538pub struct BatchManagementInformation1 {
539    #[serde(rename = "ColltnId", skip_serializing_if = "Option::is_none")]
540    pub colltn_id: Option<Max35Text>,
541    #[validate]
542    #[serde(rename = "BtchId")]
543    pub btch_id: Max35Text,
544    #[serde(rename = "MsgSeqNb", skip_serializing_if = "Option::is_none")]
545    pub msg_seq_nb: Option<Max15NumericText>,
546    #[serde(rename = "MsgChcksmInptVal", skip_serializing_if = "Option::is_none")]
547    pub msg_chcksm_inpt_val: Option<Max140Binary>,
548}
549#[derive(
550    Debug,
551    Default,
552    Clone,
553    PartialEq,
554    ::serde::Serialize,
555    ::serde::Deserialize,
556    ::derive_builder::Builder,
557    ::validator::Validate,
558)]
559pub struct EncryptedContent5 {
560    #[serde(rename = "CnttTp")]
561    pub cntt_tp: ContentType2Code,
562    #[validate]
563    #[serde(rename = "CnttNcrptnAlgo")]
564    pub cntt_ncrptn_algo: AlgorithmIdentification25,
565    #[validate(length(min = 1,))]
566    #[serde(rename = "NcrptdDataElmt", default)]
567    pub ncrptd_data_elmt: Vec<EncryptedDataElement1>,
568}
569#[derive(
570    Debug,
571    Default,
572    Clone,
573    PartialEq,
574    ::serde::Serialize,
575    ::serde::Deserialize,
576    ::derive_builder::Builder,
577    ::validator::Validate,
578)]
579pub struct Max140Binary {
580    #[validate(length(min = 1, max = 140,), regex = "MAX_140_BINARY_REGEX")]
581    pub value: String,
582}
583#[derive(
584    Debug,
585    Default,
586    Clone,
587    PartialEq,
588    ::serde::Serialize,
589    ::serde::Deserialize,
590    ::derive_builder::Builder,
591    ::validator::Validate,
592)]
593pub struct Max99Text {
594    #[validate(length(min = 1, max = 99,))]
595    #[serde(rename = "$text")]
596    pub value: String,
597}
598#[derive(
599    Debug,
600    Default,
601    Clone,
602    PartialEq,
603    ::serde::Serialize,
604    ::serde::Deserialize,
605    ::derive_builder::Builder,
606    ::validator::Validate,
607)]
608pub struct SettlementServiceMode1 {
609    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
610    pub tp: Option<Max35Text>,
611    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
612    pub id: Option<Max35Text>,
613    #[serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none")]
614    pub shrt_nm: Option<Max35Text>,
615    #[serde(rename = "SttlmPrty", skip_serializing_if = "Option::is_none")]
616    pub sttlm_prty: Option<Priority3Code>,
617}
618#[derive(
619    Debug,
620    Default,
621    Clone,
622    PartialEq,
623    ::serde::Serialize,
624    ::serde::Deserialize,
625    ::derive_builder::Builder,
626    ::validator::Validate,
627)]
628pub struct IsoDate {
629    #[serde(rename = "$text")]
630    pub value: ::chrono::NaiveDate,
631}
632#[derive(
633    Debug,
634    Default,
635    Clone,
636    PartialEq,
637    ::serde::Serialize,
638    ::serde::Deserialize,
639    ::derive_builder::Builder,
640    ::validator::Validate,
641)]
642pub struct Max3NumericText {
643    #[validate(regex = "MAX_3_NUMERIC_TEXT_REGEX")]
644    #[serde(rename = "$text")]
645    pub value: String,
646}
647#[derive(
648    Debug,
649    Default,
650    Clone,
651    PartialEq,
652    ::serde::Serialize,
653    ::serde::Deserialize,
654    ::derive_builder::Builder,
655    ::validator::Validate,
656)]
657pub struct Max500Binary {
658    #[validate(length(min = 1, max = 500,), regex = "MAX_500_BINARY_REGEX")]
659    pub value: String,
660}
661#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
662pub enum OutputFormat5Code {
663    #[serde(rename = "OTHN")]
664    Othn,
665    #[serde(rename = "OTHP")]
666    Othp,
667    #[serde(rename = "TEXT")]
668    Text,
669    #[serde(rename = "URLI")]
670    Urli,
671    #[serde(rename = "HTML")]
672    Html,
673    #[serde(rename = "PLIN")]
674    Plin,
675    #[serde(rename = "JSON")]
676    Json,
677    #[serde(rename = "XMLF")]
678    Xmlf,
679    #[serde(rename = "EDIF")]
680    Edif,
681    #[serde(rename = "CSVF")]
682    Csvf,
683    #[serde(rename = "JPEG")]
684    Jpeg,
685    #[serde(rename = "PDFF")]
686    Pdff,
687    #[serde(rename = "PNGF")]
688    Pngf,
689    #[serde(rename = "SVGF")]
690    Svgf,
691    #[default]
692    Unknown,
693}
694#[derive(
695    Debug,
696    Default,
697    Clone,
698    PartialEq,
699    ::serde::Serialize,
700    ::serde::Deserialize,
701    ::derive_builder::Builder,
702    ::validator::Validate,
703)]
704pub struct EncryptedData1 {
705    #[serde(rename = "Ctrl", skip_serializing_if = "Option::is_none")]
706    pub ctrl: Option<Exact1HexBinaryText>,
707    #[serde(rename = "KeySetIdr", skip_serializing_if = "Option::is_none")]
708    pub key_set_idr: Option<Max8NumericText>,
709    #[serde(rename = "DrvdInf", skip_serializing_if = "Option::is_none")]
710    pub drvd_inf: Option<Max32HexBinaryText>,
711    #[serde(rename = "Algo", skip_serializing_if = "Option::is_none")]
712    pub algo: Option<Max2NumericText>,
713    #[serde(rename = "KeyLngth", skip_serializing_if = "Option::is_none")]
714    pub key_lngth: Option<Max4NumericText>,
715    #[serde(rename = "KeyPrtcn", skip_serializing_if = "Option::is_none")]
716    pub key_prtcn: Option<Max2NumericText>,
717    #[serde(rename = "KeyIndx", skip_serializing_if = "Option::is_none")]
718    pub key_indx: Option<Max5NumericText>,
719    #[serde(rename = "PddgMtd", skip_serializing_if = "Option::is_none")]
720    pub pddg_mtd: Option<Max2NumericText>,
721    #[serde(rename = "NcrptdDataFrmt", skip_serializing_if = "Option::is_none")]
722    pub ncrptd_data_frmt: Option<Max2NumericText>,
723    #[validate(length(min = 1,))]
724    #[serde(rename = "NcrptdDataElmt", default)]
725    pub ncrptd_data_elmt: Vec<EncryptedDataElement1>,
726}
727#[derive(
728    Debug,
729    Default,
730    Clone,
731    PartialEq,
732    ::serde::Serialize,
733    ::serde::Deserialize,
734    ::derive_builder::Builder,
735    ::validator::Validate,
736)]
737pub struct Reconciliation3 {
738    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
739    pub id: Option<Max35Text>,
740    #[serde(rename = "Dt", skip_serializing_if = "Option::is_none")]
741    pub dt: Option<IsoDate>,
742    #[serde(rename = "ChckptRef", skip_serializing_if = "Option::is_none")]
743    pub chckpt_ref: Option<Max35Text>,
744}
745#[derive(
746    Debug,
747    Default,
748    Clone,
749    PartialEq,
750    ::serde::Serialize,
751    ::serde::Deserialize,
752    ::derive_builder::Builder,
753    ::validator::Validate,
754)]
755pub struct EncryptedDataElement1 {
756    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
757    pub id: Option<ExternalEncryptedElementIdentification1Code>,
758    #[serde(rename = "OthrId", skip_serializing_if = "Option::is_none")]
759    pub othr_id: Option<Max35Text>,
760    #[serde(rename = "NcrptdData")]
761    pub ncrptd_data: EncryptedData1Choice,
762    #[serde(rename = "ClearTxtDataFrmt", skip_serializing_if = "Option::is_none")]
763    pub clear_txt_data_frmt: Option<EncryptedDataFormat1Code>,
764    #[serde(
765        rename = "OthrClearTxtDataFrmt",
766        skip_serializing_if = "Option::is_none"
767    )]
768    pub othr_clear_txt_data_frmt: Option<Max35Text>,
769}
770#[derive(
771    Debug,
772    Default,
773    Clone,
774    PartialEq,
775    ::serde::Serialize,
776    ::serde::Deserialize,
777    ::derive_builder::Builder,
778    ::validator::Validate,
779)]
780pub struct Max10MbText {
781    #[validate(length(min = 1, max = 10000000,))]
782    #[serde(rename = "$text")]
783    pub value: String,
784}
785#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
786pub enum Frequency17Code {
787    #[serde(rename = "YEAR")]
788    Year,
789    #[serde(rename = "DAIL")]
790    Dail,
791    #[serde(rename = "FRTN")]
792    Frtn,
793    #[serde(rename = "MNTH")]
794    Mnth,
795    #[serde(rename = "QURT")]
796    Qurt,
797    #[serde(rename = "MIAN")]
798    Mian,
799    #[serde(rename = "TEND")]
800    Tend,
801    #[serde(rename = "WEEK")]
802    Week,
803    #[serde(rename = "ADHO")]
804    Adho,
805    #[serde(rename = "SHFT")]
806    Shft,
807    #[serde(rename = "ODMD")]
808    Odmd,
809    #[default]
810    Unknown,
811}
812#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
813pub enum MessageFunction27Code {
814    #[serde(rename = "NOTI")]
815    Noti,
816    #[default]
817    Unknown,
818}
819#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
820pub enum BytePadding1Code {
821    #[serde(rename = "LNGT")]
822    Lngt,
823    #[serde(rename = "NUL8")]
824    Nul8,
825    #[serde(rename = "NULG")]
826    Nulg,
827    #[serde(rename = "NULL")]
828    Null,
829    #[serde(rename = "RAND")]
830    Rand,
831    #[default]
832    Unknown,
833}
834#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
835pub enum Priority3Code {
836    #[serde(rename = "URGT")]
837    Urgt,
838    #[serde(rename = "HIGH")]
839    High,
840    #[serde(rename = "NORM")]
841    Norm,
842    #[default]
843    Unknown,
844}
845#[derive(
846    Debug,
847    Default,
848    Clone,
849    PartialEq,
850    ::serde::Serialize,
851    ::serde::Deserialize,
852    ::derive_builder::Builder,
853    ::validator::Validate,
854)]
855pub struct Environment33 {
856    #[serde(rename = "Orgtr", skip_serializing_if = "Option::is_none")]
857    pub orgtr: Option<PartyIdentification263>,
858    #[serde(rename = "Sndr", skip_serializing_if = "Option::is_none")]
859    pub sndr: Option<PartyIdentification263>,
860    #[serde(rename = "Rcvr", skip_serializing_if = "Option::is_none")]
861    pub rcvr: Option<PartyIdentification263>,
862    #[serde(rename = "Dstn", skip_serializing_if = "Option::is_none")]
863    pub dstn: Option<PartyIdentification263>,
864}
865#[derive(
866    Debug,
867    Default,
868    Clone,
869    PartialEq,
870    ::serde::Serialize,
871    ::serde::Deserialize,
872    ::derive_builder::Builder,
873    ::validator::Validate,
874)]
875pub struct EnvelopedData6 {
876    #[serde(rename = "Vrsn", skip_serializing_if = "Option::is_none")]
877    pub vrsn: Option<Number>,
878    #[validate(length(min = 1,))]
879    #[serde(rename = "Rcpt", default)]
880    pub rcpt: Vec<Recipient7Choice>,
881    #[serde(rename = "NcrptdCntt", skip_serializing_if = "Option::is_none")]
882    pub ncrptd_cntt: Option<EncryptedContent5>,
883}
884#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
885pub enum ContentType3Code {
886    #[serde(rename = "EVLP")]
887    Evlp,
888    #[serde(rename = "IFSE")]
889    Ifse,
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 Exact1HexBinaryText {
904    #[validate(regex = "EXACT_1_HEX_BINARY_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 Max15NumericText {
919    #[validate(regex = "MAX_15_NUMERIC_TEXT_REGEX")]
920    #[serde(rename = "$text")]
921    pub value: String,
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 Traceability9 {
934    #[validate]
935    #[serde(rename = "RlayId")]
936    pub rlay_id: GenericIdentification183,
937    #[serde(rename = "TracDtTmIn", skip_serializing_if = "Option::is_none")]
938    pub trac_dt_tm_in: Option<IsoDateTime>,
939    #[serde(rename = "TracDtTmOut", skip_serializing_if = "Option::is_none")]
940    pub trac_dt_tm_out: Option<IsoDateTime>,
941}
942#[derive(
943    Debug,
944    Default,
945    Clone,
946    PartialEq,
947    ::serde::Serialize,
948    ::serde::Deserialize,
949    ::derive_builder::Builder,
950    ::validator::Validate,
951)]
952pub struct TransactionContext10 {
953    #[serde(rename = "CardPrgrmmApld", skip_serializing_if = "Option::is_none")]
954    pub card_prgrmm_apld: Option<CardProgrammeMode3>,
955    #[serde(rename = "Jursdctn", skip_serializing_if = "Option::is_none")]
956    pub jursdctn: Option<Jurisdiction2>,
957    #[serde(rename = "SttlmSvc", skip_serializing_if = "Option::is_none")]
958    pub sttlm_svc: Option<SettlementService4>,
959    #[serde(rename = "Rcncltn", skip_serializing_if = "Option::is_none")]
960    pub rcncltn: Option<Reconciliation3>,
961    #[validate(length(min = 0,))]
962    #[serde(rename = "AddtlData", default)]
963    pub addtl_data: Vec<AdditionalData1>,
964}
965#[derive(
966    Debug,
967    Default,
968    Clone,
969    PartialEq,
970    ::serde::Serialize,
971    ::serde::Deserialize,
972    ::derive_builder::Builder,
973    ::validator::Validate,
974)]
975pub struct AdditionalData1 {
976    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
977    pub tp: Option<Max35Text>,
978    #[serde(rename = "Val", skip_serializing_if = "Option::is_none")]
979    pub val: Option<Max2048Text>,
980}
981#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
982pub enum Algorithm8Code {
983    #[serde(rename = "MGF1")]
984    Mgf1,
985    #[default]
986    Unknown,
987}
988#[derive(
989    Debug,
990    Default,
991    Clone,
992    PartialEq,
993    ::serde::Serialize,
994    ::serde::Deserialize,
995    ::derive_builder::Builder,
996    ::validator::Validate,
997)]
998pub struct Max2NumericText {
999    #[validate(regex = "MAX_2_NUMERIC_TEXT_REGEX")]
1000    #[serde(rename = "$text")]
1001    pub value: String,
1002}
1003#[derive(
1004    Debug,
1005    Default,
1006    Clone,
1007    PartialEq,
1008    ::serde::Serialize,
1009    ::serde::Deserialize,
1010    ::derive_builder::Builder,
1011    ::validator::Validate,
1012)]
1013pub struct Min5Max16Binary {
1014    #[validate(length(min = 5, max = 16,), regex = "MIN_5_MAX_16_BINARY_REGEX")]
1015    pub value: String,
1016}
1017#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1018pub enum PartyType17Code {
1019    #[serde(rename = "OTHN")]
1020    Othn,
1021    #[serde(rename = "OTHP")]
1022    Othp,
1023    #[serde(rename = "ACQR")]
1024    Acqr,
1025    #[serde(rename = "ACQP")]
1026    Acqp,
1027    #[serde(rename = "CISS")]
1028    Ciss,
1029    #[serde(rename = "CISP")]
1030    Cisp,
1031    #[serde(rename = "AGNT")]
1032    Agnt,
1033    #[default]
1034    Unknown,
1035}
1036#[derive(
1037    Debug,
1038    Default,
1039    Clone,
1040    PartialEq,
1041    ::serde::Serialize,
1042    ::serde::Deserialize,
1043    ::derive_builder::Builder,
1044    ::validator::Validate,
1045)]
1046#[serde(rename = "Document")]
1047pub struct Document<
1048    A: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
1049> {
1050    #[validate]
1051    #[serde(rename = "CstmRpt")]
1052    pub cstm_rpt: CustomReportV01<A>,
1053    #[serde(rename = "@xmlns", default = "namespace")]
1054    pub xmlns: String,
1055}
1056#[derive(
1057    Debug,
1058    Default,
1059    Clone,
1060    PartialEq,
1061    ::serde::Serialize,
1062    ::serde::Deserialize,
1063    ::derive_builder::Builder,
1064    ::validator::Validate,
1065)]
1066pub struct SupplementaryDataEnvelope1<
1067    A: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
1068> {
1069    #[validate]
1070    #[serde(flatten)]
1071    pub value: A,
1072}
1073#[derive(
1074    Debug,
1075    Default,
1076    Clone,
1077    PartialEq,
1078    ::serde::Serialize,
1079    ::serde::Deserialize,
1080    ::derive_builder::Builder,
1081    ::validator::Validate,
1082)]
1083pub struct Context17 {
1084    #[serde(rename = "TxCntxt", skip_serializing_if = "Option::is_none")]
1085    pub tx_cntxt: Option<TransactionContext10>,
1086}
1087#[derive(
1088    Debug,
1089    Default,
1090    Clone,
1091    PartialEq,
1092    ::serde::Serialize,
1093    ::serde::Deserialize,
1094    ::derive_builder::Builder,
1095    ::validator::Validate,
1096)]
1097pub struct CorrectionIdentification1 {
1098    #[serde(rename = "Ind", skip_serializing_if = "Option::is_none")]
1099    pub ind: Option<TrueFalseIndicator>,
1100    #[serde(rename = "Dt", skip_serializing_if = "Option::is_none")]
1101    pub dt: Option<IsoDate>,
1102    #[serde(rename = "Tm", skip_serializing_if = "Option::is_none")]
1103    pub tm: Option<IsoTime>,
1104}
1105#[derive(
1106    Debug,
1107    Default,
1108    Clone,
1109    PartialEq,
1110    ::serde::Serialize,
1111    ::serde::Deserialize,
1112    ::derive_builder::Builder,
1113    ::validator::Validate,
1114)]
1115pub struct Max2048Text {
1116    #[validate(length(min = 1, max = 2048,))]
1117    #[serde(rename = "$text")]
1118    pub value: String,
1119}
1120#[derive(
1121    Debug,
1122    Default,
1123    Clone,
1124    PartialEq,
1125    ::serde::Serialize,
1126    ::serde::Deserialize,
1127    ::derive_builder::Builder,
1128    ::validator::Validate,
1129)]
1130pub struct MacData1 {
1131    #[validate]
1132    #[serde(rename = "Ctrl")]
1133    pub ctrl: Exact1HexBinaryText,
1134    #[validate]
1135    #[serde(rename = "KeySetIdr")]
1136    pub key_set_idr: Max8NumericText,
1137    #[serde(rename = "DrvdInf", skip_serializing_if = "Option::is_none")]
1138    pub drvd_inf: Option<Max32HexBinaryText>,
1139    #[validate]
1140    #[serde(rename = "Algo")]
1141    pub algo: Max2NumericText,
1142    #[serde(rename = "KeyLngth", skip_serializing_if = "Option::is_none")]
1143    pub key_lngth: Option<Max4NumericText>,
1144    #[serde(rename = "KeyPrtcn", skip_serializing_if = "Option::is_none")]
1145    pub key_prtcn: Option<Max2NumericText>,
1146    #[serde(rename = "KeyIndx", skip_serializing_if = "Option::is_none")]
1147    pub key_indx: Option<Max5NumericText>,
1148    #[serde(rename = "PddgMtd", skip_serializing_if = "Option::is_none")]
1149    pub pddg_mtd: Option<Max2NumericText>,
1150    #[serde(rename = "InitlstnVctr", skip_serializing_if = "Option::is_none")]
1151    pub initlstn_vctr: Option<Max32HexBinaryText>,
1152}
1153#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1154pub enum Algorithm23Code {
1155    #[serde(rename = "EA2C")]
1156    Ea2C,
1157    #[serde(rename = "E3DC")]
1158    E3Dc,
1159    #[serde(rename = "EA9C")]
1160    Ea9C,
1161    #[serde(rename = "EA5C")]
1162    Ea5C,
1163    #[serde(rename = "EA2R")]
1164    Ea2R,
1165    #[serde(rename = "EA9R")]
1166    Ea9R,
1167    #[serde(rename = "EA5R")]
1168    Ea5R,
1169    #[serde(rename = "E3DR")]
1170    E3Dr,
1171    #[serde(rename = "E36C")]
1172    E36C,
1173    #[serde(rename = "E36R")]
1174    E36R,
1175    #[serde(rename = "SD5C")]
1176    Sd5C,
1177    #[default]
1178    Unknown,
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 ReportData6 {
1191    #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
1192    pub nm: Option<Max140Text>,
1193    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
1194    pub id: Option<Max140Text>,
1195    #[serde(rename = "Qlfr", skip_serializing_if = "Option::is_none")]
1196    pub qlfr: Option<Max70Text>,
1197    #[serde(rename = "Dt", skip_serializing_if = "Option::is_none")]
1198    pub dt: Option<IsoDate>,
1199    #[serde(rename = "Tm", skip_serializing_if = "Option::is_none")]
1200    pub tm: Option<IsoTime>,
1201    #[serde(rename = "Seq", skip_serializing_if = "Option::is_none")]
1202    pub seq: Option<Max5NumericText>,
1203    #[serde(rename = "TtlOcrncs", skip_serializing_if = "Option::is_none")]
1204    pub ttl_ocrncs: Option<Max5NumericText>,
1205    #[serde(rename = "Frqcy", skip_serializing_if = "Option::is_none")]
1206    pub frqcy: Option<Frequency17Code>,
1207    #[serde(rename = "Crrctn", skip_serializing_if = "Option::is_none")]
1208    pub crrctn: Option<CorrectionIdentification1>,
1209    #[serde(rename = "ConttnInd", skip_serializing_if = "Option::is_none")]
1210    pub conttn_ind: Option<TrueFalseIndicator>,
1211    #[validate(length(min = 0,))]
1212    #[serde(rename = "AddtlData", default)]
1213    pub addtl_data: Vec<AdditionalData1>,
1214    #[serde(rename = "Frmt", skip_serializing_if = "Option::is_none")]
1215    pub frmt: Option<OutputFormat5Code>,
1216    #[serde(rename = "OthrFrmt", skip_serializing_if = "Option::is_none")]
1217    pub othr_frmt: Option<Max35Text>,
1218    #[validate(length(min = 0,))]
1219    #[serde(rename = "Cntt", default)]
1220    pub cntt: Vec<ReportContent1>,
1221}
1222#[derive(
1223    Debug,
1224    Default,
1225    Clone,
1226    PartialEq,
1227    ::serde::Serialize,
1228    ::serde::Deserialize,
1229    ::derive_builder::Builder,
1230    ::validator::Validate,
1231)]
1232pub struct TrueFalseIndicator {
1233    #[serde(rename = "$text")]
1234    pub value: bool,
1235}
1236#[derive(
1237    Debug,
1238    Default,
1239    Clone,
1240    PartialEq,
1241    ::serde::Serialize,
1242    ::serde::Deserialize,
1243    ::derive_builder::Builder,
1244    ::validator::Validate,
1245)]
1246pub struct CustomReport1<
1247    A: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
1248> {
1249    #[validate]
1250    #[serde(rename = "Envt")]
1251    pub envt: Environment33,
1252    #[serde(rename = "Cntxt", skip_serializing_if = "Option::is_none")]
1253    pub cntxt: Option<Context17>,
1254    #[validate]
1255    #[serde(rename = "Rpt")]
1256    pub rpt: ReportData6,
1257    #[validate(length(min = 0,))]
1258    #[serde(rename = "SplmtryData", default)]
1259    pub splmtry_data: Vec<SupplementaryData1<A>>,
1260}
1261#[derive(
1262    Debug,
1263    Default,
1264    Clone,
1265    PartialEq,
1266    ::serde::Serialize,
1267    ::serde::Deserialize,
1268    ::derive_builder::Builder,
1269    ::validator::Validate,
1270)]
1271pub struct Recipient5ChoiceEnum {
1272    #[serde(rename = "IssrAndSrlNb", skip_serializing_if = "Option::is_none")]
1273    pub issr_and_srl_nb: Option<IssuerAndSerialNumber1>,
1274    #[serde(rename = "KeyIdr", skip_serializing_if = "Option::is_none")]
1275    pub key_idr: Option<KekIdentifier2>,
1276}
1277#[derive(
1278    Debug,
1279    Default,
1280    Clone,
1281    PartialEq,
1282    ::serde::Serialize,
1283    ::serde::Deserialize,
1284    ::derive_builder::Builder,
1285    ::validator::Validate,
1286)]
1287pub struct Recipient5Choice {
1288    #[serde(flatten)]
1289    pub value: Recipient5ChoiceEnum,
1290}
1291#[derive(
1292    Debug,
1293    Default,
1294    Clone,
1295    PartialEq,
1296    ::serde::Serialize,
1297    ::serde::Deserialize,
1298    ::derive_builder::Builder,
1299    ::validator::Validate,
1300)]
1301pub struct Max350Text {
1302    #[validate(length(min = 1, max = 350,))]
1303    #[serde(rename = "$text")]
1304    pub value: String,
1305}
1306#[derive(
1307    Debug,
1308    Default,
1309    Clone,
1310    PartialEq,
1311    ::serde::Serialize,
1312    ::serde::Deserialize,
1313    ::derive_builder::Builder,
1314    ::validator::Validate,
1315)]
1316pub struct SettlementReportingEntity1 {
1317    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
1318    pub tp: Option<Max35Text>,
1319    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
1320    pub id: Option<Max35Text>,
1321}
1322#[derive(
1323    Debug,
1324    Default,
1325    Clone,
1326    PartialEq,
1327    ::serde::Serialize,
1328    ::serde::Deserialize,
1329    ::derive_builder::Builder,
1330    ::validator::Validate,
1331)]
1332pub struct Max20MbBinary {
1333    #[validate(length(min = 1, max = 20971520,), regex = "MAX_20_MB_BINARY_REGEX")]
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 SettlementServiceDate2 {
1347    #[serde(rename = "ReqdSttlmDt", skip_serializing_if = "Option::is_none")]
1348    pub reqd_sttlm_dt: Option<IsoDate>,
1349    #[serde(rename = "DfrrdSttlmInd", skip_serializing_if = "Option::is_none")]
1350    pub dfrrd_sttlm_ind: Option<TrueFalseIndicator>,
1351    #[serde(rename = "SttlmDt", skip_serializing_if = "Option::is_none")]
1352    pub sttlm_dt: Option<IsoDate>,
1353    #[serde(rename = "SttlmTm", skip_serializing_if = "Option::is_none")]
1354    pub sttlm_tm: Option<IsoTime>,
1355    #[serde(rename = "SttlmPrd", skip_serializing_if = "Option::is_none")]
1356    pub sttlm_prd: Option<Max35Text>,
1357    #[serde(rename = "SttlmCutOffTm", skip_serializing_if = "Option::is_none")]
1358    pub sttlm_cut_off_tm: Option<IsoDateTime>,
1359}
1360#[derive(
1361    Debug,
1362    Default,
1363    Clone,
1364    PartialEq,
1365    ::serde::Serialize,
1366    ::serde::Deserialize,
1367    ::derive_builder::Builder,
1368    ::validator::Validate,
1369)]
1370pub struct Parameter13 {
1371    #[serde(rename = "DgstAlgo", skip_serializing_if = "Option::is_none")]
1372    pub dgst_algo: Option<Algorithm20Code>,
1373    #[serde(rename = "MskGnrtrAlgo", skip_serializing_if = "Option::is_none")]
1374    pub msk_gnrtr_algo: Option<AlgorithmIdentification26>,
1375}
1376#[derive(
1377    Debug,
1378    Default,
1379    Clone,
1380    PartialEq,
1381    ::serde::Serialize,
1382    ::serde::Deserialize,
1383    ::derive_builder::Builder,
1384    ::validator::Validate,
1385)]
1386pub struct Max140Text {
1387    #[validate(length(min = 1, max = 140,))]
1388    #[serde(rename = "$text")]
1389    pub value: String,
1390}
1391#[derive(
1392    Debug,
1393    Default,
1394    Clone,
1395    PartialEq,
1396    ::serde::Serialize,
1397    ::serde::Deserialize,
1398    ::derive_builder::Builder,
1399    ::validator::Validate,
1400)]
1401pub struct SettlementService4 {
1402    #[serde(rename = "SttlmSvcApld", skip_serializing_if = "Option::is_none")]
1403    pub sttlm_svc_apld: Option<SettlementServiceMode1>,
1404    #[serde(rename = "SttlmSvcDts", skip_serializing_if = "Option::is_none")]
1405    pub sttlm_svc_dts: Option<SettlementServiceDate2>,
1406    #[serde(rename = "SttlmRptgNtty", skip_serializing_if = "Option::is_none")]
1407    pub sttlm_rptg_ntty: Option<SettlementReportingEntity1>,
1408    #[validate(length(min = 0,))]
1409    #[serde(rename = "AddtlSttlmInf", default)]
1410    pub addtl_sttlm_inf: Vec<AdditionalData1>,
1411}
1412#[derive(
1413    Debug,
1414    Default,
1415    Clone,
1416    PartialEq,
1417    ::serde::Serialize,
1418    ::serde::Deserialize,
1419    ::derive_builder::Builder,
1420    ::validator::Validate,
1421)]
1422pub struct Max8NumericText {
1423    #[validate(regex = "MAX_8_NUMERIC_TEXT_REGEX")]
1424    #[serde(rename = "$text")]
1425    pub value: String,
1426}
1427#[derive(
1428    Debug,
1429    Default,
1430    Clone,
1431    PartialEq,
1432    ::serde::Serialize,
1433    ::serde::Deserialize,
1434    ::derive_builder::Builder,
1435    ::validator::Validate,
1436)]
1437pub struct Max210Text {
1438    #[validate(length(min = 1, max = 210,))]
1439    #[serde(rename = "$text")]
1440    pub value: String,
1441}
1442#[derive(
1443    Debug,
1444    Default,
1445    Clone,
1446    PartialEq,
1447    ::serde::Serialize,
1448    ::serde::Deserialize,
1449    ::derive_builder::Builder,
1450    ::validator::Validate,
1451)]
1452pub struct Max35Binary {
1453    #[validate(length(min = 1, max = 35,), regex = "MAX_35_BINARY_REGEX")]
1454    pub value: String,
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 ExternalEncryptedElementIdentification1Code {
1467    #[validate(regex = "EXTERNAL_ENCRYPTED_ELEMENT_IDENTIFICATION_1_CODE_REGEX")]
1468    #[serde(rename = "$text")]
1469    pub value: String,
1470}
1471#[derive(
1472    Debug,
1473    Default,
1474    Clone,
1475    PartialEq,
1476    ::serde::Serialize,
1477    ::serde::Deserialize,
1478    ::derive_builder::Builder,
1479    ::validator::Validate,
1480)]
1481pub struct Max5000Binary {
1482    #[validate(length(min = 1, max = 5000,), regex = "MAX_5000_BINARY_REGEX")]
1483    pub value: String,
1484}
1485#[derive(
1486    Debug,
1487    Default,
1488    Clone,
1489    PartialEq,
1490    ::serde::Serialize,
1491    ::serde::Deserialize,
1492    ::derive_builder::Builder,
1493    ::validator::Validate,
1494)]
1495pub struct Header65 {
1496    #[serde(rename = "MsgFctn")]
1497    pub msg_fctn: MessageFunction27Code,
1498    #[validate]
1499    #[serde(rename = "PrtcolVrsn")]
1500    pub prtcol_vrsn: Max2048Text,
1501    #[serde(rename = "XchgId", skip_serializing_if = "Option::is_none")]
1502    pub xchg_id: Option<Max35Text>,
1503    #[serde(rename = "ReTrnsmssnCntr", skip_serializing_if = "Option::is_none")]
1504    pub re_trnsmssn_cntr: Option<Max3NumericText>,
1505    #[validate]
1506    #[serde(rename = "CreDtTm")]
1507    pub cre_dt_tm: IsoDateTime,
1508    #[serde(rename = "BtchMgmtInf", skip_serializing_if = "Option::is_none")]
1509    pub btch_mgmt_inf: Option<BatchManagementInformation1>,
1510    #[validate]
1511    #[serde(rename = "InitgPty")]
1512    pub initg_pty: GenericIdentification183,
1513    #[serde(rename = "RcptPty", skip_serializing_if = "Option::is_none")]
1514    pub rcpt_pty: Option<GenericIdentification183>,
1515    #[validate(length(min = 0,))]
1516    #[serde(rename = "TracData", default)]
1517    pub trac_data: Vec<AdditionalData1>,
1518    #[validate(length(min = 0,))]
1519    #[serde(rename = "Tracblt", default)]
1520    pub tracblt: Vec<Traceability9>,
1521}
1522#[derive(
1523    Debug,
1524    Default,
1525    Clone,
1526    PartialEq,
1527    ::serde::Serialize,
1528    ::serde::Deserialize,
1529    ::derive_builder::Builder,
1530    ::validator::Validate,
1531)]
1532pub struct Max8HexBinaryText {
1533    #[validate(regex = "MAX_8_HEX_BINARY_TEXT_REGEX")]
1534    #[serde(rename = "$text")]
1535    pub value: String,
1536}
1537#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1538pub enum AttributeType1Code {
1539    #[serde(rename = "CNAT")]
1540    Cnat,
1541    #[serde(rename = "LATT")]
1542    Latt,
1543    #[serde(rename = "OATT")]
1544    Oatt,
1545    #[serde(rename = "OUAT")]
1546    Ouat,
1547    #[serde(rename = "CATT")]
1548    Catt,
1549    #[default]
1550    Unknown,
1551}
1552#[derive(
1553    Debug,
1554    Default,
1555    Clone,
1556    PartialEq,
1557    ::serde::Serialize,
1558    ::serde::Deserialize,
1559    ::derive_builder::Builder,
1560    ::validator::Validate,
1561)]
1562pub struct IssuerAndSerialNumber1 {
1563    #[validate]
1564    #[serde(rename = "Issr")]
1565    pub issr: CertificateIssuer1,
1566    #[validate]
1567    #[serde(rename = "SrlNb")]
1568    pub srl_nb: Max35Binary,
1569}
1570#[derive(
1571    Debug,
1572    Default,
1573    Clone,
1574    PartialEq,
1575    ::serde::Serialize,
1576    ::serde::Deserialize,
1577    ::derive_builder::Builder,
1578    ::validator::Validate,
1579)]
1580pub struct CertificateIssuer1 {
1581    #[validate(length(min = 1,))]
1582    #[serde(rename = "RltvDstngshdNm", default)]
1583    pub rltv_dstngshd_nm: Vec<RelativeDistinguishedName1>,
1584}
1585#[derive(
1586    Debug,
1587    Default,
1588    Clone,
1589    PartialEq,
1590    ::serde::Serialize,
1591    ::serde::Deserialize,
1592    ::derive_builder::Builder,
1593    ::validator::Validate,
1594)]
1595pub struct PartyIdentification263 {
1596    #[validate]
1597    #[serde(rename = "Id")]
1598    pub id: Max11NumericText,
1599    #[serde(rename = "Assgnr", skip_serializing_if = "Option::is_none")]
1600    pub assgnr: Option<Max35Text>,
1601    #[serde(rename = "Ctry", skip_serializing_if = "Option::is_none")]
1602    pub ctry: Option<Iso3NumericCountryCode>,
1603    #[serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none")]
1604    pub shrt_nm: Option<Max35Text>,
1605    #[serde(rename = "LglCorpNm", skip_serializing_if = "Option::is_none")]
1606    pub lgl_corp_nm: Option<Max99Text>,
1607    #[serde(rename = "AddtlId", skip_serializing_if = "Option::is_none")]
1608    pub addtl_id: Option<AdditionalData1>,
1609    #[serde(rename = "LclData", skip_serializing_if = "Option::is_none")]
1610    pub lcl_data: Option<LocalData1>,
1611}
1612#[derive(
1613    Debug,
1614    Default,
1615    Clone,
1616    PartialEq,
1617    ::serde::Serialize,
1618    ::serde::Deserialize,
1619    ::derive_builder::Builder,
1620    ::validator::Validate,
1621)]
1622pub struct Max9999HexBinaryText {
1623    #[validate(regex = "MAX_9999_HEX_BINARY_TEXT_REGEX")]
1624    #[serde(rename = "$text")]
1625    pub value: String,
1626}
1627#[derive(
1628    Debug,
1629    Default,
1630    Clone,
1631    PartialEq,
1632    ::serde::Serialize,
1633    ::serde::Deserialize,
1634    ::derive_builder::Builder,
1635    ::validator::Validate,
1636)]
1637pub struct KekIdentifier2 {
1638    #[validate]
1639    #[serde(rename = "KeyId")]
1640    pub key_id: Max140Text,
1641    #[validate]
1642    #[serde(rename = "KeyVrsn")]
1643    pub key_vrsn: Max140Text,
1644    #[serde(rename = "SeqNb", skip_serializing_if = "Option::is_none")]
1645    pub seq_nb: Option<Number>,
1646    #[serde(rename = "DerivtnId", skip_serializing_if = "Option::is_none")]
1647    pub derivtn_id: Option<Min5Max16Binary>,
1648}
1649#[derive(
1650    Debug,
1651    Default,
1652    Clone,
1653    PartialEq,
1654    ::serde::Serialize,
1655    ::serde::Deserialize,
1656    ::derive_builder::Builder,
1657    ::validator::Validate,
1658)]
1659pub struct RelativeDistinguishedName1 {
1660    #[serde(rename = "AttrTp")]
1661    pub attr_tp: AttributeType1Code,
1662    #[validate]
1663    #[serde(rename = "AttrVal")]
1664    pub attr_val: Max140Text,
1665}
1666#[derive(
1667    Debug,
1668    Default,
1669    Clone,
1670    PartialEq,
1671    ::serde::Serialize,
1672    ::serde::Deserialize,
1673    ::derive_builder::Builder,
1674    ::validator::Validate,
1675)]
1676pub struct ReportContent1ChoiceEnum {
1677    #[serde(rename = "PrtctdData", skip_serializing_if = "Option::is_none")]
1678    pub prtctd_data: Option<ProtectedData1>,
1679    #[serde(rename = "Txt", skip_serializing_if = "Option::is_none")]
1680    pub txt: Option<Max10MbText>,
1681    #[serde(rename = "Binry", skip_serializing_if = "Option::is_none")]
1682    pub binry: Option<Max20MbBinary>,
1683}
1684#[derive(
1685    Debug,
1686    Default,
1687    Clone,
1688    PartialEq,
1689    ::serde::Serialize,
1690    ::serde::Deserialize,
1691    ::derive_builder::Builder,
1692    ::validator::Validate,
1693)]
1694pub struct ReportContent1Choice {
1695    #[serde(flatten)]
1696    pub value: ReportContent1ChoiceEnum,
1697}
1698#[derive(
1699    Debug,
1700    Default,
1701    Clone,
1702    PartialEq,
1703    ::serde::Serialize,
1704    ::serde::Deserialize,
1705    ::derive_builder::Builder,
1706    ::validator::Validate,
1707)]
1708pub struct SupplementaryData1<
1709    A: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
1710> {
1711    #[serde(rename = "PlcAndNm", skip_serializing_if = "Option::is_none")]
1712    pub plc_and_nm: Option<Max350Text>,
1713    #[validate]
1714    #[serde(rename = "Envlp")]
1715    pub envlp: SupplementaryDataEnvelope1<A>,
1716}
1717#[derive(
1718    Debug,
1719    Default,
1720    Clone,
1721    PartialEq,
1722    ::serde::Serialize,
1723    ::serde::Deserialize,
1724    ::derive_builder::Builder,
1725    ::validator::Validate,
1726)]
1727pub struct Kek6 {
1728    #[serde(rename = "Vrsn", skip_serializing_if = "Option::is_none")]
1729    pub vrsn: Option<Number>,
1730    #[validate]
1731    #[serde(rename = "KEKId")]
1732    pub kek_id: KekIdentifier6,
1733    #[validate]
1734    #[serde(rename = "KeyNcrptnAlgo")]
1735    pub key_ncrptn_algo: AlgorithmIdentification28,
1736    #[serde(rename = "NcrptdKey", skip_serializing_if = "Option::is_none")]
1737    pub ncrptd_key: Option<Max500Binary>,
1738}
1739#[derive(
1740    Debug,
1741    Default,
1742    Clone,
1743    PartialEq,
1744    ::serde::Serialize,
1745    ::serde::Deserialize,
1746    ::derive_builder::Builder,
1747    ::validator::Validate,
1748)]
1749pub struct AlgorithmIdentification26 {
1750    #[serde(rename = "Algo")]
1751    pub algo: Algorithm8Code,
1752    #[serde(rename = "Param", skip_serializing_if = "Option::is_none")]
1753    pub param: Option<Algorithm5Code>,
1754}
1755#[derive(
1756    Debug,
1757    Default,
1758    Clone,
1759    PartialEq,
1760    ::serde::Serialize,
1761    ::serde::Deserialize,
1762    ::derive_builder::Builder,
1763    ::validator::Validate,
1764)]
1765pub struct Recipient7ChoiceEnum {
1766    #[serde(rename = "KeyIdr", skip_serializing_if = "Option::is_none")]
1767    pub key_idr: Option<KekIdentifier6>,
1768    #[serde(rename = "KEK", skip_serializing_if = "Option::is_none")]
1769    pub kek: Option<Kek6>,
1770    #[serde(rename = "KeyTrnsprt", skip_serializing_if = "Option::is_none")]
1771    pub key_trnsprt: Option<KeyTransport6>,
1772}
1773#[derive(
1774    Debug,
1775    Default,
1776    Clone,
1777    PartialEq,
1778    ::serde::Serialize,
1779    ::serde::Deserialize,
1780    ::derive_builder::Builder,
1781    ::validator::Validate,
1782)]
1783pub struct Recipient7Choice {
1784    #[serde(flatten)]
1785    pub value: Recipient7ChoiceEnum,
1786}
1787#[derive(
1788    Debug,
1789    Default,
1790    Clone,
1791    PartialEq,
1792    ::serde::Serialize,
1793    ::serde::Deserialize,
1794    ::derive_builder::Builder,
1795    ::validator::Validate,
1796)]
1797pub struct CardProgrammeMode3 {
1798    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
1799    pub tp: Option<Max35Text>,
1800    #[validate]
1801    #[serde(rename = "Id")]
1802    pub id: Max35Text,
1803    #[validate(length(min = 0,))]
1804    #[serde(rename = "AddtlId", default)]
1805    pub addtl_id: Vec<AdditionalData1>,
1806}
1807#[derive(
1808    Debug,
1809    Default,
1810    Clone,
1811    PartialEq,
1812    ::serde::Serialize,
1813    ::serde::Deserialize,
1814    ::derive_builder::Builder,
1815    ::validator::Validate,
1816)]
1817pub struct Max11NumericText {
1818    #[validate(regex = "MAX_11_NUMERIC_TEXT_REGEX")]
1819    #[serde(rename = "$text")]
1820    pub value: String,
1821}
1822#[derive(
1823    Debug,
1824    Default,
1825    Clone,
1826    PartialEq,
1827    ::serde::Serialize,
1828    ::serde::Deserialize,
1829    ::derive_builder::Builder,
1830    ::validator::Validate,
1831)]
1832pub struct Max70Text {
1833    #[validate(length(min = 1, max = 70,))]
1834    #[serde(rename = "$text")]
1835    pub value: String,
1836}
1837#[derive(
1838    Debug,
1839    Default,
1840    Clone,
1841    PartialEq,
1842    ::serde::Serialize,
1843    ::serde::Deserialize,
1844    ::derive_builder::Builder,
1845    ::validator::Validate,
1846)]
1847pub struct AlgorithmIdentification28 {
1848    #[serde(rename = "Algo")]
1849    pub algo: Algorithm13Code,
1850    #[serde(rename = "Param", skip_serializing_if = "Option::is_none")]
1851    pub param: Option<Parameter14>,
1852}
1853#[derive(
1854    Debug,
1855    Default,
1856    Clone,
1857    PartialEq,
1858    ::serde::Serialize,
1859    ::serde::Deserialize,
1860    ::derive_builder::Builder,
1861    ::validator::Validate,
1862)]
1863pub struct KekIdentifier6 {
1864    #[validate]
1865    #[serde(rename = "KeyId")]
1866    pub key_id: Max140Text,
1867    #[serde(rename = "KeyVrsn", skip_serializing_if = "Option::is_none")]
1868    pub key_vrsn: Option<Max140Text>,
1869    #[serde(rename = "SeqNb", skip_serializing_if = "Option::is_none")]
1870    pub seq_nb: Option<Number>,
1871    #[serde(rename = "DerivtnId", skip_serializing_if = "Option::is_none")]
1872    pub derivtn_id: Option<Min5Max16Binary>,
1873}
1874#[derive(
1875    Debug,
1876    Default,
1877    Clone,
1878    PartialEq,
1879    ::serde::Serialize,
1880    ::serde::Deserialize,
1881    ::derive_builder::Builder,
1882    ::validator::Validate,
1883)]
1884pub struct LocalData1 {
1885    #[serde(rename = "Lang")]
1886    pub lang: IsoMax3ALanguageCode,
1887    #[serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none")]
1888    pub shrt_nm: Option<Max70Text>,
1889    #[serde(rename = "LglCorpNm", skip_serializing_if = "Option::is_none")]
1890    pub lgl_corp_nm: Option<Max210Text>,
1891    #[validate(length(min = 0,))]
1892    #[serde(rename = "AddtlData", default)]
1893    pub addtl_data: Vec<AdditionalData1>,
1894}
1895#[derive(
1896    Debug,
1897    Default,
1898    Clone,
1899    PartialEq,
1900    ::serde::Serialize,
1901    ::serde::Deserialize,
1902    ::derive_builder::Builder,
1903    ::validator::Validate,
1904)]
1905pub struct Max35Text {
1906    #[validate(length(min = 1, max = 35,))]
1907    #[serde(rename = "$text")]
1908    pub value: String,
1909}
1910#[derive(
1911    Debug,
1912    Default,
1913    Clone,
1914    PartialEq,
1915    ::serde::Serialize,
1916    ::serde::Deserialize,
1917    ::derive_builder::Builder,
1918    ::validator::Validate,
1919)]
1920pub struct Parameter14 {
1921    #[serde(rename = "NcrptnFrmt", skip_serializing_if = "Option::is_none")]
1922    pub ncrptn_frmt: Option<EncryptionFormat3Code>,
1923    #[serde(rename = "InitlstnVctr", skip_serializing_if = "Option::is_none")]
1924    pub initlstn_vctr: Option<Max500Binary>,
1925    #[serde(rename = "BPddg", skip_serializing_if = "Option::is_none")]
1926    pub b_pddg: Option<BytePadding1Code>,
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 AlgorithmIdentification25 {
1939    #[serde(rename = "Algo")]
1940    pub algo: Algorithm23Code,
1941    #[serde(rename = "Param", skip_serializing_if = "Option::is_none")]
1942    pub param: Option<Parameter7>,
1943}
1944#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1945pub enum EncryptionFormat3Code {
1946    #[serde(rename = "TR34")]
1947    Tr34,
1948    #[serde(rename = "TR31")]
1949    Tr31,
1950    #[serde(rename = "CTCE")]
1951    Ctce,
1952    #[serde(rename = "CBCE")]
1953    Cbce,
1954    #[default]
1955    Unknown,
1956}
1957#[derive(
1958    Debug,
1959    Default,
1960    Clone,
1961    PartialEq,
1962    ::serde::Serialize,
1963    ::serde::Deserialize,
1964    ::derive_builder::Builder,
1965    ::validator::Validate,
1966)]
1967pub struct GenericIdentification183 {
1968    #[validate]
1969    #[serde(rename = "Id")]
1970    pub id: Max35Text,
1971    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
1972    pub tp: Option<PartyType17Code>,
1973    #[serde(rename = "OthrTp", skip_serializing_if = "Option::is_none")]
1974    pub othr_tp: Option<Max35Text>,
1975    #[serde(rename = "Assgnr", skip_serializing_if = "Option::is_none")]
1976    pub assgnr: Option<PartyType18Code>,
1977    #[serde(rename = "Ctry", skip_serializing_if = "Option::is_none")]
1978    pub ctry: Option<IsoMax3ACountryCode>,
1979    #[serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none")]
1980    pub shrt_nm: Option<Max35Text>,
1981}
1982#[derive(
1983    Debug,
1984    Default,
1985    Clone,
1986    PartialEq,
1987    ::serde::Serialize,
1988    ::serde::Deserialize,
1989    ::derive_builder::Builder,
1990    ::validator::Validate,
1991)]
1992pub struct KeyTransport6 {
1993    #[serde(rename = "Vrsn", skip_serializing_if = "Option::is_none")]
1994    pub vrsn: Option<Number>,
1995    #[serde(rename = "RcptId")]
1996    pub rcpt_id: Recipient5Choice,
1997    #[validate]
1998    #[serde(rename = "KeyNcrptnAlgo")]
1999    pub key_ncrptn_algo: AlgorithmIdentification27,
2000    #[validate]
2001    #[serde(rename = "NcrptdKey")]
2002    pub ncrptd_key: Max5000Binary,
2003}
iso_20022_caad/caad_010_001_01.rs

iso_20022_caad/
caad_010_001_01.rs
