iso_20022_caad/
caad_005_001_03.rs

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

iso_20022_caad/
caad_005_001_03.rs
