iso_20022_caam/
caam_003_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 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();
25}
26
27::lazy_static::lazy_static! {
28    static ref MIN_2_MAX_3_ALPHA_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[a-zA-Z]{2,3}"#).unwrap();
29}
30
31::lazy_static::lazy_static! {
32    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();
33}
34
35::lazy_static::lazy_static! {
36    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();
37}
38
39::lazy_static::lazy_static! {
40    static ref MAX_3_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,3}"#).unwrap();
41}
42
43::lazy_static::lazy_static! {
44    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();
45}
46
47::lazy_static::lazy_static! {
48    static ref COUNTRY_CODE_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Z]{2,2}"#).unwrap();
49}
50
51::lazy_static::lazy_static! {
52    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();
53}
54
55::lazy_static::lazy_static! {
56    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();
57}
58
59::lazy_static::lazy_static! {
60    static ref MAX_3000_BINARY_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Za-z0-9+/]{4}*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?"#).unwrap();
61}
62
63/// Returns the namespace of the schema
64pub fn namespace() -> String {
65    "urn:iso:std:iso:20022:tech:xsd:caam.003.001.03".to_string()
66}
67
68#[derive(
69    Debug,
70    Default,
71    Clone,
72    PartialEq,
73    ::serde::Serialize,
74    ::serde::Deserialize,
75    ::derive_builder::Builder,
76    ::validator::Validate,
77)]
78pub struct AtmSecurityConfiguration2 {
79    #[serde(rename = "MaxSmmtrcKey", skip_serializing_if = "Option::is_none")]
80    pub max_smmtrc_key: Option<Number>,
81    #[serde(rename = "MaxAsmmtrcKey", skip_serializing_if = "Option::is_none")]
82    pub max_asmmtrc_key: Option<Number>,
83    #[serde(rename = "MaxRSAKeyLngth", skip_serializing_if = "Option::is_none")]
84    pub max_rsa_key_lngth: Option<Number>,
85    #[serde(rename = "MaxRootKeyLngth", skip_serializing_if = "Option::is_none")]
86    pub max_root_key_lngth: Option<Number>,
87}
88#[derive(
89    Debug,
90    Default,
91    Clone,
92    PartialEq,
93    ::serde::Serialize,
94    ::serde::Deserialize,
95    ::derive_builder::Builder,
96    ::validator::Validate,
97)]
98pub struct AtmSignature2ChoiceEnum {
99    #[serde(rename = "DgtlSgntr", skip_serializing_if = "Option::is_none")]
100    pub dgtl_sgntr: Option<ContentInformationType14>,
101    #[serde(rename = "TRRltdData", skip_serializing_if = "Option::is_none")]
102    pub tr_rltd_data: Option<TrRelatedData2>,
103}
104#[derive(
105    Debug,
106    Default,
107    Clone,
108    PartialEq,
109    ::serde::Serialize,
110    ::serde::Deserialize,
111    ::derive_builder::Builder,
112    ::validator::Validate,
113)]
114pub struct AtmSignature2Choice {
115    #[serde(flatten)]
116    pub value: AtmSignature2ChoiceEnum,
117}
118#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
119pub enum Algorithm15Code {
120    #[serde(rename = "EA2C")]
121    Ea2C,
122    #[serde(rename = "E3DC")]
123    E3Dc,
124    #[serde(rename = "EA9C")]
125    Ea9C,
126    #[serde(rename = "EA5C")]
127    Ea5C,
128    #[default]
129    Unknown,
130}
131#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
132pub enum ContentType2Code {
133    #[serde(rename = "DATA")]
134    Data,
135    #[serde(rename = "SIGN")]
136    Sign,
137    #[serde(rename = "EVLP")]
138    Evlp,
139    #[serde(rename = "DGST")]
140    Dgst,
141    #[serde(rename = "AUTH")]
142    Auth,
143    #[default]
144    Unknown,
145}
146#[derive(
147    Debug,
148    Default,
149    Clone,
150    PartialEq,
151    ::serde::Serialize,
152    ::serde::Deserialize,
153    ::derive_builder::Builder,
154    ::validator::Validate,
155)]
156pub struct AtmSecurityConfiguration5 {
157    #[validate(length(min = 0,))]
158    #[serde(rename = "PINFrmt", default)]
159    pub pin_frmt: Vec<PinFormat4Code>,
160    #[serde(rename = "PINLngthCpblties", skip_serializing_if = "Option::is_none")]
161    pub pin_lngth_cpblties: Option<Number>,
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 AlgorithmIdentification13 {
174    #[serde(rename = "Algo")]
175    pub algo: Algorithm13Code,
176    #[serde(rename = "Param", skip_serializing_if = "Option::is_none")]
177    pub param: Option<Parameter6>,
178}
179#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
180pub enum DataSetCategory7Code {
181    #[serde(rename = "ATMC")]
182    Atmc,
183    #[serde(rename = "ATMP")]
184    Atmp,
185    #[serde(rename = "APPR")]
186    Appr,
187    #[serde(rename = "CRAP")]
188    Crap,
189    #[serde(rename = "CPRC")]
190    Cprc,
191    #[serde(rename = "OEXR")]
192    Oexr,
193    #[serde(rename = "AMNT")]
194    Amnt,
195    #[serde(rename = "LOCC")]
196    Locc,
197    #[serde(rename = "MNOC")]
198    Mnoc,
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 EnvelopedData4 {
213    #[serde(rename = "Vrsn", skip_serializing_if = "Option::is_none")]
214    pub vrsn: Option<Number>,
215    #[validate(length(min = 1,))]
216    #[serde(rename = "Rcpt", default)]
217    pub rcpt: Vec<Recipient4Choice>,
218    #[serde(rename = "NcrptdCntt", skip_serializing_if = "Option::is_none")]
219    pub ncrptd_cntt: Option<EncryptedContent3>,
220}
221#[derive(
222    Debug,
223    Default,
224    Clone,
225    PartialEq,
226    ::serde::Serialize,
227    ::serde::Deserialize,
228    ::derive_builder::Builder,
229    ::validator::Validate,
230)]
231pub struct KekIdentifier2 {
232    #[validate]
233    #[serde(rename = "KeyId")]
234    pub key_id: Max140Text,
235    #[validate]
236    #[serde(rename = "KeyVrsn")]
237    pub key_vrsn: Max140Text,
238    #[serde(rename = "SeqNb", skip_serializing_if = "Option::is_none")]
239    pub seq_nb: Option<Number>,
240    #[serde(rename = "DerivtnId", skip_serializing_if = "Option::is_none")]
241    pub derivtn_id: Option<Min5Max16Binary>,
242}
243#[derive(
244    Debug,
245    Default,
246    Clone,
247    PartialEq,
248    ::serde::Serialize,
249    ::serde::Deserialize,
250    ::derive_builder::Builder,
251    ::validator::Validate,
252)]
253pub struct KeyChoiceValue2Enum {
254    #[serde(rename = "TRRltdData", skip_serializing_if = "Option::is_none")]
255    pub tr_rltd_data: Option<TrRelatedData2>,
256    #[serde(rename = "NcrptdKeyVal", skip_serializing_if = "Option::is_none")]
257    pub ncrptd_key_val: Option<ContentInformationType10>,
258}
259#[derive(
260    Debug,
261    Default,
262    Clone,
263    PartialEq,
264    ::serde::Serialize,
265    ::serde::Deserialize,
266    ::derive_builder::Builder,
267    ::validator::Validate,
268)]
269pub struct KeyChoiceValue2 {
270    #[serde(flatten)]
271    pub value: KeyChoiceValue2Enum,
272}
273#[derive(
274    Debug,
275    Default,
276    Clone,
277    PartialEq,
278    ::serde::Serialize,
279    ::serde::Deserialize,
280    ::derive_builder::Builder,
281    ::validator::Validate,
282)]
283pub struct Acquirer7 {
284    #[serde(rename = "AcqrgInstn", skip_serializing_if = "Option::is_none")]
285    pub acqrg_instn: Option<Max35Text>,
286    #[serde(rename = "Brnch", skip_serializing_if = "Option::is_none")]
287    pub brnch: Option<Max35Text>,
288}
289#[derive(
290    Debug,
291    Default,
292    Clone,
293    PartialEq,
294    ::serde::Serialize,
295    ::serde::Deserialize,
296    ::derive_builder::Builder,
297    ::validator::Validate,
298)]
299pub struct Max70Text {
300    #[validate(length(min = 1, max = 70,))]
301    #[serde(rename = "$text")]
302    pub value: String,
303}
304#[derive(
305    Debug,
306    Default,
307    Clone,
308    PartialEq,
309    ::serde::Serialize,
310    ::serde::Deserialize,
311    ::derive_builder::Builder,
312    ::validator::Validate,
313)]
314pub struct Min5Max16Binary {
315    #[validate(length(min = 5, max = 16,), regex = "MIN_5_MAX_16_BINARY_REGEX")]
316    pub value: String,
317}
318#[derive(
319    Debug,
320    Default,
321    Clone,
322    PartialEq,
323    ::serde::Serialize,
324    ::serde::Deserialize,
325    ::derive_builder::Builder,
326    ::validator::Validate,
327)]
328pub struct Parameter6 {
329    #[serde(rename = "NcrptnFrmt", skip_serializing_if = "Option::is_none")]
330    pub ncrptn_frmt: Option<EncryptionFormat1Code>,
331    #[serde(rename = "InitlstnVctr", skip_serializing_if = "Option::is_none")]
332    pub initlstn_vctr: Option<Max500Binary>,
333    #[serde(rename = "BPddg", skip_serializing_if = "Option::is_none")]
334    pub b_pddg: Option<BytePadding1Code>,
335}
336#[derive(
337    Debug,
338    Default,
339    Clone,
340    PartialEq,
341    ::serde::Serialize,
342    ::serde::Deserialize,
343    ::derive_builder::Builder,
344    ::validator::Validate,
345)]
346pub struct Number {
347    #[serde(rename = "$text")]
348    pub value: f64,
349}
350#[derive(
351    Debug,
352    Default,
353    Clone,
354    PartialEq,
355    ::serde::Serialize,
356    ::serde::Deserialize,
357    ::derive_builder::Builder,
358    ::validator::Validate,
359)]
360pub struct Signer3 {
361    #[serde(rename = "Vrsn", skip_serializing_if = "Option::is_none")]
362    pub vrsn: Option<Number>,
363    #[serde(rename = "SgnrId", skip_serializing_if = "Option::is_none")]
364    pub sgnr_id: Option<Recipient5Choice>,
365    #[validate]
366    #[serde(rename = "DgstAlgo")]
367    pub dgst_algo: AlgorithmIdentification16,
368    #[validate]
369    #[serde(rename = "SgntrAlgo")]
370    pub sgntr_algo: AlgorithmIdentification17,
371    #[validate]
372    #[serde(rename = "Sgntr")]
373    pub sgntr: Max3000Binary,
374}
375#[derive(
376    Debug,
377    Default,
378    Clone,
379    PartialEq,
380    ::serde::Serialize,
381    ::serde::Deserialize,
382    ::derive_builder::Builder,
383    ::validator::Validate,
384)]
385pub struct SignedData4 {
386    #[serde(rename = "Vrsn", skip_serializing_if = "Option::is_none")]
387    pub vrsn: Option<Number>,
388    #[validate(length(min = 1,))]
389    #[serde(rename = "DgstAlgo", default)]
390    pub dgst_algo: Vec<AlgorithmIdentification16>,
391    #[validate]
392    #[serde(rename = "NcpsltdCntt")]
393    pub ncpsltd_cntt: EncapsulatedContent3,
394    #[validate(length(min = 0,))]
395    #[serde(rename = "Cert", default)]
396    pub cert: Vec<Max5000Binary>,
397    #[validate(length(min = 1,))]
398    #[serde(rename = "Sgnr", default)]
399    pub sgnr: Vec<Signer3>,
400}
401#[derive(
402    Debug,
403    Default,
404    Clone,
405    PartialEq,
406    ::serde::Serialize,
407    ::serde::Deserialize,
408    ::derive_builder::Builder,
409    ::validator::Validate,
410)]
411pub struct TerminalHosting1 {
412    #[serde(rename = "Ctgy", skip_serializing_if = "Option::is_none")]
413    pub ctgy: Option<TransactionEnvironment3Code>,
414    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
415    pub id: Option<Max35Text>,
416}
417#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
418pub enum TransactionEnvironment3Code {
419    #[serde(rename = "BRCH")]
420    Brch,
421    #[serde(rename = "MERC")]
422    Merc,
423    #[serde(rename = "OTHR")]
424    Othr,
425    #[default]
426    Unknown,
427}
428#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
429pub enum BytePadding1Code {
430    #[serde(rename = "LNGT")]
431    Lngt,
432    #[serde(rename = "NUL8")]
433    Nul8,
434    #[serde(rename = "NULG")]
435    Nulg,
436    #[serde(rename = "NULL")]
437    Null,
438    #[serde(rename = "RAND")]
439    Rand,
440    #[default]
441    Unknown,
442}
443#[derive(
444    Debug,
445    Default,
446    Clone,
447    PartialEq,
448    ::serde::Serialize,
449    ::serde::Deserialize,
450    ::derive_builder::Builder,
451    ::validator::Validate,
452)]
453pub struct AlgorithmIdentification16 {
454    #[serde(rename = "Algo")]
455    pub algo: Algorithm11Code,
456}
457#[derive(
458    Debug,
459    Default,
460    Clone,
461    PartialEq,
462    ::serde::Serialize,
463    ::serde::Deserialize,
464    ::derive_builder::Builder,
465    ::validator::Validate,
466)]
467pub struct Min2Max3AlphaText {
468    #[validate(regex = "MIN_2_MAX_3_ALPHA_TEXT_REGEX")]
469    #[serde(rename = "$text")]
470    pub value: String,
471}
472#[derive(
473    Debug,
474    Default,
475    Clone,
476    PartialEq,
477    ::serde::Serialize,
478    ::serde::Deserialize,
479    ::derive_builder::Builder,
480    ::validator::Validate,
481)]
482#[serde(rename = "Document")]
483pub struct Document {
484    #[validate]
485    #[serde(rename = "ATMKeyDwnldReq")]
486    pub atm_key_dwnld_req: AtmKeyDownloadRequestV03,
487    #[serde(rename = "@xmlns", default = "namespace")]
488    pub xmlns: String,
489}
490#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
491pub enum Algorithm11Code {
492    #[serde(rename = "HS25")]
493    Hs25,
494    #[serde(rename = "HS38")]
495    Hs38,
496    #[serde(rename = "HS51")]
497    Hs51,
498    #[serde(rename = "HS01")]
499    Hs01,
500    #[default]
501    Unknown,
502}
503#[derive(
504    Debug,
505    Default,
506    Clone,
507    PartialEq,
508    ::serde::Serialize,
509    ::serde::Deserialize,
510    ::derive_builder::Builder,
511    ::validator::Validate,
512)]
513pub struct Max140Text {
514    #[validate(length(min = 1, max = 140,))]
515    #[serde(rename = "$text")]
516    pub value: String,
517}
518#[derive(
519    Debug,
520    Default,
521    Clone,
522    PartialEq,
523    ::serde::Serialize,
524    ::serde::Deserialize,
525    ::derive_builder::Builder,
526    ::validator::Validate,
527)]
528pub struct Parameter4 {
529    #[serde(rename = "NcrptnFrmt", skip_serializing_if = "Option::is_none")]
530    pub ncrptn_frmt: Option<EncryptionFormat1Code>,
531    #[serde(rename = "DgstAlgo", skip_serializing_if = "Option::is_none")]
532    pub dgst_algo: Option<Algorithm11Code>,
533    #[serde(rename = "MskGnrtrAlgo", skip_serializing_if = "Option::is_none")]
534    pub msk_gnrtr_algo: Option<AlgorithmIdentification12>,
535}
536#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
537pub enum PartyType12Code {
538    #[serde(rename = "ACQR")]
539    Acqr,
540    #[serde(rename = "ATMG")]
541    Atmg,
542    #[serde(rename = "CISP")]
543    Cisp,
544    #[serde(rename = "DLIS")]
545    Dlis,
546    #[serde(rename = "HSTG")]
547    Hstg,
548    #[serde(rename = "ITAG")]
549    Itag,
550    #[serde(rename = "OATM")]
551    Oatm,
552    #[default]
553    Unknown,
554}
555#[derive(
556    Debug,
557    Default,
558    Clone,
559    PartialEq,
560    ::serde::Serialize,
561    ::serde::Deserialize,
562    ::derive_builder::Builder,
563    ::validator::Validate,
564)]
565pub struct Recipient4ChoiceEnum {
566    #[serde(rename = "KEK", skip_serializing_if = "Option::is_none")]
567    pub kek: Option<Kek4>,
568    #[serde(rename = "KeyIdr", skip_serializing_if = "Option::is_none")]
569    pub key_idr: Option<KekIdentifier2>,
570    #[serde(rename = "KeyTrnsprt", skip_serializing_if = "Option::is_none")]
571    pub key_trnsprt: Option<KeyTransport4>,
572}
573#[derive(
574    Debug,
575    Default,
576    Clone,
577    PartialEq,
578    ::serde::Serialize,
579    ::serde::Deserialize,
580    ::derive_builder::Builder,
581    ::validator::Validate,
582)]
583pub struct Recipient4Choice {
584    #[serde(flatten)]
585    pub value: Recipient4ChoiceEnum,
586}
587#[derive(
588    Debug,
589    Default,
590    Clone,
591    PartialEq,
592    ::serde::Serialize,
593    ::serde::Deserialize,
594    ::derive_builder::Builder,
595    ::validator::Validate,
596)]
597pub struct TrRelatedData2 {
598    #[serde(rename = "TR34Cmd", skip_serializing_if = "Option::is_none")]
599    pub tr_34_cmd: Option<Tr34Command1Code>,
600    #[serde(rename = "TRBlck", skip_serializing_if = "Option::is_none")]
601    pub tr_blck: Option<Max100KBinary>,
602}
603#[derive(
604    Debug,
605    Default,
606    Clone,
607    PartialEq,
608    ::serde::Serialize,
609    ::serde::Deserialize,
610    ::derive_builder::Builder,
611    ::validator::Validate,
612)]
613pub struct TrueFalseIndicator {
614    #[serde(rename = "$text")]
615    pub value: bool,
616}
617#[derive(
618    Debug,
619    Default,
620    Clone,
621    PartialEq,
622    ::serde::Serialize,
623    ::serde::Deserialize,
624    ::derive_builder::Builder,
625    ::validator::Validate,
626)]
627pub struct PublicRsaKey1 {
628    #[validate]
629    #[serde(rename = "Mdlus")]
630    pub mdlus: Max5000Binary,
631    #[validate]
632    #[serde(rename = "Expnt")]
633    pub expnt: Max5000Binary,
634}
635#[derive(
636    Debug,
637    Default,
638    Clone,
639    PartialEq,
640    ::serde::Serialize,
641    ::serde::Deserialize,
642    ::derive_builder::Builder,
643    ::validator::Validate,
644)]
645pub struct Max256Text {
646    #[validate(length(min = 1, max = 256,))]
647    #[serde(rename = "$text")]
648    pub value: String,
649}
650#[derive(
651    Debug,
652    Default,
653    Clone,
654    PartialEq,
655    ::serde::Serialize,
656    ::serde::Deserialize,
657    ::derive_builder::Builder,
658    ::validator::Validate,
659)]
660pub struct Max500Binary {
661    #[validate(length(min = 1, max = 500,), regex = "MAX_500_BINARY_REGEX")]
662    pub value: String,
663}
664#[derive(
665    Debug,
666    Default,
667    Clone,
668    PartialEq,
669    ::serde::Serialize,
670    ::serde::Deserialize,
671    ::derive_builder::Builder,
672    ::validator::Validate,
673)]
674pub struct AtmMessageFunction2 {
675    #[serde(rename = "Fctn")]
676    pub fctn: MessageFunction11Code,
677    #[serde(rename = "ATMSvcCd", skip_serializing_if = "Option::is_none")]
678    pub atm_svc_cd: Option<Max35Text>,
679    #[serde(rename = "HstSvcCd", skip_serializing_if = "Option::is_none")]
680    pub hst_svc_cd: Option<Max35Text>,
681}
682#[derive(
683    Debug,
684    Default,
685    Clone,
686    PartialEq,
687    ::serde::Serialize,
688    ::serde::Deserialize,
689    ::derive_builder::Builder,
690    ::validator::Validate,
691)]
692pub struct Parameter7 {
693    #[serde(rename = "InitlstnVctr", skip_serializing_if = "Option::is_none")]
694    pub initlstn_vctr: Option<Max500Binary>,
695    #[serde(rename = "BPddg", skip_serializing_if = "Option::is_none")]
696    pub b_pddg: Option<BytePadding1Code>,
697}
698#[derive(
699    Debug,
700    Default,
701    Clone,
702    PartialEq,
703    ::serde::Serialize,
704    ::serde::Deserialize,
705    ::derive_builder::Builder,
706    ::validator::Validate,
707)]
708pub struct SecurityParameters9 {
709    #[serde(rename = "Key", skip_serializing_if = "Option::is_none")]
710    pub key: Option<CryptographicKey12>,
711    #[serde(rename = "SgntrChc", skip_serializing_if = "Option::is_none")]
712    pub sgntr_chc: Option<AtmSignature2Choice>,
713    #[validate(length(min = 0,))]
714    #[serde(rename = "Cert", default)]
715    pub cert: Vec<Max5000Binary>,
716    #[serde(rename = "ATMChllng", skip_serializing_if = "Option::is_none")]
717    pub atm_chllng: Option<Max140Binary>,
718    #[serde(rename = "ReqdKey", skip_serializing_if = "Option::is_none")]
719    pub reqd_key: Option<Max35Text>,
720}
721#[derive(
722    Debug,
723    Default,
724    Clone,
725    PartialEq,
726    ::serde::Serialize,
727    ::serde::Deserialize,
728    ::derive_builder::Builder,
729    ::validator::Validate,
730)]
731pub struct EncryptedContent3 {
732    #[serde(rename = "CnttTp")]
733    pub cntt_tp: ContentType2Code,
734    #[validate]
735    #[serde(rename = "CnttNcrptnAlgo")]
736    pub cntt_ncrptn_algo: AlgorithmIdentification14,
737    #[validate]
738    #[serde(rename = "NcrptdData")]
739    pub ncrptd_data: Max100KBinary,
740}
741#[derive(
742    Debug,
743    Default,
744    Clone,
745    PartialEq,
746    ::serde::Serialize,
747    ::serde::Deserialize,
748    ::derive_builder::Builder,
749    ::validator::Validate,
750)]
751pub struct GeographicLocation1ChoiceEnum {
752    #[serde(rename = "GeogcCordints", skip_serializing_if = "Option::is_none")]
753    pub geogc_cordints: Option<GeographicCoordinates1>,
754    #[serde(rename = "UTMCordints", skip_serializing_if = "Option::is_none")]
755    pub utm_cordints: Option<UtmCoordinates1>,
756}
757#[derive(
758    Debug,
759    Default,
760    Clone,
761    PartialEq,
762    ::serde::Serialize,
763    ::serde::Deserialize,
764    ::derive_builder::Builder,
765    ::validator::Validate,
766)]
767pub struct GeographicLocation1Choice {
768    #[serde(flatten)]
769    pub value: GeographicLocation1ChoiceEnum,
770}
771#[derive(
772    Debug,
773    Default,
774    Clone,
775    PartialEq,
776    ::serde::Serialize,
777    ::serde::Deserialize,
778    ::derive_builder::Builder,
779    ::validator::Validate,
780)]
781pub struct Max35Binary {
782    #[validate(length(min = 1, max = 35,), regex = "MAX_35_BINARY_REGEX")]
783    pub value: String,
784}
785#[derive(
786    Debug,
787    Default,
788    Clone,
789    PartialEq,
790    ::serde::Serialize,
791    ::serde::Deserialize,
792    ::derive_builder::Builder,
793    ::validator::Validate,
794)]
795pub struct EncapsulatedContent3 {
796    #[serde(rename = "CnttTp")]
797    pub cntt_tp: ContentType2Code,
798    #[serde(rename = "Cntt", skip_serializing_if = "Option::is_none")]
799    pub cntt: Option<Max100KBinary>,
800}
801#[derive(
802    Debug,
803    Default,
804    Clone,
805    PartialEq,
806    ::serde::Serialize,
807    ::serde::Deserialize,
808    ::derive_builder::Builder,
809    ::validator::Validate,
810)]
811pub struct Recipient5ChoiceEnum {
812    #[serde(rename = "KeyIdr", skip_serializing_if = "Option::is_none")]
813    pub key_idr: Option<KekIdentifier2>,
814    #[serde(rename = "IssrAndSrlNb", skip_serializing_if = "Option::is_none")]
815    pub issr_and_srl_nb: Option<IssuerAndSerialNumber1>,
816}
817#[derive(
818    Debug,
819    Default,
820    Clone,
821    PartialEq,
822    ::serde::Serialize,
823    ::serde::Deserialize,
824    ::derive_builder::Builder,
825    ::validator::Validate,
826)]
827pub struct Recipient5Choice {
828    #[serde(flatten)]
829    pub value: Recipient5ChoiceEnum,
830}
831#[derive(
832    Debug,
833    Default,
834    Clone,
835    PartialEq,
836    ::serde::Serialize,
837    ::serde::Deserialize,
838    ::derive_builder::Builder,
839    ::validator::Validate,
840)]
841pub struct AtmSecurityConfiguration1 {
842    #[serde(rename = "Keys", skip_serializing_if = "Option::is_none")]
843    pub keys: Option<AtmSecurityConfiguration2>,
844    #[serde(rename = "Ncrptn", skip_serializing_if = "Option::is_none")]
845    pub ncrptn: Option<AtmSecurityConfiguration3>,
846    #[validate(length(min = 0,))]
847    #[serde(rename = "MACAlgo", default)]
848    pub mac_algo: Vec<Algorithm12Code>,
849    #[validate(length(min = 0,))]
850    #[serde(rename = "DgstAlgo", default)]
851    pub dgst_algo: Vec<Algorithm11Code>,
852    #[serde(rename = "DgtlSgntr", skip_serializing_if = "Option::is_none")]
853    pub dgtl_sgntr: Option<AtmSecurityConfiguration4>,
854    #[serde(rename = "PIN", skip_serializing_if = "Option::is_none")]
855    pub pin: Option<AtmSecurityConfiguration5>,
856    #[validate(length(min = 0,))]
857    #[serde(rename = "MsgPrtcn", default)]
858    pub msg_prtcn: Vec<MessageProtection1Code>,
859}
860#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
861pub enum AtmSecurityScheme3Code {
862    #[serde(rename = "APPK")]
863    Appk,
864    #[serde(rename = "CERT")]
865    Cert,
866    #[serde(rename = "FRAN")]
867    Fran,
868    #[serde(rename = "DTCH")]
869    Dtch,
870    #[serde(rename = "LUXG")]
871    Luxg,
872    #[serde(rename = "MANU")]
873    Manu,
874    #[serde(rename = "PKIP")]
875    Pkip,
876    #[serde(rename = "SIGN")]
877    Sign,
878    #[serde(rename = "NONE")]
879    None,
880    #[serde(rename = "TR34")]
881    Tr34,
882    #[default]
883    Unknown,
884}
885#[derive(
886    Debug,
887    Default,
888    Clone,
889    PartialEq,
890    ::serde::Serialize,
891    ::serde::Deserialize,
892    ::derive_builder::Builder,
893    ::validator::Validate,
894)]
895pub struct AtmCommand12 {
896    #[serde(rename = "Tp")]
897    pub tp: AtmCommand6Code,
898    #[serde(rename = "CmdId", skip_serializing_if = "Option::is_none")]
899    pub cmd_id: Option<AtmCommandIdentification1>,
900}
901#[derive(
902    Debug,
903    Default,
904    Clone,
905    PartialEq,
906    ::serde::Serialize,
907    ::serde::Deserialize,
908    ::derive_builder::Builder,
909    ::validator::Validate,
910)]
911pub struct ContentInformationType10 {
912    #[serde(rename = "CnttTp")]
913    pub cntt_tp: ContentType2Code,
914    #[validate]
915    #[serde(rename = "EnvlpdData")]
916    pub envlpd_data: EnvelopedData4,
917}
918#[derive(
919    Debug,
920    Default,
921    Clone,
922    PartialEq,
923    ::serde::Serialize,
924    ::serde::Deserialize,
925    ::derive_builder::Builder,
926    ::validator::Validate,
927)]
928pub struct AtmEquipment1 {
929    #[serde(rename = "Manfctr", skip_serializing_if = "Option::is_none")]
930    pub manfctr: Option<Max35Text>,
931    #[serde(rename = "Mdl", skip_serializing_if = "Option::is_none")]
932    pub mdl: Option<Max35Text>,
933    #[serde(rename = "SrlNb", skip_serializing_if = "Option::is_none")]
934    pub srl_nb: Option<Max35Text>,
935    #[serde(rename = "ApplPrvdr", skip_serializing_if = "Option::is_none")]
936    pub appl_prvdr: Option<Max35Text>,
937    #[serde(rename = "ApplNm", skip_serializing_if = "Option::is_none")]
938    pub appl_nm: Option<Max35Text>,
939    #[serde(rename = "ApplVrsn", skip_serializing_if = "Option::is_none")]
940    pub appl_vrsn: Option<Max35Text>,
941    #[serde(rename = "ApprvlNb", skip_serializing_if = "Option::is_none")]
942    pub apprvl_nb: Option<Max35Text>,
943    #[validate(length(min = 0,))]
944    #[serde(rename = "CfgtnParam", default)]
945    pub cfgtn_param: Vec<AtmConfigurationParameter1>,
946}
947#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
948pub enum CryptographicKeyType3Code {
949    #[serde(rename = "AES2")]
950    Aes2,
951    #[serde(rename = "EDE3")]
952    Ede3,
953    #[serde(rename = "DKP9")]
954    Dkp9,
955    #[serde(rename = "AES9")]
956    Aes9,
957    #[serde(rename = "AES5")]
958    Aes5,
959    #[serde(rename = "EDE4")]
960    Ede4,
961    #[default]
962    Unknown,
963}
964#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
965pub enum KeyUsage1Code {
966    #[serde(rename = "ENCR")]
967    Encr,
968    #[serde(rename = "DCPT")]
969    Dcpt,
970    #[serde(rename = "DENC")]
971    Denc,
972    #[serde(rename = "DDEC")]
973    Ddec,
974    #[serde(rename = "TRNI")]
975    Trni,
976    #[serde(rename = "TRNX")]
977    Trnx,
978    #[serde(rename = "MACG")]
979    Macg,
980    #[serde(rename = "MACV")]
981    Macv,
982    #[serde(rename = "SIGG")]
983    Sigg,
984    #[serde(rename = "SUGV")]
985    Sugv,
986    #[serde(rename = "PINE")]
987    Pine,
988    #[serde(rename = "PIND")]
989    Pind,
990    #[serde(rename = "PINV")]
991    Pinv,
992    #[serde(rename = "KEYG")]
993    Keyg,
994    #[serde(rename = "KEYI")]
995    Keyi,
996    #[serde(rename = "KEYX")]
997    Keyx,
998    #[serde(rename = "KEYD")]
999    Keyd,
1000    #[default]
1001    Unknown,
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 Max3NumericText {
1014    #[validate(regex = "MAX_3_NUMERIC_TEXT_REGEX")]
1015    #[serde(rename = "$text")]
1016    pub value: String,
1017}
1018#[derive(
1019    Debug,
1020    Default,
1021    Clone,
1022    PartialEq,
1023    ::serde::Serialize,
1024    ::serde::Deserialize,
1025    ::derive_builder::Builder,
1026    ::validator::Validate,
1027)]
1028pub struct Max6Text {
1029    #[validate(length(min = 1, max = 6,))]
1030    #[serde(rename = "$text")]
1031    pub value: String,
1032}
1033#[derive(
1034    Debug,
1035    Default,
1036    Clone,
1037    PartialEq,
1038    ::serde::Serialize,
1039    ::serde::Deserialize,
1040    ::derive_builder::Builder,
1041    ::validator::Validate,
1042)]
1043pub struct AtmEquipment3 {
1044    #[serde(rename = "Manfctr", skip_serializing_if = "Option::is_none")]
1045    pub manfctr: Option<Max35Text>,
1046    #[serde(rename = "Mdl", skip_serializing_if = "Option::is_none")]
1047    pub mdl: Option<Max35Text>,
1048    #[serde(rename = "Vrsn", skip_serializing_if = "Option::is_none")]
1049    pub vrsn: Option<Max35Text>,
1050    #[serde(rename = "SrlNb", skip_serializing_if = "Option::is_none")]
1051    pub srl_nb: Option<Max35Text>,
1052    #[serde(rename = "SgndSrlNb", skip_serializing_if = "Option::is_none")]
1053    pub sgnd_srl_nb: Option<ContentInformationType14>,
1054    #[serde(rename = "FrmwrPrvdr", skip_serializing_if = "Option::is_none")]
1055    pub frmwr_prvdr: Option<Max35Text>,
1056    #[serde(rename = "FrmwrId", skip_serializing_if = "Option::is_none")]
1057    pub frmwr_id: Option<Max35Text>,
1058    #[serde(rename = "FrmwrVrsn", skip_serializing_if = "Option::is_none")]
1059    pub frmwr_vrsn: Option<Max35Text>,
1060}
1061#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1062pub enum Algorithm14Code {
1063    #[serde(rename = "ERS2")]
1064    Ers2,
1065    #[serde(rename = "ERS1")]
1066    Ers1,
1067    #[serde(rename = "RPSS")]
1068    Rpss,
1069    #[default]
1070    Unknown,
1071}
1072#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1073pub enum Algorithm7Code {
1074    #[serde(rename = "ERSA")]
1075    Ersa,
1076    #[serde(rename = "RSAO")]
1077    Rsao,
1078    #[default]
1079    Unknown,
1080}
1081#[derive(
1082    Debug,
1083    Default,
1084    Clone,
1085    PartialEq,
1086    ::serde::Serialize,
1087    ::serde::Deserialize,
1088    ::derive_builder::Builder,
1089    ::validator::Validate,
1090)]
1091pub struct Parameter8 {
1092    #[serde(rename = "DgstAlgo")]
1093    pub dgst_algo: Algorithm11Code,
1094    #[validate]
1095    #[serde(rename = "MskGnrtrAlgo")]
1096    pub msk_gnrtr_algo: AlgorithmIdentification12,
1097    #[validate]
1098    #[serde(rename = "SaltLngth")]
1099    pub salt_lngth: Number,
1100    #[serde(rename = "TrlrFld", skip_serializing_if = "Option::is_none")]
1101    pub trlr_fld: Option<Number>,
1102}
1103#[derive(
1104    Debug,
1105    Default,
1106    Clone,
1107    PartialEq,
1108    ::serde::Serialize,
1109    ::serde::Deserialize,
1110    ::derive_builder::Builder,
1111    ::validator::Validate,
1112)]
1113pub struct RelativeDistinguishedName1 {
1114    #[serde(rename = "AttrTp")]
1115    pub attr_tp: AttributeType1Code,
1116    #[validate]
1117    #[serde(rename = "AttrVal")]
1118    pub attr_val: Max140Text,
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 PostalAddress17 {
1131    #[validate(length(min = 0, max = 2,))]
1132    #[serde(rename = "AdrLine", default)]
1133    pub adr_line: Vec<Max70Text>,
1134    #[serde(rename = "StrtNm", skip_serializing_if = "Option::is_none")]
1135    pub strt_nm: Option<Max70Text>,
1136    #[serde(rename = "BldgNb", skip_serializing_if = "Option::is_none")]
1137    pub bldg_nb: Option<Max16Text>,
1138    #[serde(rename = "PstCd", skip_serializing_if = "Option::is_none")]
1139    pub pst_cd: Option<Max16Text>,
1140    #[validate]
1141    #[serde(rename = "TwnNm")]
1142    pub twn_nm: Max35Text,
1143    #[validate(length(min = 0, max = 2,))]
1144    #[serde(rename = "CtrySubDvsn", default)]
1145    pub ctry_sub_dvsn: Vec<Max35Text>,
1146    #[serde(rename = "Ctry")]
1147    pub ctry: CountryCode,
1148    #[serde(rename = "GLctn", skip_serializing_if = "Option::is_none")]
1149    pub g_lctn: Option<GeographicLocation1Choice>,
1150}
1151#[derive(
1152    Debug,
1153    Default,
1154    Clone,
1155    PartialEq,
1156    ::serde::Serialize,
1157    ::serde::Deserialize,
1158    ::derive_builder::Builder,
1159    ::validator::Validate,
1160)]
1161pub struct CryptographicKey12 {
1162    #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
1163    pub nm: Option<Max140Text>,
1164    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
1165    pub id: Option<Max140Text>,
1166    #[serde(rename = "SctyDomnId", skip_serializing_if = "Option::is_none")]
1167    pub scty_domn_id: Option<Max35Text>,
1168    #[serde(rename = "AddtlId", skip_serializing_if = "Option::is_none")]
1169    pub addtl_id: Option<Max35Binary>,
1170    #[serde(rename = "Vrsn", skip_serializing_if = "Option::is_none")]
1171    pub vrsn: Option<Max256Text>,
1172    #[serde(rename = "SeqCntr", skip_serializing_if = "Option::is_none")]
1173    pub seq_cntr: Option<Number>,
1174    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
1175    pub tp: Option<CryptographicKeyType3Code>,
1176    #[validate(length(min = 0,))]
1177    #[serde(rename = "Fctn", default)]
1178    pub fctn: Vec<KeyUsage1Code>,
1179    #[serde(rename = "ActvtnDt", skip_serializing_if = "Option::is_none")]
1180    pub actvtn_dt: Option<IsoDateTime>,
1181    #[serde(rename = "DeactvtnDt", skip_serializing_if = "Option::is_none")]
1182    pub deactvtn_dt: Option<IsoDateTime>,
1183    #[serde(rename = "KeyChckVal", skip_serializing_if = "Option::is_none")]
1184    pub key_chck_val: Option<Max35Binary>,
1185    #[serde(rename = "PblcKeyVal", skip_serializing_if = "Option::is_none")]
1186    pub pblc_key_val: Option<PublicRsaKey1>,
1187    #[serde(rename = "KeyChcVal", skip_serializing_if = "Option::is_none")]
1188    pub key_chc_val: Option<KeyChoiceValue2>,
1189}
1190#[derive(
1191    Debug,
1192    Default,
1193    Clone,
1194    PartialEq,
1195    ::serde::Serialize,
1196    ::serde::Deserialize,
1197    ::derive_builder::Builder,
1198    ::validator::Validate,
1199)]
1200pub struct Max5000Binary {
1201    #[validate(length(min = 1, max = 5000,), regex = "MAX_5000_BINARY_REGEX")]
1202    pub value: String,
1203}
1204#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1205pub enum Algorithm12Code {
1206    #[serde(rename = "MACC")]
1207    Macc,
1208    #[serde(rename = "MCCS")]
1209    Mccs,
1210    #[serde(rename = "CMA1")]
1211    Cma1,
1212    #[serde(rename = "MCC1")]
1213    Mcc1,
1214    #[serde(rename = "CMA9")]
1215    Cma9,
1216    #[serde(rename = "CMA5")]
1217    Cma5,
1218    #[default]
1219    Unknown,
1220}
1221#[derive(
1222    Debug,
1223    Default,
1224    Clone,
1225    PartialEq,
1226    ::serde::Serialize,
1227    ::serde::Deserialize,
1228    ::derive_builder::Builder,
1229    ::validator::Validate,
1230)]
1231pub struct AutomatedTellerMachine6 {
1232    #[validate]
1233    #[serde(rename = "Id")]
1234    pub id: Max35Text,
1235    #[serde(rename = "AddtlId", skip_serializing_if = "Option::is_none")]
1236    pub addtl_id: Option<Max35Text>,
1237    #[serde(rename = "SeqNb", skip_serializing_if = "Option::is_none")]
1238    pub seq_nb: Option<Max35Text>,
1239    #[serde(rename = "Lctn", skip_serializing_if = "Option::is_none")]
1240    pub lctn: Option<PostalAddress17>,
1241    #[serde(rename = "LctnCtgy", skip_serializing_if = "Option::is_none")]
1242    pub lctn_ctgy: Option<TransactionEnvironment2Code>,
1243    #[serde(rename = "Eqpmnt", skip_serializing_if = "Option::is_none")]
1244    pub eqpmnt: Option<AtmEquipment1>,
1245}
1246#[derive(
1247    Debug,
1248    Default,
1249    Clone,
1250    PartialEq,
1251    ::serde::Serialize,
1252    ::serde::Deserialize,
1253    ::derive_builder::Builder,
1254    ::validator::Validate,
1255)]
1256pub struct IssuerAndSerialNumber1 {
1257    #[validate]
1258    #[serde(rename = "Issr")]
1259    pub issr: CertificateIssuer1,
1260    #[validate]
1261    #[serde(rename = "SrlNb")]
1262    pub srl_nb: Max35Binary,
1263}
1264#[derive(
1265    Debug,
1266    Default,
1267    Clone,
1268    PartialEq,
1269    ::serde::Serialize,
1270    ::serde::Deserialize,
1271    ::derive_builder::Builder,
1272    ::validator::Validate,
1273)]
1274pub struct AtmEnvironment15 {
1275    #[serde(rename = "Acqrr", skip_serializing_if = "Option::is_none")]
1276    pub acqrr: Option<Acquirer7>,
1277    #[serde(rename = "ATMMgrId", skip_serializing_if = "Option::is_none")]
1278    pub atm_mgr_id: Option<Max35Text>,
1279    #[serde(rename = "HstgNtty", skip_serializing_if = "Option::is_none")]
1280    pub hstg_ntty: Option<TerminalHosting1>,
1281    #[validate]
1282    #[serde(rename = "ATM")]
1283    pub atm: AutomatedTellerMachine6,
1284}
1285#[derive(
1286    Debug,
1287    Default,
1288    Clone,
1289    PartialEq,
1290    ::serde::Serialize,
1291    ::serde::Deserialize,
1292    ::derive_builder::Builder,
1293    ::validator::Validate,
1294)]
1295pub struct AlgorithmIdentification14 {
1296    #[serde(rename = "Algo")]
1297    pub algo: Algorithm15Code,
1298    #[serde(rename = "Param", skip_serializing_if = "Option::is_none")]
1299    pub param: Option<Parameter6>,
1300}
1301#[derive(
1302    Debug,
1303    Default,
1304    Clone,
1305    PartialEq,
1306    ::serde::Serialize,
1307    ::serde::Deserialize,
1308    ::derive_builder::Builder,
1309    ::validator::Validate,
1310)]
1311pub struct CountryCode {
1312    #[validate(regex = "COUNTRY_CODE_REGEX")]
1313    #[serde(rename = "$text")]
1314    pub value: String,
1315}
1316#[derive(
1317    Debug,
1318    Default,
1319    Clone,
1320    PartialEq,
1321    ::serde::Serialize,
1322    ::serde::Deserialize,
1323    ::derive_builder::Builder,
1324    ::validator::Validate,
1325)]
1326pub struct AtmSecurityConfiguration3 {
1327    #[serde(rename = "AsmmtrcNcrptn", skip_serializing_if = "Option::is_none")]
1328    pub asmmtrc_ncrptn: Option<TrueFalseIndicator>,
1329    #[serde(rename = "AsmmtrcKeyStdId", skip_serializing_if = "Option::is_none")]
1330    pub asmmtrc_key_std_id: Option<TrueFalseIndicator>,
1331    #[validate(length(min = 0,))]
1332    #[serde(rename = "AsmmtrcNcrptnAlgo", default)]
1333    pub asmmtrc_ncrptn_algo: Vec<Algorithm7Code>,
1334    #[serde(rename = "SmmtrcTrnsprtKey", skip_serializing_if = "Option::is_none")]
1335    pub smmtrc_trnsprt_key: Option<TrueFalseIndicator>,
1336    #[validate(length(min = 0,))]
1337    #[serde(rename = "SmmtrcTrnsprtKeyAlgo", default)]
1338    pub smmtrc_trnsprt_key_algo: Vec<Algorithm13Code>,
1339    #[validate(length(min = 0,))]
1340    #[serde(rename = "SmmtrcNcrptnAlgo", default)]
1341    pub smmtrc_ncrptn_algo: Vec<Algorithm15Code>,
1342    #[validate(length(min = 0,))]
1343    #[serde(rename = "NcrptnFrmt", default)]
1344    pub ncrptn_frmt: Vec<EncryptionFormat1Code>,
1345}
1346#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1347pub enum TerminalManagementActionResult2Code {
1348    #[serde(rename = "CNTE")]
1349    Cnte,
1350    #[serde(rename = "FMTE")]
1351    Fmte,
1352    #[serde(rename = "HRDW")]
1353    Hrdw,
1354    #[serde(rename = "NSUP")]
1355    Nsup,
1356    #[serde(rename = "SECR")]
1357    Secr,
1358    #[serde(rename = "SUCC")]
1359    Succ,
1360    #[serde(rename = "SYNE")]
1361    Syne,
1362    #[serde(rename = "TIMO")]
1363    Timo,
1364    #[serde(rename = "UKRF")]
1365    Ukrf,
1366    #[default]
1367    Unknown,
1368}
1369#[derive(
1370    Debug,
1371    Default,
1372    Clone,
1373    PartialEq,
1374    ::serde::Serialize,
1375    ::serde::Deserialize,
1376    ::derive_builder::Builder,
1377    ::validator::Validate,
1378)]
1379pub struct ContentInformationType13 {
1380    #[serde(rename = "CnttTp")]
1381    pub cntt_tp: ContentType2Code,
1382    #[serde(rename = "AuthntcdData", skip_serializing_if = "Option::is_none")]
1383    pub authntcd_data: Option<AuthenticatedData4>,
1384    #[serde(rename = "SgndData", skip_serializing_if = "Option::is_none")]
1385    pub sgnd_data: Option<SignedData4>,
1386}
1387#[derive(
1388    Debug,
1389    Default,
1390    Clone,
1391    PartialEq,
1392    ::serde::Serialize,
1393    ::serde::Deserialize,
1394    ::derive_builder::Builder,
1395    ::validator::Validate,
1396)]
1397pub struct AtmCommand11 {
1398    #[serde(rename = "Tp")]
1399    pub tp: AtmCommand6Code,
1400    #[serde(rename = "ReqrdDtTm", skip_serializing_if = "Option::is_none")]
1401    pub reqrd_dt_tm: Option<IsoDateTime>,
1402    #[validate]
1403    #[serde(rename = "PrcdDtTm")]
1404    pub prcd_dt_tm: IsoDateTime,
1405    #[serde(rename = "CmdId", skip_serializing_if = "Option::is_none")]
1406    pub cmd_id: Option<AtmCommandIdentification1>,
1407    #[serde(rename = "Rslt")]
1408    pub rslt: TerminalManagementActionResult2Code,
1409    #[serde(rename = "AddtlErrInf", skip_serializing_if = "Option::is_none")]
1410    pub addtl_err_inf: Option<Max140Text>,
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 AlgorithmIdentification11 {
1423    #[serde(rename = "Algo")]
1424    pub algo: Algorithm7Code,
1425    #[serde(rename = "Param", skip_serializing_if = "Option::is_none")]
1426    pub param: Option<Parameter4>,
1427}
1428#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1429pub enum Algorithm13Code {
1430    #[serde(rename = "EA2C")]
1431    Ea2C,
1432    #[serde(rename = "E3DC")]
1433    E3Dc,
1434    #[serde(rename = "DKP9")]
1435    Dkp9,
1436    #[serde(rename = "UKPT")]
1437    Ukpt,
1438    #[serde(rename = "UKA1")]
1439    Uka1,
1440    #[serde(rename = "EA9C")]
1441    Ea9C,
1442    #[serde(rename = "EA5C")]
1443    Ea5C,
1444    #[default]
1445    Unknown,
1446}
1447#[derive(
1448    Debug,
1449    Default,
1450    Clone,
1451    PartialEq,
1452    ::serde::Serialize,
1453    ::serde::Deserialize,
1454    ::derive_builder::Builder,
1455    ::validator::Validate,
1456)]
1457pub struct Max35Text {
1458    #[validate(length(min = 1, max = 35,))]
1459    #[serde(rename = "$text")]
1460    pub value: String,
1461}
1462#[derive(
1463    Debug,
1464    Default,
1465    Clone,
1466    PartialEq,
1467    ::serde::Serialize,
1468    ::serde::Deserialize,
1469    ::derive_builder::Builder,
1470    ::validator::Validate,
1471)]
1472pub struct Header31 {
1473    #[validate]
1474    #[serde(rename = "MsgFctn")]
1475    pub msg_fctn: AtmMessageFunction2,
1476    #[validate]
1477    #[serde(rename = "PrtcolVrsn")]
1478    pub prtcol_vrsn: Max6Text,
1479    #[validate]
1480    #[serde(rename = "XchgId")]
1481    pub xchg_id: Max3NumericText,
1482    #[validate]
1483    #[serde(rename = "CreDtTm")]
1484    pub cre_dt_tm: IsoDateTime,
1485    #[validate]
1486    #[serde(rename = "InitgPty")]
1487    pub initg_pty: Max35Text,
1488    #[serde(rename = "RcptPty", skip_serializing_if = "Option::is_none")]
1489    pub rcpt_pty: Option<Max35Text>,
1490    #[serde(rename = "PrcStat", skip_serializing_if = "Option::is_none")]
1491    pub prc_stat: Option<Max35Text>,
1492    #[validate(length(min = 0,))]
1493    #[serde(rename = "Tracblt", default)]
1494    pub tracblt: Vec<Traceability4>,
1495}
1496#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1497pub enum Algorithm8Code {
1498    #[serde(rename = "MGF1")]
1499    Mgf1,
1500    #[default]
1501    Unknown,
1502}
1503#[derive(
1504    Debug,
1505    Default,
1506    Clone,
1507    PartialEq,
1508    ::serde::Serialize,
1509    ::serde::Deserialize,
1510    ::derive_builder::Builder,
1511    ::validator::Validate,
1512)]
1513pub struct AlgorithmIdentification12 {
1514    #[serde(rename = "Algo")]
1515    pub algo: Algorithm8Code,
1516    #[serde(rename = "Param", skip_serializing_if = "Option::is_none")]
1517    pub param: Option<Parameter5>,
1518}
1519#[derive(
1520    Debug,
1521    Default,
1522    Clone,
1523    PartialEq,
1524    ::serde::Serialize,
1525    ::serde::Deserialize,
1526    ::derive_builder::Builder,
1527    ::validator::Validate,
1528)]
1529pub struct Max16Text {
1530    #[validate(length(min = 1, max = 16,))]
1531    #[serde(rename = "$text")]
1532    pub value: String,
1533}
1534#[derive(
1535    Debug,
1536    Default,
1537    Clone,
1538    PartialEq,
1539    ::serde::Serialize,
1540    ::serde::Deserialize,
1541    ::derive_builder::Builder,
1542    ::validator::Validate,
1543)]
1544pub struct AtmConfigurationParameter1 {
1545    #[serde(rename = "Tp")]
1546    pub tp: DataSetCategory7Code,
1547    #[validate]
1548    #[serde(rename = "Vrsn")]
1549    pub vrsn: Max35Text,
1550}
1551#[derive(
1552    Debug,
1553    Default,
1554    Clone,
1555    PartialEq,
1556    ::serde::Serialize,
1557    ::serde::Deserialize,
1558    ::derive_builder::Builder,
1559    ::validator::Validate,
1560)]
1561pub struct KeyTransport4 {
1562    #[serde(rename = "Vrsn", skip_serializing_if = "Option::is_none")]
1563    pub vrsn: Option<Number>,
1564    #[serde(rename = "RcptId")]
1565    pub rcpt_id: Recipient5Choice,
1566    #[validate]
1567    #[serde(rename = "KeyNcrptnAlgo")]
1568    pub key_ncrptn_algo: AlgorithmIdentification11,
1569    #[validate]
1570    #[serde(rename = "NcrptdKey")]
1571    pub ncrptd_key: Max5000Binary,
1572}
1573#[derive(
1574    Debug,
1575    Default,
1576    Clone,
1577    PartialEq,
1578    ::serde::Serialize,
1579    ::serde::Deserialize,
1580    ::derive_builder::Builder,
1581    ::validator::Validate,
1582)]
1583pub struct Max140Binary {
1584    #[validate(length(min = 1, max = 140,), regex = "MAX_140_BINARY_REGEX")]
1585    pub value: String,
1586}
1587#[derive(
1588    Debug,
1589    Default,
1590    Clone,
1591    PartialEq,
1592    ::serde::Serialize,
1593    ::serde::Deserialize,
1594    ::derive_builder::Builder,
1595    ::validator::Validate,
1596)]
1597pub struct AtmSecurityConfiguration4 {
1598    #[serde(rename = "MaxCerts", skip_serializing_if = "Option::is_none")]
1599    pub max_certs: Option<Number>,
1600    #[serde(rename = "MaxSgntrs", skip_serializing_if = "Option::is_none")]
1601    pub max_sgntrs: Option<Number>,
1602    #[validate(length(min = 0,))]
1603    #[serde(rename = "DgtlSgntrAlgo", default)]
1604    pub dgtl_sgntr_algo: Vec<Algorithm14Code>,
1605}
1606#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1607pub enum PinFormat4Code {
1608    #[serde(rename = "ANSI")]
1609    Ansi,
1610    #[serde(rename = "BNCM")]
1611    Bncm,
1612    #[serde(rename = "BKSY")]
1613    Bksy,
1614    #[serde(rename = "DBLD")]
1615    Dbld,
1616    #[serde(rename = "DBLC")]
1617    Dblc,
1618    #[serde(rename = "ECI2")]
1619    Eci2,
1620    #[serde(rename = "ECI3")]
1621    Eci3,
1622    #[serde(rename = "EMVS")]
1623    Emvs,
1624    #[serde(rename = "IBM3")]
1625    Ibm3,
1626    #[serde(rename = "ISO0")]
1627    Iso0,
1628    #[serde(rename = "ISO1")]
1629    Iso1,
1630    #[serde(rename = "ISO2")]
1631    Iso2,
1632    #[serde(rename = "ISO3")]
1633    Iso3,
1634    #[serde(rename = "ISO4")]
1635    Iso4,
1636    #[serde(rename = "ISO5")]
1637    Iso5,
1638    #[serde(rename = "VIS2")]
1639    Vis2,
1640    #[serde(rename = "VIS3")]
1641    Vis3,
1642    #[default]
1643    Unknown,
1644}
1645#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1646pub enum Tr34Command1Code {
1647    #[serde(rename = "BIND")]
1648    Bind,
1649    #[serde(rename = "HILR")]
1650    Hilr,
1651    #[serde(rename = "HILU")]
1652    Hilu,
1653    #[serde(rename = "RBND")]
1654    Rbnd,
1655    #[serde(rename = "UBND")]
1656    Ubnd,
1657    #[default]
1658    Unknown,
1659}
1660#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1661pub enum MessageProtection1Code {
1662    #[serde(rename = "EVLP")]
1663    Evlp,
1664    #[serde(rename = "MACB")]
1665    Macb,
1666    #[serde(rename = "MACM")]
1667    Macm,
1668    #[serde(rename = "UNPR")]
1669    Unpr,
1670    #[default]
1671    Unknown,
1672}
1673#[derive(
1674    Debug,
1675    Default,
1676    Clone,
1677    PartialEq,
1678    ::serde::Serialize,
1679    ::serde::Deserialize,
1680    ::derive_builder::Builder,
1681    ::validator::Validate,
1682)]
1683pub struct Traceability4 {
1684    #[validate]
1685    #[serde(rename = "RlayId")]
1686    pub rlay_id: GenericIdentification77,
1687    #[serde(rename = "SeqNb", skip_serializing_if = "Option::is_none")]
1688    pub seq_nb: Option<Max35Text>,
1689    #[validate]
1690    #[serde(rename = "TracDtTmIn")]
1691    pub trac_dt_tm_in: IsoDateTime,
1692    #[validate]
1693    #[serde(rename = "TracDtTmOut")]
1694    pub trac_dt_tm_out: IsoDateTime,
1695}
1696#[derive(
1697    Debug,
1698    Default,
1699    Clone,
1700    PartialEq,
1701    ::serde::Serialize,
1702    ::serde::Deserialize,
1703    ::derive_builder::Builder,
1704    ::validator::Validate,
1705)]
1706pub struct AlgorithmIdentification17 {
1707    #[serde(rename = "Algo")]
1708    pub algo: Algorithm14Code,
1709    #[serde(rename = "Param", skip_serializing_if = "Option::is_none")]
1710    pub param: Option<Parameter8>,
1711}
1712#[derive(
1713    Debug,
1714    Default,
1715    Clone,
1716    PartialEq,
1717    ::serde::Serialize,
1718    ::serde::Deserialize,
1719    ::derive_builder::Builder,
1720    ::validator::Validate,
1721)]
1722pub struct AtmKeyDownloadRequest4 {
1723    #[validate]
1724    #[serde(rename = "Envt")]
1725    pub envt: AtmEnvironment15,
1726    #[validate(length(min = 0,))]
1727    #[serde(rename = "CmdRslt", default)]
1728    pub cmd_rslt: Vec<AtmCommand11>,
1729    #[serde(rename = "CmdCntxt", skip_serializing_if = "Option::is_none")]
1730    pub cmd_cntxt: Option<AtmCommand12>,
1731    #[validate]
1732    #[serde(rename = "ATMSctyCntxt")]
1733    pub atm_scty_cntxt: AtmSecurityContext3,
1734    #[validate]
1735    #[serde(rename = "ATMSctyParams")]
1736    pub atm_scty_params: SecurityParameters9,
1737    #[serde(rename = "HstChllng", skip_serializing_if = "Option::is_none")]
1738    pub hst_chllng: Option<Max140Binary>,
1739}
1740#[derive(
1741    Debug,
1742    Default,
1743    Clone,
1744    PartialEq,
1745    ::serde::Serialize,
1746    ::serde::Deserialize,
1747    ::derive_builder::Builder,
1748    ::validator::Validate,
1749)]
1750pub struct AtmKeyDownloadRequestV03 {
1751    #[validate]
1752    #[serde(rename = "Hdr")]
1753    pub hdr: Header31,
1754    #[serde(
1755        rename = "PrtctdATMKeyDwnldReq",
1756        skip_serializing_if = "Option::is_none"
1757    )]
1758    pub prtctd_atm_key_dwnld_req: Option<ContentInformationType10>,
1759    #[serde(rename = "ATMKeyDwnldReq", skip_serializing_if = "Option::is_none")]
1760    pub atm_key_dwnld_req: Option<AtmKeyDownloadRequest4>,
1761    #[serde(rename = "SctyTrlr", skip_serializing_if = "Option::is_none")]
1762    pub scty_trlr: Option<ContentInformationType13>,
1763}
1764#[derive(
1765    Debug,
1766    Default,
1767    Clone,
1768    PartialEq,
1769    ::serde::Serialize,
1770    ::serde::Deserialize,
1771    ::derive_builder::Builder,
1772    ::validator::Validate,
1773)]
1774pub struct GeographicCoordinates1 {
1775    #[validate]
1776    #[serde(rename = "Lat")]
1777    pub lat: Max16Text,
1778    #[validate]
1779    #[serde(rename = "Long")]
1780    pub long: Max16Text,
1781}
1782#[derive(
1783    Debug,
1784    Default,
1785    Clone,
1786    PartialEq,
1787    ::serde::Serialize,
1788    ::serde::Deserialize,
1789    ::derive_builder::Builder,
1790    ::validator::Validate,
1791)]
1792pub struct Max100KBinary {
1793    #[validate(length(min = 1, max = 102400,), regex = "MAX_100_K_BINARY_REGEX")]
1794    pub value: String,
1795}
1796#[derive(
1797    Debug,
1798    Default,
1799    Clone,
1800    PartialEq,
1801    ::serde::Serialize,
1802    ::serde::Deserialize,
1803    ::derive_builder::Builder,
1804    ::validator::Validate,
1805)]
1806pub struct Max3000Binary {
1807    #[validate(length(min = 1, max = 3000,), regex = "MAX_3000_BINARY_REGEX")]
1808    pub value: String,
1809}
1810#[derive(
1811    Debug,
1812    Default,
1813    Clone,
1814    PartialEq,
1815    ::serde::Serialize,
1816    ::serde::Deserialize,
1817    ::derive_builder::Builder,
1818    ::validator::Validate,
1819)]
1820pub struct AuthenticatedData4 {
1821    #[serde(rename = "Vrsn", skip_serializing_if = "Option::is_none")]
1822    pub vrsn: Option<Number>,
1823    #[validate(length(min = 1,))]
1824    #[serde(rename = "Rcpt", default)]
1825    pub rcpt: Vec<Recipient4Choice>,
1826    #[validate]
1827    #[serde(rename = "MACAlgo")]
1828    pub mac_algo: AlgorithmIdentification15,
1829    #[validate]
1830    #[serde(rename = "NcpsltdCntt")]
1831    pub ncpsltd_cntt: EncapsulatedContent3,
1832    #[validate]
1833    #[serde(rename = "MAC")]
1834    pub mac: Max140Binary,
1835}
1836#[derive(
1837    Debug,
1838    Default,
1839    Clone,
1840    PartialEq,
1841    ::serde::Serialize,
1842    ::serde::Deserialize,
1843    ::derive_builder::Builder,
1844    ::validator::Validate,
1845)]
1846pub struct ContentInformationType14 {
1847    #[serde(rename = "CnttTp")]
1848    pub cntt_tp: ContentType2Code,
1849    #[validate]
1850    #[serde(rename = "SgndData")]
1851    pub sgnd_data: SignedData4,
1852}
1853#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1854pub enum AtmCommand6Code {
1855    #[serde(rename = "ABAL")]
1856    Abal,
1857    #[serde(rename = "ASTS")]
1858    Asts,
1859    #[serde(rename = "CFGT")]
1860    Cfgt,
1861    #[serde(rename = "CCNT")]
1862    Ccnt,
1863    #[serde(rename = "DISC")]
1864    Disc,
1865    #[serde(rename = "KACT")]
1866    Kact,
1867    #[serde(rename = "KDAC")]
1868    Kdac,
1869    #[serde(rename = "KDWL")]
1870    Kdwl,
1871    #[serde(rename = "KRMV")]
1872    Krmv,
1873    #[serde(rename = "SCFU")]
1874    Scfu,
1875    #[serde(rename = "SSCU")]
1876    Sscu,
1877    #[serde(rename = "SSTU")]
1878    Sstu,
1879    #[serde(rename = "SNDM")]
1880    Sndm,
1881    #[serde(rename = "HKCG")]
1882    Hkcg,
1883    #[serde(rename = "HKRV")]
1884    Hkrv,
1885    #[serde(rename = "KCHG")]
1886    Kchg,
1887    #[default]
1888    Unknown,
1889}
1890#[derive(
1891    Debug,
1892    Default,
1893    Clone,
1894    PartialEq,
1895    ::serde::Serialize,
1896    ::serde::Deserialize,
1897    ::derive_builder::Builder,
1898    ::validator::Validate,
1899)]
1900pub struct CertificateIssuer1 {
1901    #[validate(length(min = 1,))]
1902    #[serde(rename = "RltvDstngshdNm", default)]
1903    pub rltv_dstngshd_nm: Vec<RelativeDistinguishedName1>,
1904}
1905#[derive(
1906    Debug,
1907    Default,
1908    Clone,
1909    PartialEq,
1910    ::serde::Serialize,
1911    ::serde::Deserialize,
1912    ::derive_builder::Builder,
1913    ::validator::Validate,
1914)]
1915pub struct IsoDateTime {
1916    #[serde(rename = "$text")]
1917    pub value: ::chrono::DateTime<::chrono::Utc>,
1918}
1919#[derive(
1920    Debug,
1921    Default,
1922    Clone,
1923    PartialEq,
1924    ::serde::Serialize,
1925    ::serde::Deserialize,
1926    ::derive_builder::Builder,
1927    ::validator::Validate,
1928)]
1929pub struct AlgorithmIdentification15 {
1930    #[serde(rename = "Algo")]
1931    pub algo: Algorithm12Code,
1932    #[serde(rename = "Param", skip_serializing_if = "Option::is_none")]
1933    pub param: Option<Parameter7>,
1934}
1935#[derive(
1936    Debug,
1937    Default,
1938    Clone,
1939    PartialEq,
1940    ::serde::Serialize,
1941    ::serde::Deserialize,
1942    ::derive_builder::Builder,
1943    ::validator::Validate,
1944)]
1945pub struct AtmSecurityContext3 {
1946    #[serde(rename = "CurSctySchme")]
1947    pub cur_scty_schme: AtmSecurityScheme3Code,
1948    #[serde(rename = "DvcPrprty", skip_serializing_if = "Option::is_none")]
1949    pub dvc_prprty: Option<AtmEquipment3>,
1950    #[serde(rename = "CurCfgtn", skip_serializing_if = "Option::is_none")]
1951    pub cur_cfgtn: Option<AtmSecurityConfiguration1>,
1952}
1953#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1954pub enum EncryptionFormat1Code {
1955    #[serde(rename = "TR31")]
1956    Tr31,
1957    #[serde(rename = "TR34")]
1958    Tr34,
1959    #[default]
1960    Unknown,
1961}
1962#[derive(
1963    Debug,
1964    Default,
1965    Clone,
1966    PartialEq,
1967    ::serde::Serialize,
1968    ::serde::Deserialize,
1969    ::derive_builder::Builder,
1970    ::validator::Validate,
1971)]
1972pub struct GenericIdentification77 {
1973    #[validate]
1974    #[serde(rename = "Id")]
1975    pub id: Max35Text,
1976    #[serde(rename = "Tp")]
1977    pub tp: PartyType12Code,
1978    #[serde(rename = "Issr", skip_serializing_if = "Option::is_none")]
1979    pub issr: Option<PartyType12Code>,
1980    #[serde(rename = "Ctry", skip_serializing_if = "Option::is_none")]
1981    pub ctry: Option<Min2Max3AlphaText>,
1982    #[serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none")]
1983    pub shrt_nm: Option<Max35Text>,
1984}
1985#[derive(
1986    Debug,
1987    Default,
1988    Clone,
1989    PartialEq,
1990    ::serde::Serialize,
1991    ::serde::Deserialize,
1992    ::derive_builder::Builder,
1993    ::validator::Validate,
1994)]
1995pub struct Kek4 {
1996    #[serde(rename = "Vrsn", skip_serializing_if = "Option::is_none")]
1997    pub vrsn: Option<Number>,
1998    #[validate]
1999    #[serde(rename = "KEKId")]
2000    pub kek_id: KekIdentifier2,
2001    #[validate]
2002    #[serde(rename = "KeyNcrptnAlgo")]
2003    pub key_ncrptn_algo: AlgorithmIdentification13,
2004    #[validate]
2005    #[serde(rename = "NcrptdKey")]
2006    pub ncrptd_key: Max500Binary,
2007}
2008#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2009pub enum MessageFunction11Code {
2010    #[serde(rename = "BALN")]
2011    Baln,
2012    #[serde(rename = "CMPA")]
2013    Cmpa,
2014    #[serde(rename = "CMPD")]
2015    Cmpd,
2016    #[serde(rename = "ACMD")]
2017    Acmd,
2018    #[serde(rename = "DVCC")]
2019    Dvcc,
2020    #[serde(rename = "DIAQ")]
2021    Diaq,
2022    #[serde(rename = "DIAP")]
2023    Diap,
2024    #[serde(rename = "GSTS")]
2025    Gsts,
2026    #[serde(rename = "INQQ")]
2027    Inqq,
2028    #[serde(rename = "INQP")]
2029    Inqp,
2030    #[serde(rename = "KYAQ")]
2031    Kyaq,
2032    #[serde(rename = "KYAP")]
2033    Kyap,
2034    #[serde(rename = "PINQ")]
2035    Pinq,
2036    #[serde(rename = "PINP")]
2037    Pinp,
2038    #[serde(rename = "RJAQ")]
2039    Rjaq,
2040    #[serde(rename = "RJAP")]
2041    Rjap,
2042    #[serde(rename = "WITV")]
2043    Witv,
2044    #[serde(rename = "WITK")]
2045    Witk,
2046    #[serde(rename = "WITQ")]
2047    Witq,
2048    #[serde(rename = "WITP")]
2049    Witp,
2050    #[serde(rename = "INQC")]
2051    Inqc,
2052    #[serde(rename = "H2AP")]
2053    H2Ap,
2054    #[serde(rename = "H2AQ")]
2055    H2Aq,
2056    #[serde(rename = "TMOP")]
2057    Tmop,
2058    #[serde(rename = "CSEC")]
2059    Csec,
2060    #[serde(rename = "DSEC")]
2061    Dsec,
2062    #[serde(rename = "SKSC")]
2063    Sksc,
2064    #[serde(rename = "SSTS")]
2065    Ssts,
2066    #[serde(rename = "DPSK")]
2067    Dpsk,
2068    #[serde(rename = "DPSV")]
2069    Dpsv,
2070    #[serde(rename = "DPSQ")]
2071    Dpsq,
2072    #[serde(rename = "DPSP")]
2073    Dpsp,
2074    #[serde(rename = "EXPK")]
2075    Expk,
2076    #[serde(rename = "EXPV")]
2077    Expv,
2078    #[serde(rename = "TRFQ")]
2079    Trfq,
2080    #[serde(rename = "TRFP")]
2081    Trfp,
2082    #[serde(rename = "RPTC")]
2083    Rptc,
2084    #[default]
2085    Unknown,
2086}
2087#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2088pub enum AttributeType1Code {
2089    #[serde(rename = "CNAT")]
2090    Cnat,
2091    #[serde(rename = "LATT")]
2092    Latt,
2093    #[serde(rename = "OATT")]
2094    Oatt,
2095    #[serde(rename = "OUAT")]
2096    Ouat,
2097    #[serde(rename = "CATT")]
2098    Catt,
2099    #[default]
2100    Unknown,
2101}
2102#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2103pub enum TransactionEnvironment2Code {
2104    #[serde(rename = "PRIV")]
2105    Priv,
2106    #[serde(rename = "PUBL")]
2107    Publ,
2108    #[default]
2109    Unknown,
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 AtmCommandIdentification1 {
2122    #[serde(rename = "Orgn", skip_serializing_if = "Option::is_none")]
2123    pub orgn: Option<Max35Text>,
2124    #[serde(rename = "Ref", skip_serializing_if = "Option::is_none")]
2125    pub r#ref: Option<Max35Text>,
2126    #[serde(rename = "Prcr", skip_serializing_if = "Option::is_none")]
2127    pub prcr: Option<Max140Text>,
2128}
2129#[derive(
2130    Debug,
2131    Default,
2132    Clone,
2133    PartialEq,
2134    ::serde::Serialize,
2135    ::serde::Deserialize,
2136    ::derive_builder::Builder,
2137    ::validator::Validate,
2138)]
2139pub struct UtmCoordinates1 {
2140    #[validate]
2141    #[serde(rename = "UTMZone")]
2142    pub utm_zone: Max16Text,
2143    #[validate]
2144    #[serde(rename = "UTMEstwrd")]
2145    pub utm_estwrd: Number,
2146    #[validate]
2147    #[serde(rename = "UTMNrthwrd")]
2148    pub utm_nrthwrd: Number,
2149}
2150#[derive(
2151    Debug,
2152    Default,
2153    Clone,
2154    PartialEq,
2155    ::serde::Serialize,
2156    ::serde::Deserialize,
2157    ::derive_builder::Builder,
2158    ::validator::Validate,
2159)]
2160pub struct Parameter5 {
2161    #[serde(rename = "DgstAlgo", skip_serializing_if = "Option::is_none")]
2162    pub dgst_algo: Option<Algorithm11Code>,
2163}
iso_20022_caam/caam_003_001_03.rs

iso_20022_caam/
caam_003_001_03.rs
