iso_20022_caad/
caad_009_001_01.rs

1// Copyright 2023 Emergent Financial, LLC - All Rights Reserved
2//
3//
4// This software is licensed under the Emergent Financial Limited Public License Version 1.0
5// (EF-LPLv1). You may use, copy, modify, and distribute this software under the terms and
6// conditions of the EF-LPL. For more information, please refer to the full text of the license
7// at https://github.com/emergentfinancial/ef-lpl.
8//
9//
10// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS
11// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
12// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
13// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
14// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
15// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
16//
17// See ISO-20022 Intellectual Property Rights Policy at
18// <https://www.iso20022.org/intellectual-property-rights>
19// for more information.
20
21use validator::Validate;
22
23::lazy_static::lazy_static! {
24    static ref MAX_12_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,12}"#).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 EXACT_6_ALPHA_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[a-zA-Z0-9\s]{6}"#).unwrap();
33}
34
35::lazy_static::lazy_static! {
36    static ref MAX_10_K_HEX_BINARY_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"([0-9A-F][0-9A-F]){1,10000}  "#).unwrap();
37}
38
39::lazy_static::lazy_static! {
40    static ref MAX_19_HEX_BINARY_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"([0-9A-F][0-9A-F]){1,19}"#).unwrap();
41}
42
43::lazy_static::lazy_static! {
44    static ref ISO_2_A_LANGUAGE_CODE_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[a-z]{2,2}"#).unwrap();
45}
46
47::lazy_static::lazy_static! {
48    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();
49}
50
51::lazy_static::lazy_static! {
52    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();
53}
54
55::lazy_static::lazy_static! {
56    static ref EXACT_3_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{3}"#).unwrap();
57}
58
59::lazy_static::lazy_static! {
60    static ref ISO_18245_MERCHANT_CATEGORY_CODE_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{4,4}"#).unwrap();
61}
62
63::lazy_static::lazy_static! {
64    static ref EXACT_2_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{2}"#).unwrap();
65}
66
67::lazy_static::lazy_static! {
68    static ref GEOGRAPHIC_POINT_IN_DECIMAL_DEGREES_REGEX: ::regex::Regex = ::regex::Regex::new(r#"(\+|-)?[\d]{1,3}(\.[\d]{1,8})?/(\+|-)?[\d]{1,3}(\.[\d]{1,8})?"#).unwrap();
69}
70
71::lazy_static::lazy_static! {
72    static ref MAX_35_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,35}"#).unwrap();
73}
74
75::lazy_static::lazy_static! {
76    static ref EXACT_1_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]"#).unwrap();
77}
78
79::lazy_static::lazy_static! {
80    static ref EXTERNAL_ENCRYPTED_ELEMENT_IDENTIFICATION_1_CODE_REGEX: ::regex::Regex = ::regex::Regex::new(r#"([0-9A-F][0-9A-F]){1,3}"#).unwrap();
81}
82
83::lazy_static::lazy_static! {
84    static ref MAX_4_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,4}"#).unwrap();
85}
86
87::lazy_static::lazy_static! {
88    static ref MAX_23_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,23}"#).unwrap();
89}
90
91::lazy_static::lazy_static! {
92    static ref MIN_2_MAX_3_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{2,3}"#).unwrap();
93}
94
95::lazy_static::lazy_static! {
96    static ref MAX_16_HEX_BINARY_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"([0-9A-F][0-9A-F]){1,16}"#).unwrap();
97}
98
99::lazy_static::lazy_static! {
100    static ref ISO_8583_TRANSACTION_TYPE_CODE_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9A-Z]{2,2}"#).unwrap();
101}
102
103::lazy_static::lazy_static! {
104    static ref ISO_8583_AMOUNT_TYPE_CODE_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9A-Z]{2,2}"#).unwrap();
105}
106
107::lazy_static::lazy_static! {
108    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();
109}
110
111::lazy_static::lazy_static! {
112    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();
113}
114
115::lazy_static::lazy_static! {
116    static ref ISO_YEAR_MONTH_REGEX: ::regex::Regex = ::regex::Regex::new(r#"^-?\d{4}-(0[1-9]|1[0-2])([+-]\d{2}:\d{2}|Z)?$"#).unwrap();
117}
118
119::lazy_static::lazy_static! {
120    static ref MAX_15_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,15}"#).unwrap();
121}
122
123::lazy_static::lazy_static! {
124    static ref PHONE_NUMBER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"\+[0-9]{1,3}-[0-9()+\-]{1,30}"#).unwrap();
125}
126
127::lazy_static::lazy_static! {
128    static ref MAX_32_HEX_BINARY_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"([0-9A-F][0-9A-F]){1,32}"#).unwrap();
129}
130
131::lazy_static::lazy_static! {
132    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();
133}
134
135::lazy_static::lazy_static! {
136    static ref ISO_3_NUMERIC_CURRENCY_CODE_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{3,3}"#).unwrap();
137}
138
139::lazy_static::lazy_static! {
140    static ref MAX_11_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,11}"#).unwrap();
141}
142
143::lazy_static::lazy_static! {
144    static ref ISO_MAX_3_A_LANGUAGE_CODE_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[a-z]{2,3}"#).unwrap();
145}
146
147::lazy_static::lazy_static! {
148    static ref MAX_8_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,8}"#).unwrap();
149}
150
151::lazy_static::lazy_static! {
152    static ref ISO_8583_MESSAGE_REASON_CODE_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{4,4}"#).unwrap();
153}
154
155::lazy_static::lazy_static! {
156    static ref MAX_10_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,10}"#).unwrap();
157}
158
159::lazy_static::lazy_static! {
160    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();
161}
162
163::lazy_static::lazy_static! {
164    static ref MAX_5_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,5}"#).unwrap();
165}
166
167::lazy_static::lazy_static! {
168    static ref MAX_9999_HEX_BINARY_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"([0-9A-F][0-9A-F]){1,9999}"#).unwrap();
169}
170
171::lazy_static::lazy_static! {
172    static ref MAX_6_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,6}"#).unwrap();
173}
174
175::lazy_static::lazy_static! {
176    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();
177}
178
179::lazy_static::lazy_static! {
180    static ref ISO_8583_RESPONSE_CODE_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9A-Z]{2,2}"#).unwrap();
181}
182
183::lazy_static::lazy_static! {
184    static ref ISO_COUNTRY_SUB_DIVISION_CODE_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Z]{2,3}"#).unwrap();
185}
186
187::lazy_static::lazy_static! {
188    static ref MAX_3_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,3}"#).unwrap();
189}
190
191::lazy_static::lazy_static! {
192    static ref MAX_8_HEX_BINARY_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"([0-9A-F][0-9A-F]){1,8}"#).unwrap();
193}
194
195::lazy_static::lazy_static! {
196    static ref MAX_2_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,2}"#).unwrap();
197}
198
199::lazy_static::lazy_static! {
200    static ref ISO_8583_ACCOUNT_TYPE_CODE_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9A-Z]{2,2}"#).unwrap();
201}
202
203::lazy_static::lazy_static! {
204    static ref EXACT_1_HEX_BINARY_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"([0-9A-F][0-9A-F]){1}"#).unwrap();
205}
206
207::lazy_static::lazy_static! {
208    static ref MAX_19_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,19}"#).unwrap();
209}
210
211::lazy_static::lazy_static! {
212    static ref ISO_MAX_3_A_COUNTRY_CODE_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Z]{2,3}"#).unwrap();
213}
214
215/// Returns the namespace of the schema
216pub fn namespace() -> String {
217    "urn:iso:std:iso:20022:tech:xsd:caad.009.001.01".to_string()
218}
219
220#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
221pub enum PartyType26Code {
222    #[serde(rename = "ACCP")]
223    Accp,
224    #[serde(rename = "ACQR")]
225    Acqr,
226    #[serde(rename = "ICCA")]
227    Icca,
228    #[serde(rename = "CISS")]
229    Ciss,
230    #[serde(rename = "DLIS")]
231    Dlis,
232    #[serde(rename = "AGNT")]
233    Agnt,
234    #[serde(rename = "OTHN")]
235    Othn,
236    #[serde(rename = "OTHP")]
237    Othp,
238    #[default]
239    Unknown,
240}
241#[derive(
242    Debug,
243    Default,
244    Clone,
245    PartialEq,
246    ::serde::Serialize,
247    ::serde::Deserialize,
248    ::derive_builder::Builder,
249    ::validator::Validate,
250)]
251pub struct KeyTransport6 {
252    #[serde(rename = "Vrsn", skip_serializing_if = "Option::is_none")]
253    pub vrsn: Option<Number>,
254    #[serde(rename = "RcptId")]
255    pub rcpt_id: Recipient5Choice,
256    #[validate]
257    #[serde(rename = "KeyNcrptnAlgo")]
258    pub key_ncrptn_algo: AlgorithmIdentification27,
259    #[validate]
260    #[serde(rename = "NcrptdKey")]
261    pub ncrptd_key: Max5000Binary,
262}
263#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
264pub enum DeviceOperatingSystemType1Code {
265    #[serde(rename = "DROI")]
266    Droi,
267    #[serde(rename = "BLCK")]
268    Blck,
269    #[serde(rename = "IOSS")]
270    Ioss,
271    #[serde(rename = "OTHN")]
272    Othn,
273    #[serde(rename = "OTHP")]
274    Othp,
275    #[serde(rename = "TIZN")]
276    Tizn,
277    #[serde(rename = "WIND")]
278    Wind,
279    #[default]
280    Unknown,
281}
282#[derive(
283    Debug,
284    Default,
285    Clone,
286    PartialEq,
287    ::serde::Serialize,
288    ::serde::Deserialize,
289    ::derive_builder::Builder,
290    ::validator::Validate,
291)]
292pub struct LocalData3 {
293    #[serde(rename = "Lang")]
294    pub lang: IsoMax3ALanguageCode,
295    #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
296    pub nm: Option<CardholderName2>,
297    #[serde(rename = "Adr", skip_serializing_if = "Option::is_none")]
298    pub adr: Option<Address3>,
299    #[validate(length(min = 0,))]
300    #[serde(rename = "AddtlData", default)]
301    pub addtl_data: Vec<AdditionalData1>,
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 LocalData9 {
314    #[serde(rename = "Lang")]
315    pub lang: IsoMax3ALanguageCode,
316    #[validate]
317    #[serde(rename = "TxtMsg")]
318    pub txt_msg: Max40KText,
319}
320#[derive(
321    Debug,
322    Default,
323    Clone,
324    PartialEq,
325    ::serde::Serialize,
326    ::serde::Deserialize,
327    ::derive_builder::Builder,
328    ::validator::Validate,
329)]
330pub struct Action13 {
331    #[serde(rename = "Dstn", skip_serializing_if = "Option::is_none")]
332    pub dstn: Option<PartyType20Code>,
333    #[serde(rename = "ActnTp", skip_serializing_if = "Option::is_none")]
334    pub actn_tp: Option<ActionType11Code>,
335    #[serde(rename = "OthrActnTp", skip_serializing_if = "Option::is_none")]
336    pub othr_actn_tp: Option<Max35Text>,
337    #[serde(rename = "Ctct", skip_serializing_if = "Option::is_none")]
338    pub ctct: Option<Contact6>,
339    #[validate(length(min = 0,))]
340    #[serde(rename = "AddtlData", default)]
341    pub addtl_data: Vec<AdditionalData1>,
342}
343#[derive(
344    Debug,
345    Default,
346    Clone,
347    PartialEq,
348    ::serde::Serialize,
349    ::serde::Deserialize,
350    ::derive_builder::Builder,
351    ::validator::Validate,
352)]
353pub struct VehicleRentalService2 {
354    #[serde(rename = "VhclRntlCpny", skip_serializing_if = "Option::is_none")]
355    pub vhcl_rntl_cpny: Option<VehicleRentalCompany2>,
356    #[serde(rename = "Cstmr", skip_serializing_if = "Option::is_none")]
357    pub cstmr: Option<VehicleRentalCustomer2>,
358    #[serde(rename = "SummryCmmdtyId", skip_serializing_if = "Option::is_none")]
359    pub summry_cmmdty_id: Option<Max35Text>,
360    #[serde(rename = "RntlAgrmt", skip_serializing_if = "Option::is_none")]
361    pub rntl_agrmt: Option<VehicleRentalAgreement2>,
362    #[serde(rename = "RntlInvc", skip_serializing_if = "Option::is_none")]
363    pub rntl_invc: Option<VehicleRentalInvoice2>,
364    #[serde(rename = "AddtlData", skip_serializing_if = "Option::is_none")]
365    pub addtl_data: Option<Max350Text>,
366}
367#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
368pub enum UnitOfMeasure10Code {
369    #[serde(rename = "KMET")]
370    Kmet,
371    #[serde(rename = "MILE")]
372    Mile,
373    #[default]
374    Unknown,
375}
376#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
377pub enum ContentType3Code {
378    #[serde(rename = "EVLP")]
379    Evlp,
380    #[serde(rename = "IFSE")]
381    Ifse,
382    #[default]
383    Unknown,
384}
385#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
386pub enum ActionType8Code {
387    #[serde(rename = "APPV")]
388    Appv,
389    #[serde(rename = "BLCK")]
390    Blck,
391    #[serde(rename = "CPTR")]
392    Cptr,
393    #[serde(rename = "DCLN")]
394    Dcln,
395    #[serde(rename = "RQID")]
396    Rqid,
397    #[serde(rename = "NDCL")]
398    Ndcl,
399    #[serde(rename = "RFRL")]
400    Rfrl,
401    #[serde(rename = "OTHN")]
402    Othn,
403    #[serde(rename = "OTHP")]
404    Othp,
405    #[serde(rename = "STUA")]
406    Stua,
407    #[default]
408    Unknown,
409}
410#[derive(
411    Debug,
412    Default,
413    Clone,
414    PartialEq,
415    ::serde::Serialize,
416    ::serde::Deserialize,
417    ::derive_builder::Builder,
418    ::validator::Validate,
419)]
420pub struct CommunicationCharacteristics3 {
421    #[serde(rename = "ComTp")]
422    pub com_tp: PoiCommunicationType2Code,
423    #[validate(length(min = 1,))]
424    #[serde(rename = "RmotPty", default)]
425    pub rmot_pty: Vec<PartyType7Code>,
426    #[validate]
427    #[serde(rename = "Actv")]
428    pub actv: TrueFalseIndicator,
429}
430#[derive(
431    Debug,
432    Default,
433    Clone,
434    PartialEq,
435    ::serde::Serialize,
436    ::serde::Deserialize,
437    ::derive_builder::Builder,
438    ::validator::Validate,
439)]
440pub struct CardData7 {
441    #[serde(rename = "PAN", skip_serializing_if = "Option::is_none")]
442    pub pan: Option<Max19NumericText>,
443    #[serde(rename = "PrtctdPANInd", skip_serializing_if = "Option::is_none")]
444    pub prtctd_pan_ind: Option<TrueFalseIndicator>,
445    #[serde(rename = "CardSeqNb", skip_serializing_if = "Option::is_none")]
446    pub card_seq_nb: Option<Min2Max3NumericText>,
447    #[serde(rename = "FctvDt", skip_serializing_if = "Option::is_none")]
448    pub fctv_dt: Option<IsoYearMonth>,
449    #[serde(rename = "XpryDt", skip_serializing_if = "Option::is_none")]
450    pub xpry_dt: Option<IsoYearMonth>,
451    #[serde(rename = "PmtAcctRef", skip_serializing_if = "Option::is_none")]
452    pub pmt_acct_ref: Option<Max35Text>,
453    #[serde(rename = "PANAcctRg", skip_serializing_if = "Option::is_none")]
454    pub pan_acct_rg: Option<Max19NumericText>,
455    #[serde(rename = "CardCtryCd", skip_serializing_if = "Option::is_none")]
456    pub card_ctry_cd: Option<Iso3NumericCountryCode>,
457    #[serde(rename = "CardPdctTp", skip_serializing_if = "Option::is_none")]
458    pub card_pdct_tp: Option<Max35Text>,
459    #[serde(rename = "CardPdctSubTp", skip_serializing_if = "Option::is_none")]
460    pub card_pdct_sub_tp: Option<Max35Text>,
461    #[serde(rename = "CardPrtflIdr", skip_serializing_if = "Option::is_none")]
462    pub card_prtfl_idr: Option<Max35Text>,
463    #[validate(length(min = 0,))]
464    #[serde(rename = "AddtlCardData", default)]
465    pub addtl_card_data: Vec<AdditionalData1>,
466}
467#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
468pub enum AdditionalServiceType2Code {
469    #[serde(rename = "CACT")]
470    Cact,
471    #[serde(rename = "CSHB")]
472    Cshb,
473    #[serde(rename = "DCCV")]
474    Dccv,
475    #[serde(rename = "INTP")]
476    Intp,
477    #[serde(rename = "INTT")]
478    Intt,
479    #[serde(rename = "LOYT")]
480    Loyt,
481    #[serde(rename = "OTHN")]
482    Othn,
483    #[serde(rename = "OTHP")]
484    Othp,
485    #[serde(rename = "PRST")]
486    Prst,
487    #[serde(rename = "BALC")]
488    Balc,
489    #[default]
490    Unknown,
491}
492#[derive(
493    Debug,
494    Default,
495    Clone,
496    PartialEq,
497    ::serde::Serialize,
498    ::serde::Deserialize,
499    ::derive_builder::Builder,
500    ::validator::Validate,
501)]
502pub struct Max1Number {
503    #[serde(rename = "$text")]
504    pub value: f64,
505}
506#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
507pub enum CardDataWriting1Code {
508    #[serde(rename = "ICPY")]
509    Icpy,
510    #[serde(rename = "MGST")]
511    Mgst,
512    #[serde(rename = "ICCY")]
513    Iccy,
514    #[serde(rename = "MSIP")]
515    Msip,
516    #[serde(rename = "OTHN")]
517    Othn,
518    #[serde(rename = "UNSP")]
519    Unsp,
520    #[serde(rename = "OTHP")]
521    Othp,
522    #[default]
523    Unknown,
524}
525#[derive(
526    Debug,
527    Default,
528    Clone,
529    PartialEq,
530    ::serde::Serialize,
531    ::serde::Deserialize,
532    ::derive_builder::Builder,
533    ::validator::Validate,
534)]
535pub struct KekIdentifier6 {
536    #[validate]
537    #[serde(rename = "KeyId")]
538    pub key_id: Max140Text,
539    #[serde(rename = "KeyVrsn", skip_serializing_if = "Option::is_none")]
540    pub key_vrsn: Option<Max140Text>,
541    #[serde(rename = "SeqNb", skip_serializing_if = "Option::is_none")]
542    pub seq_nb: Option<Number>,
543    #[serde(rename = "DerivtnId", skip_serializing_if = "Option::is_none")]
544    pub derivtn_id: Option<Min5Max16Binary>,
545}
546#[derive(
547    Debug,
548    Default,
549    Clone,
550    PartialEq,
551    ::serde::Serialize,
552    ::serde::Deserialize,
553    ::derive_builder::Builder,
554    ::validator::Validate,
555)]
556pub struct Max12NumericText {
557    #[validate(regex = "MAX_12_NUMERIC_TEXT_REGEX")]
558    #[serde(rename = "$text")]
559    pub value: String,
560}
561#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
562pub enum ActionType11Code {
563    #[serde(rename = "CNTI")]
564    Cnti,
565    #[serde(rename = "CNIS")]
566    Cnis,
567    #[serde(rename = "CNTA")]
568    Cnta,
569    #[serde(rename = "CNAS")]
570    Cnas,
571    #[serde(rename = "CPTR")]
572    Cptr,
573    #[serde(rename = "CHDV")]
574    Chdv,
575    #[serde(rename = "VIPM")]
576    Vipm,
577    #[serde(rename = "TRCK")]
578    Trck,
579    #[serde(rename = "TRXR")]
580    Trxr,
581    #[serde(rename = "OTHN")]
582    Othn,
583    #[serde(rename = "OTHP")]
584    Othp,
585    #[serde(rename = "SIGN")]
586    Sign,
587    #[default]
588    Unknown,
589}
590#[derive(
591    Debug,
592    Default,
593    Clone,
594    PartialEq,
595    ::serde::Serialize,
596    ::serde::Deserialize,
597    ::derive_builder::Builder,
598    ::validator::Validate,
599)]
600pub struct PassengerTransportSummary2 {
601    #[serde(rename = "DocNb", skip_serializing_if = "Option::is_none")]
602    pub doc_nb: Option<Max35Text>,
603    #[serde(rename = "Rsvatn", skip_serializing_if = "Option::is_none")]
604    pub rsvatn: Option<ReservationDetails3>,
605    #[serde(rename = "TrvlAuthstnCd", skip_serializing_if = "Option::is_none")]
606    pub trvl_authstn_cd: Option<Max70Text>,
607    #[serde(rename = "TcktIssr", skip_serializing_if = "Option::is_none")]
608    pub tckt_issr: Option<Max35Text>,
609    #[serde(rename = "OpnTcktInd", skip_serializing_if = "Option::is_none")]
610    pub opn_tckt_ind: Option<TrueFalseIndicator>,
611    #[validate(length(min = 0,))]
612    #[serde(rename = "CstmrRef", default)]
613    pub cstmr_ref: Vec<CustomerReference1>,
614    #[validate(length(min = 0,))]
615    #[serde(rename = "Pssngr", default)]
616    pub pssngr: Vec<Customer8>,
617    #[serde(rename = "Dprture", skip_serializing_if = "Option::is_none")]
618    pub dprture: Option<DepartureOrArrival1>,
619    #[serde(rename = "Drtn", skip_serializing_if = "Option::is_none")]
620    pub drtn: Option<Max4NumericText>,
621    #[serde(rename = "InsrncInd", skip_serializing_if = "Option::is_none")]
622    pub insrnc_ind: Option<TrueFalseIndicator>,
623    #[validate(length(min = 0,))]
624    #[serde(rename = "TtlAmt", default)]
625    pub ttl_amt: Vec<AmountDetails2>,
626    #[serde(rename = "SummryCmmdtyId", skip_serializing_if = "Option::is_none")]
627    pub summry_cmmdty_id: Option<Max35Text>,
628    #[serde(rename = "LltyPrgrmm", skip_serializing_if = "Option::is_none")]
629    pub llty_prgrmm: Option<LoyaltyProgramme2>,
630    #[serde(rename = "AddtlData", skip_serializing_if = "Option::is_none")]
631    pub addtl_data: Option<Max350Text>,
632}
633#[derive(
634    Debug,
635    Default,
636    Clone,
637    PartialEq,
638    ::serde::Serialize,
639    ::serde::Deserialize,
640    ::derive_builder::Builder,
641    ::validator::Validate,
642)]
643pub struct GracePeriod2 {
644    #[serde(rename = "Tm", skip_serializing_if = "Option::is_none")]
645    pub tm: Option<Max3NumericText>,
646    #[serde(rename = "UnitTp", skip_serializing_if = "Option::is_none")]
647    pub unit_tp: Option<GracePeriodUnitType1Code>,
648    #[serde(rename = "OthrUnitTp", skip_serializing_if = "Option::is_none")]
649    pub othr_unit_tp: Option<Max35Text>,
650    #[serde(
651        rename = "CstmrSelctdGracePrd",
652        skip_serializing_if = "Option::is_none"
653    )]
654    pub cstmr_selctd_grace_prd: Option<bool>,
655}
656#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
657pub enum PoiComponentType5Code {
658    #[serde(rename = "AQPP")]
659    Aqpp,
660    #[serde(rename = "APPR")]
661    Appr,
662    #[serde(rename = "TLPR")]
663    Tlpr,
664    #[serde(rename = "SCPR")]
665    Scpr,
666    #[serde(rename = "SERV")]
667    Serv,
668    #[serde(rename = "TERM")]
669    Term,
670    #[serde(rename = "DVCE")]
671    Dvce,
672    #[serde(rename = "SECM")]
673    Secm,
674    #[serde(rename = "APLI")]
675    Apli,
676    #[serde(rename = "EMVK")]
677    Emvk,
678    #[serde(rename = "EMVO")]
679    Emvo,
680    #[serde(rename = "MDWR")]
681    Mdwr,
682    #[serde(rename = "DRVR")]
683    Drvr,
684    #[serde(rename = "OPST")]
685    Opst,
686    #[serde(rename = "MRPR")]
687    Mrpr,
688    #[serde(rename = "CRTF")]
689    Crtf,
690    #[serde(rename = "TMSP")]
691    Tmsp,
692    #[serde(rename = "SACP")]
693    Sacp,
694    #[serde(rename = "SAPR")]
695    Sapr,
696    #[default]
697    Unknown,
698}
699#[derive(
700    Debug,
701    Default,
702    Clone,
703    PartialEq,
704    ::serde::Serialize,
705    ::serde::Deserialize,
706    ::derive_builder::Builder,
707    ::validator::Validate,
708)]
709pub struct PartyIdentification255 {
710    #[validate]
711    #[serde(rename = "Id")]
712    pub id: Max35Text,
713    #[serde(rename = "Assgnr", skip_serializing_if = "Option::is_none")]
714    pub assgnr: Option<Max35Text>,
715    #[serde(rename = "Ctry", skip_serializing_if = "Option::is_none")]
716    pub ctry: Option<Iso3NumericCountryCode>,
717    #[serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none")]
718    pub shrt_nm: Option<Max35Text>,
719    #[serde(rename = "LglCorpNm", skip_serializing_if = "Option::is_none")]
720    pub lgl_corp_nm: Option<Max99Text>,
721    #[serde(rename = "AddtlId", skip_serializing_if = "Option::is_none")]
722    pub addtl_id: Option<AdditionalData1>,
723    #[validate]
724    #[serde(rename = "NmAndLctn")]
725    pub nm_and_lctn: Max99Text,
726    #[serde(rename = "Adr", skip_serializing_if = "Option::is_none")]
727    pub adr: Option<Address2>,
728    #[serde(rename = "AddtlAdrInf", skip_serializing_if = "Option::is_none")]
729    pub addtl_adr_inf: Option<Max256Text>,
730    #[serde(rename = "GeogcLctn", skip_serializing_if = "Option::is_none")]
731    pub geogc_lctn: Option<GeographicPointInDecimalDegrees>,
732    #[serde(rename = "Email", skip_serializing_if = "Option::is_none")]
733    pub email: Option<Max256Text>,
734    #[serde(rename = "URLAdr", skip_serializing_if = "Option::is_none")]
735    pub url_adr: Option<Max256Text>,
736    #[serde(rename = "PhneNb", skip_serializing_if = "Option::is_none")]
737    pub phne_nb: Option<Max35Text>,
738    #[serde(rename = "CstmrSvc", skip_serializing_if = "Option::is_none")]
739    pub cstmr_svc: Option<Max35Text>,
740    #[serde(rename = "AddtlCtctInf", skip_serializing_if = "Option::is_none")]
741    pub addtl_ctct_inf: Option<Max256Text>,
742    #[serde(rename = "TaxRegnId", skip_serializing_if = "Option::is_none")]
743    pub tax_regn_id: Option<Max35Text>,
744    #[validate(length(min = 0,))]
745    #[serde(rename = "AddtlData", default)]
746    pub addtl_data: Vec<AdditionalData1>,
747    #[serde(rename = "LclData", skip_serializing_if = "Option::is_none")]
748    pub lcl_data: Option<LocalData4>,
749    #[validate(length(min = 0,))]
750    #[serde(rename = "SpnsrdMrchnt", default)]
751    pub spnsrd_mrchnt: Vec<SponsoredMerchant2>,
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 TerminalIdentification3 {
764    #[validate]
765    #[serde(rename = "Id")]
766    pub id: Max16Text,
767    #[serde(rename = "Assgnr", skip_serializing_if = "Option::is_none")]
768    pub assgnr: Option<Max35Text>,
769    #[serde(rename = "Ctry", skip_serializing_if = "Option::is_none")]
770    pub ctry: Option<IsoMax3ACountryCode>,
771    #[serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none")]
772    pub shrt_nm: Option<Max35Text>,
773}
774#[derive(
775    Debug,
776    Default,
777    Clone,
778    PartialEq,
779    ::serde::Serialize,
780    ::serde::Deserialize,
781    ::derive_builder::Builder,
782    ::validator::Validate,
783)]
784pub struct ServiceStartEnd2 {
785    #[serde(rename = "Lctn", skip_serializing_if = "Option::is_none")]
786    pub lctn: Option<Max35Text>,
787    #[serde(rename = "LctnCd", skip_serializing_if = "Option::is_none")]
788    pub lctn_cd: Option<Max35Text>,
789    #[serde(rename = "Adr", skip_serializing_if = "Option::is_none")]
790    pub adr: Option<Address2>,
791    #[serde(rename = "Ctct", skip_serializing_if = "Option::is_none")]
792    pub ctct: Option<Contact2>,
793    #[serde(rename = "DtAndTm", skip_serializing_if = "Option::is_none")]
794    pub dt_and_tm: Option<IsoDateTime>,
795    #[serde(rename = "TmSgmt", skip_serializing_if = "Option::is_none")]
796    pub tm_sgmt: Option<TimeSegment1Code>,
797    #[serde(rename = "JrnyInf", skip_serializing_if = "Option::is_none")]
798    pub jrny_inf: Option<JourneyInformation1>,
799}
800#[derive(
801    Debug,
802    Default,
803    Clone,
804    PartialEq,
805    ::serde::Serialize,
806    ::serde::Deserialize,
807    ::derive_builder::Builder,
808    ::validator::Validate,
809)]
810pub struct DeliveryInformation4 {
811    #[serde(rename = "DlvryNoteNb", skip_serializing_if = "Option::is_none")]
812    pub dlvry_note_nb: Option<Max35Text>,
813    #[serde(rename = "Adr", skip_serializing_if = "Option::is_none")]
814    pub adr: Option<Address2>,
815    #[serde(rename = "Ctct", skip_serializing_if = "Option::is_none")]
816    pub ctct: Option<Contact6>,
817    #[serde(rename = "Instrs", skip_serializing_if = "Option::is_none")]
818    pub instrs: Option<Max350Text>,
819    #[serde(rename = "Dt", skip_serializing_if = "Option::is_none")]
820    pub dt: Option<IsoDate>,
821    #[serde(rename = "Tm", skip_serializing_if = "Option::is_none")]
822    pub tm: Option<IsoTime>,
823}
824#[derive(
825    Debug,
826    Default,
827    Clone,
828    PartialEq,
829    ::serde::Serialize,
830    ::serde::Deserialize,
831    ::derive_builder::Builder,
832    ::validator::Validate,
833)]
834pub struct PartyIdentification261 {
835    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
836    pub cd: Option<Max35Text>,
837    #[serde(rename = "Assgnr", skip_serializing_if = "Option::is_none")]
838    pub assgnr: Option<Max35Text>,
839    #[serde(rename = "IATACd", skip_serializing_if = "Option::is_none")]
840    pub iata_cd: Option<Max35Text>,
841    #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
842    pub nm: Option<Max70Text>,
843    #[serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none")]
844    pub shrt_nm: Option<Max35Text>,
845    #[serde(rename = "Adr", skip_serializing_if = "Option::is_none")]
846    pub adr: Option<Address2>,
847    #[serde(rename = "Ctct", skip_serializing_if = "Option::is_none")]
848    pub ctct: Option<Contact6>,
849}
850#[derive(
851    Debug,
852    Default,
853    Clone,
854    PartialEq,
855    ::serde::Serialize,
856    ::serde::Deserialize,
857    ::derive_builder::Builder,
858    ::validator::Validate,
859)]
860pub struct CardData6 {
861    #[serde(rename = "PAN", skip_serializing_if = "Option::is_none")]
862    pub pan: Option<Max19NumericText>,
863    #[serde(rename = "PrtctdPANInd", skip_serializing_if = "Option::is_none")]
864    pub prtctd_pan_ind: Option<TrueFalseIndicator>,
865    #[serde(rename = "CardSeqNb", skip_serializing_if = "Option::is_none")]
866    pub card_seq_nb: Option<Min2Max3NumericText>,
867    #[serde(rename = "FctvDt", skip_serializing_if = "Option::is_none")]
868    pub fctv_dt: Option<IsoYearMonth>,
869    #[serde(rename = "XpryDt", skip_serializing_if = "Option::is_none")]
870    pub xpry_dt: Option<IsoYearMonth>,
871    #[serde(rename = "SvcCd", skip_serializing_if = "Option::is_none")]
872    pub svc_cd: Option<Exact3NumericText>,
873    #[serde(rename = "Trck1", skip_serializing_if = "Option::is_none")]
874    pub trck_1: Option<Max76Text>,
875    #[serde(rename = "Trck2", skip_serializing_if = "Option::is_none")]
876    pub trck_2: Option<Track2Data1Choice>,
877    #[serde(rename = "Trck3", skip_serializing_if = "Option::is_none")]
878    pub trck_3: Option<Max104Text>,
879    #[serde(rename = "PmtAcctRef", skip_serializing_if = "Option::is_none")]
880    pub pmt_acct_ref: Option<Max35Text>,
881    #[serde(rename = "PANAcctRg", skip_serializing_if = "Option::is_none")]
882    pub pan_acct_rg: Option<Max19NumericText>,
883    #[serde(rename = "CardCtryCd", skip_serializing_if = "Option::is_none")]
884    pub card_ctry_cd: Option<Iso3NumericCountryCode>,
885    #[serde(rename = "CardPdctTp", skip_serializing_if = "Option::is_none")]
886    pub card_pdct_tp: Option<Max35Text>,
887    #[serde(rename = "CardPdctSubTp", skip_serializing_if = "Option::is_none")]
888    pub card_pdct_sub_tp: Option<Max35Text>,
889    #[serde(rename = "CardPrtflIdr", skip_serializing_if = "Option::is_none")]
890    pub card_prtfl_idr: Option<Max35Text>,
891    #[validate(length(min = 0,))]
892    #[serde(rename = "AddtlCardData", default)]
893    pub addtl_card_data: Vec<AdditionalData1>,
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 InvoiceLineItem2 {
906    #[serde(rename = "Dt", skip_serializing_if = "Option::is_none")]
907    pub dt: Option<IsoDate>,
908    #[serde(rename = "OrdrDt", skip_serializing_if = "Option::is_none")]
909    pub ordr_dt: Option<IsoDate>,
910    #[serde(rename = "CtrctNb", skip_serializing_if = "Option::is_none")]
911    pub ctrct_nb: Option<Max70Text>,
912    #[serde(rename = "ShppgDt", skip_serializing_if = "Option::is_none")]
913    pub shppg_dt: Option<IsoDate>,
914    #[serde(rename = "RbllgInd", skip_serializing_if = "Option::is_none")]
915    pub rbllg_ind: Option<TrueFalseIndicator>,
916    #[serde(rename = "MdclSvcsInd", skip_serializing_if = "Option::is_none")]
917    pub mdcl_svcs_ind: Option<TrueFalseIndicator>,
918    #[serde(rename = "ShipToIndstryCd", skip_serializing_if = "Option::is_none")]
919    pub ship_to_indstry_cd: Option<Max50Text>,
920    #[serde(rename = "PdctCd", skip_serializing_if = "Option::is_none")]
921    pub pdct_cd: Option<Max70Text>,
922    #[serde(rename = "PdctQlfr", skip_serializing_if = "Option::is_none")]
923    pub pdct_qlfr: Option<Max35Text>,
924    #[serde(rename = "Desc", skip_serializing_if = "Option::is_none")]
925    pub desc: Option<Max256Text>,
926    #[serde(rename = "TpOfSpply", skip_serializing_if = "Option::is_none")]
927    pub tp_of_spply: Option<Max10Text>,
928    #[serde(rename = "UnitOfMeasr", skip_serializing_if = "Option::is_none")]
929    pub unit_of_measr: Option<UnitOfMeasure1Code>,
930    #[serde(rename = "OthrUnitOfMeasr", skip_serializing_if = "Option::is_none")]
931    pub othr_unit_of_measr: Option<Max35Text>,
932    #[serde(rename = "UnitPric", skip_serializing_if = "Option::is_none")]
933    pub unit_pric: Option<ImpliedCurrencyAndAmount>,
934    #[serde(rename = "PdctQty", skip_serializing_if = "Option::is_none")]
935    pub pdct_qty: Option<DecimalNumber>,
936    #[serde(rename = "Adjstmnt", skip_serializing_if = "Option::is_none")]
937    pub adjstmnt: Option<Adjustment12>,
938    #[serde(rename = "InsrncInd", skip_serializing_if = "Option::is_none")]
939    pub insrnc_ind: Option<TrueFalseIndicator>,
940    #[serde(rename = "InsrncAmt", skip_serializing_if = "Option::is_none")]
941    pub insrnc_amt: Option<ImpliedCurrencyAndAmount>,
942    #[validate(length(min = 0,))]
943    #[serde(rename = "Tax", default)]
944    pub tax: Vec<Tax39>,
945    #[serde(rename = "UnqVATInvcRef", skip_serializing_if = "Option::is_none")]
946    pub unq_vat_invc_ref: Option<Max35Text>,
947    #[serde(rename = "TtlAmt", skip_serializing_if = "Option::is_none")]
948    pub ttl_amt: Option<ImpliedCurrencyAndAmount>,
949    #[serde(rename = "CdtDbt", skip_serializing_if = "Option::is_none")]
950    pub cdt_dbt: Option<CreditDebit3Code>,
951    #[serde(rename = "ZeroCostToCstmrInd", skip_serializing_if = "Option::is_none")]
952    pub zero_cost_to_cstmr_ind: Option<TrueFalseIndicator>,
953    #[serde(rename = "AddtlData", skip_serializing_if = "Option::is_none")]
954    pub addtl_data: Option<Max350Text>,
955}
956#[derive(
957    Debug,
958    Default,
959    Clone,
960    PartialEq,
961    ::serde::Serialize,
962    ::serde::Deserialize,
963    ::derive_builder::Builder,
964    ::validator::Validate,
965)]
966pub struct AlgorithmIdentification23 {
967    #[serde(rename = "Algo")]
968    pub algo: Algorithm18Code,
969    #[serde(rename = "Param", skip_serializing_if = "Option::is_none")]
970    pub param: Option<Parameter12>,
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 Iso3NumericCountryCode {
983    #[validate(regex = "ISO_3_NUMERIC_COUNTRY_CODE_REGEX")]
984    #[serde(rename = "$text")]
985    pub value: String,
986}
987#[derive(
988    Debug,
989    Default,
990    Clone,
991    PartialEq,
992    ::serde::Serialize,
993    ::serde::Deserialize,
994    ::derive_builder::Builder,
995    ::validator::Validate,
996)]
997pub struct Amount12 {
998    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
999    pub tp: Option<TemporaryServicesCharge1Code>,
1000    #[serde(rename = "OthrTp", skip_serializing_if = "Option::is_none")]
1001    pub othr_tp: Option<Max35Text>,
1002    #[serde(rename = "Rate", skip_serializing_if = "Option::is_none")]
1003    pub rate: Option<ImpliedCurrencyAndAmount>,
1004    #[serde(rename = "Hrs", skip_serializing_if = "Option::is_none")]
1005    pub hrs: Option<Max6NumericText>,
1006}
1007#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1008pub enum Algorithm11Code {
1009    #[serde(rename = "HS25")]
1010    Hs25,
1011    #[serde(rename = "HS38")]
1012    Hs38,
1013    #[serde(rename = "HS51")]
1014    Hs51,
1015    #[serde(rename = "HS01")]
1016    Hs01,
1017    #[default]
1018    Unknown,
1019}
1020#[derive(
1021    Debug,
1022    Default,
1023    Clone,
1024    PartialEq,
1025    ::serde::Serialize,
1026    ::serde::Deserialize,
1027    ::derive_builder::Builder,
1028    ::validator::Validate,
1029)]
1030pub struct Address2 {
1031    #[serde(rename = "AdrLine1", skip_serializing_if = "Option::is_none")]
1032    pub adr_line_1: Option<Max99Text>,
1033    #[serde(rename = "AdrLine2", skip_serializing_if = "Option::is_none")]
1034    pub adr_line_2: Option<Max99Text>,
1035    #[serde(rename = "StrtNm", skip_serializing_if = "Option::is_none")]
1036    pub strt_nm: Option<Max99Text>,
1037    #[serde(rename = "BldgNb", skip_serializing_if = "Option::is_none")]
1038    pub bldg_nb: Option<Max16Text>,
1039    #[serde(rename = "PstlCd", skip_serializing_if = "Option::is_none")]
1040    pub pstl_cd: Option<Max16Text>,
1041    #[serde(rename = "TwnNm", skip_serializing_if = "Option::is_none")]
1042    pub twn_nm: Option<Max50Text>,
1043    #[serde(rename = "CtrySubDvsnMnr", skip_serializing_if = "Option::is_none")]
1044    pub ctry_sub_dvsn_mnr: Option<IsoCountrySubDivisionCode>,
1045    #[serde(rename = "CtrySubDvsnMjr", skip_serializing_if = "Option::is_none")]
1046    pub ctry_sub_dvsn_mjr: Option<IsoCountrySubDivisionCode>,
1047    #[serde(rename = "CtrySubDvsnMjrNm", skip_serializing_if = "Option::is_none")]
1048    pub ctry_sub_dvsn_mjr_nm: Option<Max50Text>,
1049    #[serde(rename = "CtrySubDvsnMnrNm", skip_serializing_if = "Option::is_none")]
1050    pub ctry_sub_dvsn_mnr_nm: Option<Max50Text>,
1051    #[serde(rename = "Ctry", skip_serializing_if = "Option::is_none")]
1052    pub ctry: Option<IsoMax3ACountryCode>,
1053}
1054#[derive(
1055    Debug,
1056    Default,
1057    Clone,
1058    PartialEq,
1059    ::serde::Serialize,
1060    ::serde::Deserialize,
1061    ::derive_builder::Builder,
1062    ::validator::Validate,
1063)]
1064pub struct Amount19 {
1065    #[serde(rename = "Desc", skip_serializing_if = "Option::is_none")]
1066    pub desc: Option<Max35Text>,
1067    #[validate]
1068    #[serde(rename = "Amt")]
1069    pub amt: ImpliedCurrencyAndAmount,
1070    #[serde(rename = "CdtDbt", skip_serializing_if = "Option::is_none")]
1071    pub cdt_dbt: Option<CreditDebit3Code>,
1072    #[validate(length(min = 0,))]
1073    #[serde(rename = "Tax", default)]
1074    pub tax: Vec<Tax39>,
1075}
1076#[derive(
1077    Debug,
1078    Default,
1079    Clone,
1080    PartialEq,
1081    ::serde::Serialize,
1082    ::serde::Deserialize,
1083    ::derive_builder::Builder,
1084    ::validator::Validate,
1085)]
1086pub struct ErrorDetails2 {
1087    #[serde(rename = "MsgErrTp")]
1088    pub msg_err_tp: MessageError1Code,
1089    #[serde(rename = "OthrMsgErrTp", skip_serializing_if = "Option::is_none")]
1090    pub othr_msg_err_tp: Option<Max35Text>,
1091    #[serde(rename = "ErrCd", skip_serializing_if = "Option::is_none")]
1092    pub err_cd: Option<Max35Text>,
1093    #[serde(rename = "ErrDesc", skip_serializing_if = "Option::is_none")]
1094    pub err_desc: Option<Max500Text>,
1095    #[validate(length(min = 0,))]
1096    #[serde(rename = "DataElmtInErr", default)]
1097    pub data_elmt_in_err: Vec<Max4000Text>,
1098}
1099#[derive(
1100    Debug,
1101    Default,
1102    Clone,
1103    PartialEq,
1104    ::serde::Serialize,
1105    ::serde::Deserialize,
1106    ::derive_builder::Builder,
1107    ::validator::Validate,
1108)]
1109pub struct SettlementServiceMode1 {
1110    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
1111    pub tp: Option<Max35Text>,
1112    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
1113    pub id: Option<Max35Text>,
1114    #[serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none")]
1115    pub shrt_nm: Option<Max35Text>,
1116    #[serde(rename = "SttlmPrty", skip_serializing_if = "Option::is_none")]
1117    pub sttlm_prty: Option<Priority3Code>,
1118}
1119#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1120pub enum InterestRate1Code {
1121    #[serde(rename = "GSRT")]
1122    Gsrt,
1123    #[serde(rename = "NTRT")]
1124    Ntrt,
1125    #[serde(rename = "OTHN")]
1126    Othn,
1127    #[serde(rename = "OTHP")]
1128    Othp,
1129    #[default]
1130    Unknown,
1131}
1132#[derive(
1133    Debug,
1134    Default,
1135    Clone,
1136    PartialEq,
1137    ::serde::Serialize,
1138    ::serde::Deserialize,
1139    ::derive_builder::Builder,
1140    ::validator::Validate,
1141)]
1142pub struct PartyIdentification200 {
1143    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
1144    pub id: Option<Max35Text>,
1145    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
1146    pub tp: Option<PartyType28Code>,
1147    #[serde(rename = "OthrTp", skip_serializing_if = "Option::is_none")]
1148    pub othr_tp: Option<Max35Text>,
1149    #[serde(rename = "Assgnr", skip_serializing_if = "Option::is_none")]
1150    pub assgnr: Option<PartyType18Code>,
1151    #[serde(rename = "Ctry", skip_serializing_if = "Option::is_none")]
1152    pub ctry: Option<Iso3NumericCountryCode>,
1153    #[serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none")]
1154    pub shrt_nm: Option<Max35Text>,
1155}
1156#[derive(
1157    Debug,
1158    Default,
1159    Clone,
1160    PartialEq,
1161    ::serde::Serialize,
1162    ::serde::Deserialize,
1163    ::derive_builder::Builder,
1164    ::validator::Validate,
1165)]
1166pub struct Ticket2 {
1167    #[serde(rename = "TcktNb", skip_serializing_if = "Option::is_none")]
1168    pub tckt_nb: Option<Max35Text>,
1169    #[serde(rename = "TcktIssr", skip_serializing_if = "Option::is_none")]
1170    pub tckt_issr: Option<PartyIdentification258>,
1171    #[serde(rename = "TcktIsseDt", skip_serializing_if = "Option::is_none")]
1172    pub tckt_isse_dt: Option<IsoDate>,
1173    #[serde(rename = "TcktIsseLctn", skip_serializing_if = "Option::is_none")]
1174    pub tckt_isse_lctn: Option<Max140Text>,
1175    #[serde(rename = "CnjnctnTcktNb", skip_serializing_if = "Option::is_none")]
1176    pub cnjnctn_tckt_nb: Option<Max35Text>,
1177    #[serde(rename = "RstrctdTcktInd", skip_serializing_if = "Option::is_none")]
1178    pub rstrctd_tckt_ind: Option<TrueFalseIndicator>,
1179    #[serde(rename = "OpnTcktInd", skip_serializing_if = "Option::is_none")]
1180    pub opn_tckt_ind: Option<TrueFalseIndicator>,
1181    #[serde(rename = "Rstrctns", skip_serializing_if = "Option::is_none")]
1182    pub rstrctns: Option<Max70Text>,
1183    #[serde(rename = "XchgdTcktInd", skip_serializing_if = "Option::is_none")]
1184    pub xchgd_tckt_ind: Option<TrueFalseIndicator>,
1185    #[serde(rename = "XchgdTcktNb", skip_serializing_if = "Option::is_none")]
1186    pub xchgd_tckt_nb: Option<Max35Text>,
1187    #[serde(rename = "RcrdLctrNb", skip_serializing_if = "Option::is_none")]
1188    pub rcrd_lctr_nb: Option<Max35Text>,
1189    #[serde(rename = "Rsvatn", skip_serializing_if = "Option::is_none")]
1190    pub rsvatn: Option<ReservationDetails3>,
1191}
1192#[derive(
1193    Debug,
1194    Default,
1195    Clone,
1196    PartialEq,
1197    ::serde::Serialize,
1198    ::serde::Deserialize,
1199    ::derive_builder::Builder,
1200    ::validator::Validate,
1201)]
1202pub struct Environment20 {
1203    #[serde(rename = "Acqrr", skip_serializing_if = "Option::is_none")]
1204    pub acqrr: Option<PartyIdentification263>,
1205    #[serde(rename = "Orgtr", skip_serializing_if = "Option::is_none")]
1206    pub orgtr: Option<PartyIdentification263>,
1207    #[serde(rename = "Sndr", skip_serializing_if = "Option::is_none")]
1208    pub sndr: Option<PartyIdentification263>,
1209    #[serde(rename = "Rcvr", skip_serializing_if = "Option::is_none")]
1210    pub rcvr: Option<PartyIdentification263>,
1211    #[serde(rename = "Accptr", skip_serializing_if = "Option::is_none")]
1212    pub accptr: Option<PartyIdentification254>,
1213    #[serde(rename = "Dstn", skip_serializing_if = "Option::is_none")]
1214    pub dstn: Option<PartyIdentification263>,
1215    #[serde(rename = "Pyer", skip_serializing_if = "Option::is_none")]
1216    pub pyer: Option<PartyIdentification257>,
1217    #[serde(rename = "Pyee", skip_serializing_if = "Option::is_none")]
1218    pub pyee: Option<PartyIdentification257>,
1219    #[serde(rename = "Termnl", skip_serializing_if = "Option::is_none")]
1220    pub termnl: Option<Terminal5>,
1221    #[serde(rename = "Issr", skip_serializing_if = "Option::is_none")]
1222    pub issr: Option<PartyIdentification263>,
1223    #[validate]
1224    #[serde(rename = "Card")]
1225    pub card: CardData7,
1226    #[serde(rename = "CstmrDvc", skip_serializing_if = "Option::is_none")]
1227    pub cstmr_dvc: Option<CustomerDevice4>,
1228    #[serde(rename = "Wllt", skip_serializing_if = "Option::is_none")]
1229    pub wllt: Option<Wallet2>,
1230    #[serde(rename = "Tkn", skip_serializing_if = "Option::is_none")]
1231    pub tkn: Option<Token2>,
1232    #[serde(rename = "Crdhldr", skip_serializing_if = "Option::is_none")]
1233    pub crdhldr: Option<Cardholder19>,
1234}
1235#[derive(
1236    Debug,
1237    Default,
1238    Clone,
1239    PartialEq,
1240    ::serde::Serialize,
1241    ::serde::Deserialize,
1242    ::derive_builder::Builder,
1243    ::validator::Validate,
1244)]
1245pub struct ProcessingResult17 {
1246    #[serde(rename = "RspnSrc", skip_serializing_if = "Option::is_none")]
1247    pub rspn_src: Option<ApprovalEntity2>,
1248    #[validate]
1249    #[serde(rename = "RsltData")]
1250    pub rslt_data: ResultData7,
1251    #[validate(length(min = 0,))]
1252    #[serde(rename = "ErrDtl", default)]
1253    pub err_dtl: Vec<ErrorDetails2>,
1254    #[serde(rename = "OrgnlRsltData", skip_serializing_if = "Option::is_none")]
1255    pub orgnl_rslt_data: Option<ResultData7>,
1256    #[serde(rename = "ActnReqrd", skip_serializing_if = "Option::is_none")]
1257    pub actn_reqrd: Option<YesNoIndicator>,
1258    #[validate(length(min = 0,))]
1259    #[serde(rename = "Actn", default)]
1260    pub actn: Vec<Action13>,
1261    #[validate(length(min = 0,))]
1262    #[serde(rename = "AddtlActn", default)]
1263    pub addtl_actn: Vec<AdditionalAction1>,
1264    #[validate(length(min = 0,))]
1265    #[serde(rename = "AddtlInf", default)]
1266    pub addtl_inf: Vec<AdditionalInformation29>,
1267}
1268#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1269pub enum TransactionInitiator1Code {
1270    #[serde(rename = "MERC")]
1271    Merc,
1272    #[serde(rename = "CUST")]
1273    Cust,
1274    #[default]
1275    Unknown,
1276}
1277#[derive(
1278    Debug,
1279    Default,
1280    Clone,
1281    PartialEq,
1282    ::serde::Serialize,
1283    ::serde::Deserialize,
1284    ::derive_builder::Builder,
1285    ::validator::Validate,
1286)]
1287pub struct Exact6AlphaNumericText {
1288    #[validate(regex = "EXACT_6_ALPHA_NUMERIC_TEXT_REGEX")]
1289    #[serde(rename = "$text")]
1290    pub value: String,
1291}
1292#[derive(
1293    Debug,
1294    Default,
1295    Clone,
1296    PartialEq,
1297    ::serde::Serialize,
1298    ::serde::Deserialize,
1299    ::derive_builder::Builder,
1300    ::validator::Validate,
1301)]
1302pub struct Max10KHexBinaryText {
1303    #[validate(regex = "MAX_10_K_HEX_BINARY_TEXT_REGEX")]
1304    #[serde(rename = "$text")]
1305    pub value: String,
1306}
1307#[derive(
1308    Debug,
1309    Default,
1310    Clone,
1311    PartialEq,
1312    ::serde::Serialize,
1313    ::serde::Deserialize,
1314    ::derive_builder::Builder,
1315    ::validator::Validate,
1316)]
1317pub struct Customer6 {
1318    #[serde(rename = "AcctNb", skip_serializing_if = "Option::is_none")]
1319    pub acct_nb: Option<Max35Text>,
1320    #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
1321    pub nm: Option<Max70Text>,
1322    #[serde(rename = "PhneNb", skip_serializing_if = "Option::is_none")]
1323    pub phne_nb: Option<PhoneNumber>,
1324}
1325#[derive(
1326    Debug,
1327    Default,
1328    Clone,
1329    PartialEq,
1330    ::serde::Serialize,
1331    ::serde::Deserialize,
1332    ::derive_builder::Builder,
1333    ::validator::Validate,
1334)]
1335pub struct Max19HexBinaryText {
1336    #[validate(regex = "MAX_19_HEX_BINARY_TEXT_REGEX")]
1337    #[serde(rename = "$text")]
1338    pub value: String,
1339}
1340#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1341pub enum PartyType21Code {
1342    #[serde(rename = "ACCP")]
1343    Accp,
1344    #[serde(rename = "CRDH")]
1345    Crdh,
1346    #[serde(rename = "OTHN")]
1347    Othn,
1348    #[serde(rename = "OTHP")]
1349    Othp,
1350    #[default]
1351    Unknown,
1352}
1353#[derive(
1354    Debug,
1355    Default,
1356    Clone,
1357    PartialEq,
1358    ::serde::Serialize,
1359    ::serde::Deserialize,
1360    ::derive_builder::Builder,
1361    ::validator::Validate,
1362)]
1363pub struct DetailedAmount22 {
1364    #[serde(rename = "Tp")]
1365    pub tp: Iso8583AmountTypeCode,
1366    #[serde(rename = "OthrTp", skip_serializing_if = "Option::is_none")]
1367    pub othr_tp: Option<Max35Text>,
1368    #[serde(rename = "CdtDbt", skip_serializing_if = "Option::is_none")]
1369    pub cdt_dbt: Option<CreditDebit3Code>,
1370    #[validate]
1371    #[serde(rename = "Amt")]
1372    pub amt: ImpliedCurrencyAndAmount,
1373    #[serde(rename = "CrdhldrBllgAmt", skip_serializing_if = "Option::is_none")]
1374    pub crdhldr_bllg_amt: Option<ImpliedCurrencyAndAmount>,
1375    #[serde(rename = "RcncltnAmt", skip_serializing_if = "Option::is_none")]
1376    pub rcncltn_amt: Option<ImpliedCurrencyAndAmount>,
1377    #[serde(rename = "Desc", skip_serializing_if = "Option::is_none")]
1378    pub desc: Option<Max70Text>,
1379}
1380#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1381pub enum PlanOwner1Code {
1382    #[serde(rename = "ACCP")]
1383    Accp,
1384    #[serde(rename = "ACQR")]
1385    Acqr,
1386    #[serde(rename = "ISSR")]
1387    Issr,
1388    #[serde(rename = "OTHN")]
1389    Othn,
1390    #[serde(rename = "OTHP")]
1391    Othp,
1392    #[default]
1393    Unknown,
1394}
1395#[derive(
1396    Debug,
1397    Default,
1398    Clone,
1399    PartialEq,
1400    ::serde::Serialize,
1401    ::serde::Deserialize,
1402    ::derive_builder::Builder,
1403    ::validator::Validate,
1404)]
1405pub struct TemporaryServicesCompany2 {
1406    #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
1407    pub nm: Option<Max70Text>,
1408    #[serde(rename = "Dept", skip_serializing_if = "Option::is_none")]
1409    pub dept: Option<Max70Text>,
1410    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
1411    pub id: Option<PartyIdentification258>,
1412    #[serde(rename = "Sprvsr", skip_serializing_if = "Option::is_none")]
1413    pub sprvsr: Option<Max70Text>,
1414}
1415#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1416pub enum GracePeriodUnitType1Code {
1417    #[serde(rename = "WEKS")]
1418    Weks,
1419    #[serde(rename = "PMTS")]
1420    Pmts,
1421    #[serde(rename = "OTHP")]
1422    Othp,
1423    #[serde(rename = "OTHN")]
1424    Othn,
1425    #[serde(rename = "MNTH")]
1426    Mnth,
1427    #[serde(rename = "DAYS")]
1428    Days,
1429    #[default]
1430    Unknown,
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 LodgingProperty2 {
1443    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
1444    pub tp: Option<LodgingActivity1Code>,
1445    #[serde(rename = "OthrTp", skip_serializing_if = "Option::is_none")]
1446    pub othr_tp: Option<Max35Text>,
1447    #[serde(rename = "PrstgsPrprty", skip_serializing_if = "Option::is_none")]
1448    pub prstgs_prprty: Option<Max35Text>,
1449    #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
1450    pub nm: Option<Max35Text>,
1451    #[validate]
1452    #[serde(rename = "Id")]
1453    pub id: PartyIdentification258,
1454    #[serde(rename = "Lctn", skip_serializing_if = "Option::is_none")]
1455    pub lctn: Option<Location4>,
1456    #[serde(rename = "Assgnr", skip_serializing_if = "Option::is_none")]
1457    pub assgnr: Option<CompanyAssigner2Code>,
1458    #[serde(rename = "Ctct", skip_serializing_if = "Option::is_none")]
1459    pub ctct: Option<Contact3>,
1460    #[serde(rename = "Ctry", skip_serializing_if = "Option::is_none")]
1461    pub ctry: Option<IsoMax3ACountryCode>,
1462    #[serde(rename = "FireSftyActInd", skip_serializing_if = "Option::is_none")]
1463    pub fire_sfty_act_ind: Option<TrueFalseIndicator>,
1464}
1465#[derive(
1466    Debug,
1467    Default,
1468    Clone,
1469    PartialEq,
1470    ::serde::Serialize,
1471    ::serde::Deserialize,
1472    ::derive_builder::Builder,
1473    ::validator::Validate,
1474)]
1475pub struct Parameter9 {
1476    #[serde(rename = "DgstAlgo", skip_serializing_if = "Option::is_none")]
1477    pub dgst_algo: Option<Algorithm16Code>,
1478}
1479#[derive(
1480    Debug,
1481    Default,
1482    Clone,
1483    PartialEq,
1484    ::serde::Serialize,
1485    ::serde::Deserialize,
1486    ::derive_builder::Builder,
1487    ::validator::Validate,
1488)]
1489pub struct Iso2ALanguageCode {
1490    #[validate(regex = "ISO_2_A_LANGUAGE_CODE_REGEX")]
1491    #[serde(rename = "$text")]
1492    pub value: String,
1493}
1494#[derive(
1495    Debug,
1496    Default,
1497    Clone,
1498    PartialEq,
1499    ::serde::Serialize,
1500    ::serde::Deserialize,
1501    ::derive_builder::Builder,
1502    ::validator::Validate,
1503)]
1504pub struct TemporaryServices2 {
1505    #[serde(rename = "CtrctgCpny", skip_serializing_if = "Option::is_none")]
1506    pub ctrctg_cpny: Option<TemporaryServicesCompany2>,
1507    #[serde(rename = "TempMplyee", skip_serializing_if = "Option::is_none")]
1508    pub temp_mplyee: Option<PartyIdentification210>,
1509    #[serde(rename = "Job", skip_serializing_if = "Option::is_none")]
1510    pub job: Option<TemporaryServicesJob1>,
1511    #[serde(rename = "FlatRateInd", skip_serializing_if = "Option::is_none")]
1512    pub flat_rate_ind: Option<TrueFalseIndicator>,
1513    #[serde(rename = "DscntAmt", skip_serializing_if = "Option::is_none")]
1514    pub dscnt_amt: Option<ImpliedCurrencyAndAmount>,
1515    #[serde(rename = "SummryCmmdtyId", skip_serializing_if = "Option::is_none")]
1516    pub summry_cmmdty_id: Option<Max35Text>,
1517    #[serde(rename = "Labr", skip_serializing_if = "Option::is_none")]
1518    pub labr: Option<TemporaryServicesLabor1>,
1519    #[validate(length(min = 0,))]
1520    #[serde(rename = "MiscExpnss", default)]
1521    pub misc_expnss: Vec<Amount13>,
1522    #[serde(rename = "SbttlAmt", skip_serializing_if = "Option::is_none")]
1523    pub sbttl_amt: Option<ImpliedCurrencyAndAmount>,
1524    #[validate(length(min = 0,))]
1525    #[serde(rename = "Tax", default)]
1526    pub tax: Vec<Tax39>,
1527    #[serde(rename = "AddtlData", skip_serializing_if = "Option::is_none")]
1528    pub addtl_data: Option<Max350Text>,
1529}
1530#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1531pub enum ExchangeRateAgreementType1Code {
1532    #[serde(rename = "FWCT")]
1533    Fwct,
1534    #[serde(rename = "NORM")]
1535    Norm,
1536    #[serde(rename = "OTHN")]
1537    Othn,
1538    #[serde(rename = "OTHP")]
1539    Othp,
1540    #[serde(rename = "SPOT")]
1541    Spot,
1542    #[default]
1543    Unknown,
1544}
1545#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1546pub enum AdditionalServiceResult1Code {
1547    #[serde(rename = "NOPF")]
1548    Nopf,
1549    #[serde(rename = "NOSP")]
1550    Nosp,
1551    #[serde(rename = "OTHN")]
1552    Othn,
1553    #[serde(rename = "OTHP")]
1554    Othp,
1555    #[serde(rename = "PERF")]
1556    Perf,
1557    #[default]
1558    Unknown,
1559}
1560#[derive(
1561    Debug,
1562    Default,
1563    Clone,
1564    PartialEq,
1565    ::serde::Serialize,
1566    ::serde::Deserialize,
1567    ::derive_builder::Builder,
1568    ::validator::Validate,
1569)]
1570pub struct Customer4 {
1571    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
1572    pub tp: Option<CustomerType2Code>,
1573    #[serde(rename = "RefNb", skip_serializing_if = "Option::is_none")]
1574    pub ref_nb: Option<Max35Text>,
1575    #[validate(length(min = 0,))]
1576    #[serde(rename = "TaxRegnId", default)]
1577    pub tax_regn_id: Vec<Max70Text>,
1578    #[serde(rename = "AuthrsdCtctCpny", skip_serializing_if = "Option::is_none")]
1579    pub authrsd_ctct_cpny: Option<Max70Text>,
1580    #[serde(rename = "AuthrsdCtctNm", skip_serializing_if = "Option::is_none")]
1581    pub authrsd_ctct_nm: Option<Max70Text>,
1582    #[serde(rename = "AuthrsdCtctPhneNb", skip_serializing_if = "Option::is_none")]
1583    pub authrsd_ctct_phne_nb: Option<PhoneNumber>,
1584    #[serde(rename = "VIPInd", skip_serializing_if = "Option::is_none")]
1585    pub vip_ind: Option<TrueFalseIndicator>,
1586    #[serde(rename = "CstmrRltsh", skip_serializing_if = "Option::is_none")]
1587    pub cstmr_rltsh: Option<Max35Text>,
1588}
1589#[derive(
1590    Debug,
1591    Default,
1592    Clone,
1593    PartialEq,
1594    ::serde::Serialize,
1595    ::serde::Deserialize,
1596    ::derive_builder::Builder,
1597    ::validator::Validate,
1598)]
1599pub struct ContentInformationType20 {
1600    #[validate]
1601    #[serde(rename = "MACData")]
1602    pub mac_data: MacData1,
1603    #[validate]
1604    #[serde(rename = "MAC")]
1605    pub mac: Max8HexBinaryText,
1606}
1607#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1608pub enum CreditDebit3Code {
1609    #[serde(rename = "CRDT")]
1610    Crdt,
1611    #[serde(rename = "DBIT")]
1612    Dbit,
1613    #[default]
1614    Unknown,
1615}
1616#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1617pub enum FleetPurchaseType1Code {
1618    #[serde(rename = "FUEL")]
1619    Fuel,
1620    #[serde(rename = "NONF")]
1621    Nonf,
1622    #[serde(rename = "FANF")]
1623    Fanf,
1624    #[default]
1625    Unknown,
1626}
1627#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1628pub enum Algorithm13Code {
1629    #[serde(rename = "EA2C")]
1630    Ea2C,
1631    #[serde(rename = "E3DC")]
1632    E3Dc,
1633    #[serde(rename = "DKP9")]
1634    Dkp9,
1635    #[serde(rename = "UKPT")]
1636    Ukpt,
1637    #[serde(rename = "UKA1")]
1638    Uka1,
1639    #[serde(rename = "EA9C")]
1640    Ea9C,
1641    #[serde(rename = "EA5C")]
1642    Ea5C,
1643    #[default]
1644    Unknown,
1645}
1646#[derive(
1647    Debug,
1648    Default,
1649    Clone,
1650    PartialEq,
1651    ::serde::Serialize,
1652    ::serde::Deserialize,
1653    ::derive_builder::Builder,
1654    ::validator::Validate,
1655)]
1656pub struct Cardholder19 {
1657    #[serde(rename = "CrdhldrNm", skip_serializing_if = "Option::is_none")]
1658    pub crdhldr_nm: Option<CardholderName3>,
1659    #[validate(length(min = 0,))]
1660    #[serde(rename = "Id", default)]
1661    pub id: Vec<Credentials2>,
1662    #[serde(rename = "Adr", skip_serializing_if = "Option::is_none")]
1663    pub adr: Option<Address2>,
1664    #[serde(rename = "CtctInf", skip_serializing_if = "Option::is_none")]
1665    pub ctct_inf: Option<Contact1>,
1666    #[serde(rename = "DtOfBirth", skip_serializing_if = "Option::is_none")]
1667    pub dt_of_birth: Option<IsoDate>,
1668    #[serde(rename = "HghValCstmrInd", skip_serializing_if = "Option::is_none")]
1669    pub hgh_val_cstmr_ind: Option<TrueFalseIndicator>,
1670    #[validate(length(min = 0,))]
1671    #[serde(rename = "AddtlData", default)]
1672    pub addtl_data: Vec<AdditionalData1>,
1673    #[serde(rename = "LclData", skip_serializing_if = "Option::is_none")]
1674    pub lcl_data: Option<LocalData7>,
1675}
1676#[derive(
1677    Debug,
1678    Default,
1679    Clone,
1680    PartialEq,
1681    ::serde::Serialize,
1682    ::serde::Deserialize,
1683    ::derive_builder::Builder,
1684    ::validator::Validate,
1685)]
1686pub struct ShippingPackage2 {
1687    #[serde(rename = "TrckgNb", skip_serializing_if = "Option::is_none")]
1688    pub trckg_nb: Option<Max70Text>,
1689    #[serde(rename = "Spplr", skip_serializing_if = "Option::is_none")]
1690    pub spplr: Option<PartyIdentification260>,
1691    #[serde(rename = "PckpDt", skip_serializing_if = "Option::is_none")]
1692    pub pckp_dt: Option<IsoDate>,
1693    #[serde(rename = "PckpTm", skip_serializing_if = "Option::is_none")]
1694    pub pckp_tm: Option<IsoTime>,
1695    #[serde(rename = "Dlvry", skip_serializing_if = "Option::is_none")]
1696    pub dlvry: Option<DeliveryInformation4>,
1697    #[serde(rename = "Wght", skip_serializing_if = "Option::is_none")]
1698    pub wght: Option<UnitOfMeasure2>,
1699    #[validate(length(min = 0,))]
1700    #[serde(rename = "Pdct", default)]
1701    pub pdct: Vec<Product7>,
1702    #[serde(rename = "InsrncInd", skip_serializing_if = "Option::is_none")]
1703    pub insrnc_ind: Option<TrueFalseIndicator>,
1704    #[serde(rename = "InsrncAmt", skip_serializing_if = "Option::is_none")]
1705    pub insrnc_amt: Option<ImpliedCurrencyAndAmount>,
1706}
1707#[derive(
1708    Debug,
1709    Default,
1710    Clone,
1711    PartialEq,
1712    ::serde::Serialize,
1713    ::serde::Deserialize,
1714    ::derive_builder::Builder,
1715    ::validator::Validate,
1716)]
1717pub struct FeeAmount3 {
1718    #[validate]
1719    #[serde(rename = "Amt")]
1720    pub amt: ImpliedCurrencyAndAmount,
1721    #[serde(rename = "CdtDbt", skip_serializing_if = "Option::is_none")]
1722    pub cdt_dbt: Option<CreditDebit3Code>,
1723    #[serde(rename = "Ccy", skip_serializing_if = "Option::is_none")]
1724    pub ccy: Option<Iso3NumericCurrencyCode>,
1725    #[serde(rename = "FctvXchgRate", skip_serializing_if = "Option::is_none")]
1726    pub fctv_xchg_rate: Option<BaseOne25Rate>,
1727    #[serde(rename = "ConvsDt", skip_serializing_if = "Option::is_none")]
1728    pub convs_dt: Option<IsoDate>,
1729    #[serde(rename = "ConvsTm", skip_serializing_if = "Option::is_none")]
1730    pub convs_tm: Option<IsoTime>,
1731}
1732#[derive(
1733    Debug,
1734    Default,
1735    Clone,
1736    PartialEq,
1737    ::serde::Serialize,
1738    ::serde::Deserialize,
1739    ::derive_builder::Builder,
1740    ::validator::Validate,
1741)]
1742pub struct CustomerReference1 {
1743    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
1744    pub id: Option<Max35Text>,
1745    #[serde(rename = "Dtl", skip_serializing_if = "Option::is_none")]
1746    pub dtl: Option<Max70Text>,
1747}
1748#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1749pub enum DeviceIdentificationType1Code {
1750    #[serde(rename = "IMEI")]
1751    Imei,
1752    #[serde(rename = "OTHN")]
1753    Othn,
1754    #[serde(rename = "OTHP")]
1755    Othp,
1756    #[serde(rename = "SEID")]
1757    Seid,
1758    #[serde(rename = "SENU")]
1759    Senu,
1760    #[default]
1761    Unknown,
1762}
1763#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1764pub enum JourneyType1Code {
1765    #[serde(rename = "COAC")]
1766    Coac,
1767    #[serde(rename = "EARL")]
1768    Earl,
1769    #[serde(rename = "FLGT")]
1770    Flgt,
1771    #[serde(rename = "LATE")]
1772    Late,
1773    #[serde(rename = "ONTM")]
1774    Ontm,
1775    #[serde(rename = "OTHR")]
1776    Othr,
1777    #[serde(rename = "TRAN")]
1778    Tran,
1779    #[serde(rename = "VESS")]
1780    Vess,
1781    #[default]
1782    Unknown,
1783}
1784#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1785pub enum SecurityCharacteristics1Code {
1786    #[serde(rename = "CETE")]
1787    Cete,
1788    #[serde(rename = "CPTE")]
1789    Cpte,
1790    #[serde(rename = "CENC")]
1791    Cenc,
1792    #[serde(rename = "CMAC")]
1793    Cmac,
1794    #[serde(rename = "ETEE")]
1795    Etee,
1796    #[serde(rename = "METE")]
1797    Mete,
1798    #[serde(rename = "MPTE")]
1799    Mpte,
1800    #[serde(rename = "OPNN")]
1801    Opnn,
1802    #[serde(rename = "PMAC")]
1803    Pmac,
1804    #[serde(rename = "PKIE")]
1805    Pkie,
1806    #[serde(rename = "PRAE")]
1807    Prae,
1808    #[serde(rename = "PRAM")]
1809    Pram,
1810    #[serde(rename = "PRVN")]
1811    Prvn,
1812    #[serde(rename = "STAM")]
1813    Stam,
1814    #[serde(rename = "APTE")]
1815    Apte,
1816    #[serde(rename = "AETE")]
1817    Aete,
1818    #[serde(rename = "OTHN")]
1819    Othn,
1820    #[serde(rename = "OTHP")]
1821    Othp,
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 AdditionalCharacteristics1 {
1836    #[serde(rename = "BizTp", skip_serializing_if = "Option::is_none")]
1837    pub biz_tp: Option<AdditionalCharacteristicDetails1>,
1838    #[serde(rename = "Ownr", skip_serializing_if = "Option::is_none")]
1839    pub ownr: Option<AdditionalCharacteristicDetails1>,
1840    #[serde(rename = "Certfctn", skip_serializing_if = "Option::is_none")]
1841    pub certfctn: Option<AdditionalCharacteristicDetails1>,
1842    #[serde(rename = "OwnrEthncty", skip_serializing_if = "Option::is_none")]
1843    pub ownr_ethncty: Option<AdditionalCharacteristicDetails1>,
1844}
1845#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1846pub enum Algorithm19Code {
1847    #[serde(rename = "ERS2")]
1848    Ers2,
1849    #[serde(rename = "ERS1")]
1850    Ers1,
1851    #[serde(rename = "RPSS")]
1852    Rpss,
1853    #[serde(rename = "ECC5")]
1854    Ecc5,
1855    #[serde(rename = "ECC1")]
1856    Ecc1,
1857    #[serde(rename = "ECC4")]
1858    Ecc4,
1859    #[serde(rename = "ECC2")]
1860    Ecc2,
1861    #[serde(rename = "ECC3")]
1862    Ecc3,
1863    #[serde(rename = "ERS3")]
1864    Ers3,
1865    #[serde(rename = "ECP2")]
1866    Ecp2,
1867    #[serde(rename = "ECP3")]
1868    Ecp3,
1869    #[serde(rename = "ECP5")]
1870    Ecp5,
1871    #[default]
1872    Unknown,
1873}
1874#[derive(
1875    Debug,
1876    Default,
1877    Clone,
1878    PartialEq,
1879    ::serde::Serialize,
1880    ::serde::Deserialize,
1881    ::derive_builder::Builder,
1882    ::validator::Validate,
1883)]
1884pub struct RateLock1 {
1885    #[serde(rename = "ReqdInd", skip_serializing_if = "Option::is_none")]
1886    pub reqd_ind: Option<TrueFalseIndicator>,
1887    #[serde(rename = "ElgblInd", skip_serializing_if = "Option::is_none")]
1888    pub elgbl_ind: Option<TrueFalseIndicator>,
1889    #[serde(rename = "ApldInd", skip_serializing_if = "Option::is_none")]
1890    pub apld_ind: Option<TrueFalseIndicator>,
1891}
1892#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1893pub enum ActionType10Code {
1894    #[serde(rename = "ACTV")]
1895    Actv,
1896    #[serde(rename = "DEAC")]
1897    Deac,
1898    #[serde(rename = "DISP")]
1899    Disp,
1900    #[serde(rename = "FUPD")]
1901    Fupd,
1902    #[serde(rename = "PRNT")]
1903    Prnt,
1904    #[serde(rename = "SNDM")]
1905    Sndm,
1906    #[default]
1907    Unknown,
1908}
1909#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1910pub enum PartyType18Code {
1911    #[serde(rename = "ACQR")]
1912    Acqr,
1913    #[serde(rename = "CISS")]
1914    Ciss,
1915    #[serde(rename = "CSCH")]
1916    Csch,
1917    #[serde(rename = "AGNT")]
1918    Agnt,
1919    #[default]
1920    Unknown,
1921}
1922#[derive(
1923    Debug,
1924    Default,
1925    Clone,
1926    PartialEq,
1927    ::serde::Serialize,
1928    ::serde::Deserialize,
1929    ::derive_builder::Builder,
1930    ::validator::Validate,
1931)]
1932pub struct Verification4 {
1933    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
1934    pub tp: Option<ExternalAuthenticationMethod1Code>,
1935    #[serde(rename = "OthrTp", skip_serializing_if = "Option::is_none")]
1936    pub othr_tp: Option<Max35Text>,
1937    #[serde(rename = "SubTp", skip_serializing_if = "Option::is_none")]
1938    pub sub_tp: Option<Max35Text>,
1939    #[serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none")]
1940    pub addtl_inf: Option<Max35Text>,
1941    #[validate(length(min = 0,))]
1942    #[serde(rename = "VrfctnRslt", default)]
1943    pub vrfctn_rslt: Vec<VerificationResult2>,
1944}
1945#[derive(
1946    Debug,
1947    Default,
1948    Clone,
1949    PartialEq,
1950    ::serde::Serialize,
1951    ::serde::Deserialize,
1952    ::derive_builder::Builder,
1953    ::validator::Validate,
1954)]
1955pub struct Max6Text {
1956    #[validate(length(min = 1, max = 6,))]
1957    #[serde(rename = "$text")]
1958    pub value: String,
1959}
1960#[derive(
1961    Debug,
1962    Default,
1963    Clone,
1964    PartialEq,
1965    ::serde::Serialize,
1966    ::serde::Deserialize,
1967    ::derive_builder::Builder,
1968    ::validator::Validate,
1969)]
1970pub struct Max350Text {
1971    #[validate(length(min = 1, max = 350,))]
1972    #[serde(rename = "$text")]
1973    pub value: String,
1974}
1975#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1976pub enum LoyaltyValueType1Code {
1977    #[serde(rename = "MILE")]
1978    Mile,
1979    #[serde(rename = "MONE")]
1980    Mone,
1981    #[serde(rename = "OTHR")]
1982    Othr,
1983    #[serde(rename = "POIN")]
1984    Poin,
1985    #[serde(rename = "PRIV")]
1986    Priv,
1987    #[default]
1988    Unknown,
1989}
1990#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1991pub enum BytePadding1Code {
1992    #[serde(rename = "LNGT")]
1993    Lngt,
1994    #[serde(rename = "NUL8")]
1995    Nul8,
1996    #[serde(rename = "NULG")]
1997    Nulg,
1998    #[serde(rename = "NULL")]
1999    Null,
2000    #[serde(rename = "RAND")]
2001    Rand,
2002    #[default]
2003    Unknown,
2004}
2005#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2006pub enum RiskAssessment1Code {
2007    #[serde(rename = "APPC")]
2008    Appc,
2009    #[serde(rename = "APPH")]
2010    Apph,
2011    #[serde(rename = "APPU")]
2012    Appu,
2013    #[serde(rename = "DONT")]
2014    Dont,
2015    #[default]
2016    Unknown,
2017}
2018#[derive(
2019    Debug,
2020    Default,
2021    Clone,
2022    PartialEq,
2023    ::serde::Serialize,
2024    ::serde::Deserialize,
2025    ::derive_builder::Builder,
2026    ::validator::Validate,
2027)]
2028pub struct AlgorithmIdentification20 {
2029    #[serde(rename = "Algo")]
2030    pub algo: Algorithm19Code,
2031    #[serde(rename = "Param", skip_serializing_if = "Option::is_none")]
2032    pub param: Option<Parameter11>,
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 LanguageCode {
2045    #[serde(rename = "$text")]
2046    pub value: String,
2047}
2048#[derive(
2049    Debug,
2050    Default,
2051    Clone,
2052    PartialEq,
2053    ::serde::Serialize,
2054    ::serde::Deserialize,
2055    ::derive_builder::Builder,
2056    ::validator::Validate,
2057)]
2058pub struct Min5Max16Binary {
2059    #[validate(length(min = 5, max = 16,), regex = "MIN_5_MAX_16_BINARY_REGEX")]
2060    pub value: String,
2061}
2062#[derive(
2063    Debug,
2064    Default,
2065    Clone,
2066    PartialEq,
2067    ::serde::Serialize,
2068    ::serde::Deserialize,
2069    ::derive_builder::Builder,
2070    ::validator::Validate,
2071)]
2072pub struct CardholderName3 {
2073    #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
2074    pub nm: Option<Max70Text>,
2075    #[serde(rename = "GvnNm", skip_serializing_if = "Option::is_none")]
2076    pub gvn_nm: Option<Max35Text>,
2077    #[serde(rename = "MddlNm", skip_serializing_if = "Option::is_none")]
2078    pub mddl_nm: Option<Max35Text>,
2079    #[serde(rename = "LastNm", skip_serializing_if = "Option::is_none")]
2080    pub last_nm: Option<Max35Text>,
2081}
2082#[derive(
2083    Debug,
2084    Default,
2085    Clone,
2086    PartialEq,
2087    ::serde::Serialize,
2088    ::serde::Deserialize,
2089    ::derive_builder::Builder,
2090    ::validator::Validate,
2091)]
2092pub struct CertificateIssuer1 {
2093    #[validate(length(min = 1,))]
2094    #[serde(rename = "RltvDstngshdNm", default)]
2095    pub rltv_dstngshd_nm: Vec<RelativeDistinguishedName1>,
2096}
2097#[derive(
2098    Debug,
2099    Default,
2100    Clone,
2101    PartialEq,
2102    ::serde::Serialize,
2103    ::serde::Deserialize,
2104    ::derive_builder::Builder,
2105    ::validator::Validate,
2106)]
2107pub struct SettlementService3 {
2108    #[serde(rename = "SttlmSvcPropsd", skip_serializing_if = "Option::is_none")]
2109    pub sttlm_svc_propsd: Option<SettlementServiceMode1>,
2110    #[serde(rename = "SttlmSvcApld", skip_serializing_if = "Option::is_none")]
2111    pub sttlm_svc_apld: Option<SettlementServiceMode1>,
2112    #[serde(rename = "SttlmSvcDts", skip_serializing_if = "Option::is_none")]
2113    pub sttlm_svc_dts: Option<SettlementServiceDate2>,
2114    #[serde(rename = "SttlmRptgNtty", skip_serializing_if = "Option::is_none")]
2115    pub sttlm_rptg_ntty: Option<SettlementReportingEntity1>,
2116    #[validate(length(min = 0,))]
2117    #[serde(rename = "AddtlSttlmInf", default)]
2118    pub addtl_sttlm_inf: Vec<AdditionalData1>,
2119}
2120#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2121pub enum Algorithm16Code {
2122    #[serde(rename = "HS25")]
2123    Hs25,
2124    #[serde(rename = "HS38")]
2125    Hs38,
2126    #[serde(rename = "HS51")]
2127    Hs51,
2128    #[serde(rename = "HS01")]
2129    Hs01,
2130    #[serde(rename = "SH31")]
2131    Sh31,
2132    #[serde(rename = "SH32")]
2133    Sh32,
2134    #[serde(rename = "SH33")]
2135    Sh33,
2136    #[serde(rename = "SH35")]
2137    Sh35,
2138    #[serde(rename = "SHK1")]
2139    Shk1,
2140    #[serde(rename = "SHK2")]
2141    Shk2,
2142    #[default]
2143    Unknown,
2144}
2145#[derive(
2146    Debug,
2147    Default,
2148    Clone,
2149    PartialEq,
2150    ::serde::Serialize,
2151    ::serde::Deserialize,
2152    ::derive_builder::Builder,
2153    ::validator::Validate,
2154)]
2155pub struct Destination3 {
2156    #[serde(rename = "NmAndLctn", skip_serializing_if = "Option::is_none")]
2157    pub nm_and_lctn: Option<Max99Text>,
2158    #[serde(rename = "Adr", skip_serializing_if = "Option::is_none")]
2159    pub adr: Option<Address2>,
2160}
2161#[derive(
2162    Debug,
2163    Default,
2164    Clone,
2165    PartialEq,
2166    ::serde::Serialize,
2167    ::serde::Deserialize,
2168    ::derive_builder::Builder,
2169    ::validator::Validate,
2170)]
2171pub struct Max100KBinary {
2172    #[validate(length(min = 1, max = 102400,), regex = "MAX_100_K_BINARY_REGEX")]
2173    pub value: String,
2174}
2175#[derive(
2176    Debug,
2177    Default,
2178    Clone,
2179    PartialEq,
2180    ::serde::Serialize,
2181    ::serde::Deserialize,
2182    ::derive_builder::Builder,
2183    ::validator::Validate,
2184)]
2185pub struct AdditionalAmounts3 {
2186    #[serde(rename = "Tp")]
2187    pub tp: Iso8583AmountTypeCode,
2188    #[serde(rename = "OthrTp", skip_serializing_if = "Option::is_none")]
2189    pub othr_tp: Option<Max35Text>,
2190    #[validate]
2191    #[serde(rename = "Amt")]
2192    pub amt: Amount17,
2193    #[serde(rename = "Desc", skip_serializing_if = "Option::is_none")]
2194    pub desc: Option<Max70Text>,
2195    #[validate(length(min = 0,))]
2196    #[serde(rename = "AddtlData", default)]
2197    pub addtl_data: Vec<AdditionalData1>,
2198}
2199#[derive(
2200    Debug,
2201    Default,
2202    Clone,
2203    PartialEq,
2204    ::serde::Serialize,
2205    ::serde::Deserialize,
2206    ::derive_builder::Builder,
2207    ::validator::Validate,
2208)]
2209pub struct EncryptedData1 {
2210    #[serde(rename = "Ctrl", skip_serializing_if = "Option::is_none")]
2211    pub ctrl: Option<Exact1HexBinaryText>,
2212    #[serde(rename = "KeySetIdr", skip_serializing_if = "Option::is_none")]
2213    pub key_set_idr: Option<Max8NumericText>,
2214    #[serde(rename = "DrvdInf", skip_serializing_if = "Option::is_none")]
2215    pub drvd_inf: Option<Max32HexBinaryText>,
2216    #[serde(rename = "Algo", skip_serializing_if = "Option::is_none")]
2217    pub algo: Option<Max2NumericText>,
2218    #[serde(rename = "KeyLngth", skip_serializing_if = "Option::is_none")]
2219    pub key_lngth: Option<Max4NumericText>,
2220    #[serde(rename = "KeyPrtcn", skip_serializing_if = "Option::is_none")]
2221    pub key_prtcn: Option<Max2NumericText>,
2222    #[serde(rename = "KeyIndx", skip_serializing_if = "Option::is_none")]
2223    pub key_indx: Option<Max5NumericText>,
2224    #[serde(rename = "PddgMtd", skip_serializing_if = "Option::is_none")]
2225    pub pddg_mtd: Option<Max2NumericText>,
2226    #[serde(rename = "NcrptdDataFrmt", skip_serializing_if = "Option::is_none")]
2227    pub ncrptd_data_frmt: Option<Max2NumericText>,
2228    #[validate(length(min = 1,))]
2229    #[serde(rename = "NcrptdDataElmt", default)]
2230    pub ncrptd_data_elmt: Vec<EncryptedDataElement1>,
2231}
2232#[derive(
2233    Debug,
2234    Default,
2235    Clone,
2236    PartialEq,
2237    ::serde::Serialize,
2238    ::serde::Deserialize,
2239    ::derive_builder::Builder,
2240    ::validator::Validate,
2241)]
2242pub struct EnvelopedData5 {
2243    #[serde(rename = "Vrsn", skip_serializing_if = "Option::is_none")]
2244    pub vrsn: Option<Number>,
2245    #[serde(rename = "OrgtrInf", skip_serializing_if = "Option::is_none")]
2246    pub orgtr_inf: Option<OriginatorInformation1>,
2247    #[validate(length(min = 1,))]
2248    #[serde(rename = "Rcpt", default)]
2249    pub rcpt: Vec<Recipient6Choice>,
2250    #[serde(rename = "NcrptdCntt", skip_serializing_if = "Option::is_none")]
2251    pub ncrptd_cntt: Option<EncryptedContent4>,
2252}
2253#[derive(
2254    Debug,
2255    Default,
2256    Clone,
2257    PartialEq,
2258    ::serde::Serialize,
2259    ::serde::Deserialize,
2260    ::derive_builder::Builder,
2261    ::validator::Validate,
2262)]
2263pub struct Max16Text {
2264    #[validate(length(min = 1, max = 16,))]
2265    #[serde(rename = "$text")]
2266    pub value: String,
2267}
2268#[derive(
2269    Debug,
2270    Default,
2271    Clone,
2272    PartialEq,
2273    ::serde::Serialize,
2274    ::serde::Deserialize,
2275    ::derive_builder::Builder,
2276    ::validator::Validate,
2277)]
2278pub struct TemporaryServicesLabor1 {
2279    #[serde(rename = "TmSheetNb", skip_serializing_if = "Option::is_none")]
2280    pub tm_sheet_nb: Option<Max35Text>,
2281    #[serde(rename = "WkEndg", skip_serializing_if = "Option::is_none")]
2282    pub wk_endg: Option<Max10NumericText>,
2283    #[validate(length(min = 0,))]
2284    #[serde(rename = "Chrg", default)]
2285    pub chrg: Vec<Amount12>,
2286}
2287#[derive(
2288    Debug,
2289    Default,
2290    Clone,
2291    PartialEq,
2292    ::serde::Serialize,
2293    ::serde::Deserialize,
2294    ::derive_builder::Builder,
2295    ::validator::Validate,
2296)]
2297pub struct ShippingData2 {
2298    #[serde(rename = "InvcNb", skip_serializing_if = "Option::is_none")]
2299    pub invc_nb: Option<Max70Text>,
2300    #[serde(rename = "InvcCreDtTm", skip_serializing_if = "Option::is_none")]
2301    pub invc_cre_dt_tm: Option<IsoDateTime>,
2302    #[serde(rename = "SvcDscrptrCd", skip_serializing_if = "Option::is_none")]
2303    pub svc_dscrptr_cd: Option<Max40Text>,
2304    #[serde(rename = "IncntivAmt", skip_serializing_if = "Option::is_none")]
2305    pub incntiv_amt: Option<ImpliedCurrencyAndAmount>,
2306    #[serde(rename = "MiscExpnss", skip_serializing_if = "Option::is_none")]
2307    pub misc_expnss: Option<ImpliedCurrencyAndAmount>,
2308    #[serde(rename = "InsrncInd", skip_serializing_if = "Option::is_none")]
2309    pub insrnc_ind: Option<TrueFalseIndicator>,
2310    #[serde(rename = "InsrncAmt", skip_serializing_if = "Option::is_none")]
2311    pub insrnc_amt: Option<ImpliedCurrencyAndAmount>,
2312    #[serde(rename = "NetAmt", skip_serializing_if = "Option::is_none")]
2313    pub net_amt: Option<ImpliedCurrencyAndAmount>,
2314    #[validate(length(min = 0,))]
2315    #[serde(rename = "Tax", default)]
2316    pub tax: Vec<Tax39>,
2317    #[serde(rename = "SummryCmmdtyId", skip_serializing_if = "Option::is_none")]
2318    pub summry_cmmdty_id: Option<Max35Text>,
2319    #[serde(rename = "NbOfPackgs", skip_serializing_if = "Option::is_none")]
2320    pub nb_of_packgs: Option<Max6NumericText>,
2321    #[validate(length(min = 0,))]
2322    #[serde(rename = "Packg", default)]
2323    pub packg: Vec<ShippingPackage2>,
2324    #[serde(rename = "AddtlData", skip_serializing_if = "Option::is_none")]
2325    pub addtl_data: Option<Max350Text>,
2326}
2327#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2328pub enum CorporateTaxType1Code {
2329    #[serde(rename = "SMBS")]
2330    Smbs,
2331    #[serde(rename = "OTHR")]
2332    Othr,
2333    #[serde(rename = "CORP")]
2334    Corp,
2335    #[default]
2336    Unknown,
2337}
2338#[derive(
2339    Debug,
2340    Default,
2341    Clone,
2342    PartialEq,
2343    ::serde::Serialize,
2344    ::serde::Deserialize,
2345    ::derive_builder::Builder,
2346    ::validator::Validate,
2347)]
2348pub struct Exact3NumericText {
2349    #[validate(regex = "EXACT_3_NUMERIC_TEXT_REGEX")]
2350    #[serde(rename = "$text")]
2351    pub value: String,
2352}
2353#[derive(
2354    Debug,
2355    Default,
2356    Clone,
2357    PartialEq,
2358    ::serde::Serialize,
2359    ::serde::Deserialize,
2360    ::derive_builder::Builder,
2361    ::validator::Validate,
2362)]
2363pub struct SupplementaryDataEnvelope1<
2364    A: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
2365> {
2366    #[validate]
2367    #[serde(flatten)]
2368    pub value: A,
2369}
2370#[derive(
2371    Debug,
2372    Default,
2373    Clone,
2374    PartialEq,
2375    ::serde::Serialize,
2376    ::serde::Deserialize,
2377    ::derive_builder::Builder,
2378    ::validator::Validate,
2379)]
2380pub struct Contact3 {
2381    #[serde(rename = "CntrlPhneNb", skip_serializing_if = "Option::is_none")]
2382    pub cntrl_phne_nb: Option<PhoneNumber>,
2383    #[serde(rename = "PrprtyPhneNb", skip_serializing_if = "Option::is_none")]
2384    pub prprty_phne_nb: Option<PhoneNumber>,
2385    #[serde(rename = "TollFreePhneNb", skip_serializing_if = "Option::is_none")]
2386    pub toll_free_phne_nb: Option<PhoneNumber>,
2387    #[serde(rename = "Email", skip_serializing_if = "Option::is_none")]
2388    pub email: Option<Max256Text>,
2389    #[serde(rename = "FaxNb", skip_serializing_if = "Option::is_none")]
2390    pub fax_nb: Option<PhoneNumber>,
2391    #[serde(rename = "URLAdr", skip_serializing_if = "Option::is_none")]
2392    pub url_adr: Option<Max256Text>,
2393    #[serde(rename = "Lang", skip_serializing_if = "Option::is_none")]
2394    pub lang: Option<LanguageCode>,
2395}
2396#[derive(
2397    Debug,
2398    Default,
2399    Clone,
2400    PartialEq,
2401    ::serde::Serialize,
2402    ::serde::Deserialize,
2403    ::derive_builder::Builder,
2404    ::validator::Validate,
2405)]
2406pub struct LoyaltyProgramme3 {
2407    #[validate(length(min = 0,))]
2408    #[serde(rename = "PrgrmmElgbltyInd", default)]
2409    pub prgrmm_elgblty_ind: Vec<TrueFalseIndicator>,
2410    #[serde(rename = "PrgrmmIssr", skip_serializing_if = "Option::is_none")]
2411    pub prgrmm_issr: Option<Max35Text>,
2412    #[serde(rename = "LltyMmb", skip_serializing_if = "Option::is_none")]
2413    pub llty_mmb: Option<LoyaltyMember2>,
2414}
2415#[derive(
2416    Debug,
2417    Default,
2418    Clone,
2419    PartialEq,
2420    ::serde::Serialize,
2421    ::serde::Deserialize,
2422    ::derive_builder::Builder,
2423    ::validator::Validate,
2424)]
2425pub struct RentalDetails2 {
2426    #[serde(rename = "RntlId", skip_serializing_if = "Option::is_none")]
2427    pub rntl_id: Option<Max70Text>,
2428    #[serde(rename = "RntlDtTm", skip_serializing_if = "Option::is_none")]
2429    pub rntl_dt_tm: Option<IsoDateTime>,
2430    #[serde(rename = "RntlStart", skip_serializing_if = "Option::is_none")]
2431    pub rntl_start: Option<ServiceStartEnd2>,
2432    #[serde(rename = "RntlRtr", skip_serializing_if = "Option::is_none")]
2433    pub rntl_rtr: Option<ServiceStartEnd2>,
2434    #[validate(length(min = 0,))]
2435    #[serde(rename = "RntlTmPrd", default)]
2436    pub rntl_tm_prd: Vec<PeriodUnit2Code>,
2437    #[serde(rename = "TmPrdUnit", skip_serializing_if = "Option::is_none")]
2438    pub tm_prd_unit: Option<Max4NumericText>,
2439    #[serde(rename = "TmPrdRate", skip_serializing_if = "Option::is_none")]
2440    pub tm_prd_rate: Option<ImpliedCurrencyAndAmount>,
2441    #[serde(rename = "Ccy", skip_serializing_if = "Option::is_none")]
2442    pub ccy: Option<Iso3NumericCurrencyCode>,
2443}
2444#[derive(
2445    Debug,
2446    Default,
2447    Clone,
2448    PartialEq,
2449    ::serde::Serialize,
2450    ::serde::Deserialize,
2451    ::derive_builder::Builder,
2452    ::validator::Validate,
2453)]
2454pub struct RiskAssessment2 {
2455    #[serde(rename = "RskAssmntNtty", skip_serializing_if = "Option::is_none")]
2456    pub rsk_assmnt_ntty: Option<PartyIdentification200>,
2457    #[serde(rename = "RskAssmntTp", skip_serializing_if = "Option::is_none")]
2458    pub rsk_assmnt_tp: Option<Max35Text>,
2459    #[serde(rename = "HghRskTx", skip_serializing_if = "Option::is_none")]
2460    pub hgh_rsk_tx: Option<TrueFalseIndicator>,
2461    #[validate(length(min = 0,))]
2462    #[serde(rename = "Rsn", default)]
2463    pub rsn: Vec<Max35Text>,
2464    #[serde(rename = "Rslt", skip_serializing_if = "Option::is_none")]
2465    pub rslt: Option<Max35Text>,
2466    #[validate(length(min = 0,))]
2467    #[serde(rename = "RskCond", default)]
2468    pub rsk_cond: Vec<AdditionalData1>,
2469    #[validate(length(min = 0,))]
2470    #[serde(rename = "AddtlRskData", default)]
2471    pub addtl_rsk_data: Vec<AdditionalRiskData1>,
2472    #[validate(length(min = 0,))]
2473    #[serde(rename = "RcmmnddActn", default)]
2474    pub rcmmndd_actn: Vec<ActionType8Code>,
2475    #[serde(rename = "OthrRcmmnddActn", skip_serializing_if = "Option::is_none")]
2476    pub othr_rcmmndd_actn: Option<Max35Text>,
2477    #[serde(rename = "RcmmnddActnDtls", skip_serializing_if = "Option::is_none")]
2478    pub rcmmndd_actn_dtls: Option<Max256Text>,
2479}
2480#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2481pub enum CarRentalServiceType2Code {
2482    #[serde(rename = "ADJM")]
2483    Adjm,
2484    #[serde(rename = "AUTH")]
2485    Auth,
2486    #[serde(rename = "BAST")]
2487    Bast,
2488    #[serde(rename = "CLEA")]
2489    Clea,
2490    #[serde(rename = "DMGS")]
2491    Dmgs,
2492    #[serde(rename = "DLVR")]
2493    Dlvr,
2494    #[serde(rename = "DPOF")]
2495    Dpof,
2496    #[serde(rename = "ENTE")]
2497    Ente,
2498    #[serde(rename = "EXTC")]
2499    Extc,
2500    #[serde(rename = "EXDY")]
2501    Exdy,
2502    #[serde(rename = "EXDI")]
2503    Exdi,
2504    #[serde(rename = "EXHR")]
2505    Exhr,
2506    #[serde(rename = "FINE")]
2507    Fine,
2508    #[serde(rename = "FUEL")]
2509    Fuel,
2510    #[serde(rename = "GARA")]
2511    Gara,
2512    #[serde(rename = "GPSY")]
2513    Gpsy,
2514    #[serde(rename = "INSU")]
2515    Insu,
2516    #[serde(rename = "LATE")]
2517    Late,
2518    #[serde(rename = "LIIN")]
2519    Liin,
2520    #[serde(rename = "LDIN")]
2521    Ldin,
2522    #[serde(rename = "MISC")]
2523    Misc,
2524    #[serde(rename = "NAVI")]
2525    Navi,
2526    #[serde(rename = "NOSH")]
2527    Nosh,
2528    #[serde(rename = "ONEW")]
2529    Onew,
2530    #[serde(rename = "OTHN")]
2531    Othn,
2532    #[serde(rename = "OTHP")]
2533    Othp,
2534    #[serde(rename = "PARK")]
2535    Park,
2536    #[serde(rename = "PRIN")]
2537    Prin,
2538    #[serde(rename = "PFIN")]
2539    Pfin,
2540    #[serde(rename = "PHON")]
2541    Phon,
2542    #[serde(rename = "REGD")]
2543    Regd,
2544    #[serde(rename = "SMOK")]
2545    Smok,
2546    #[serde(rename = "TOLL")]
2547    Toll,
2548    #[serde(rename = "TOWI")]
2549    Towi,
2550    #[default]
2551    Unknown,
2552}
2553#[derive(
2554    Debug,
2555    Default,
2556    Clone,
2557    PartialEq,
2558    ::serde::Serialize,
2559    ::serde::Deserialize,
2560    ::derive_builder::Builder,
2561    ::validator::Validate,
2562)]
2563pub struct TelecomServicesLineItem2 {
2564    #[serde(rename = "StartDtTm", skip_serializing_if = "Option::is_none")]
2565    pub start_dt_tm: Option<IsoDate>,
2566    #[serde(rename = "TmPrd", skip_serializing_if = "Option::is_none")]
2567    pub tm_prd: Option<Max35Text>,
2568    #[serde(rename = "Drtn", skip_serializing_if = "Option::is_none")]
2569    pub drtn: Option<IsoTime>,
2570    #[serde(rename = "CallFr", skip_serializing_if = "Option::is_none")]
2571    pub call_fr: Option<TelecomCallDetails2>,
2572    #[serde(rename = "CallTo", skip_serializing_if = "Option::is_none")]
2573    pub call_to: Option<TelecomCallDetails2>,
2574    #[validate(length(min = 0,))]
2575    #[serde(rename = "Chrg", default)]
2576    pub chrg: Vec<Amount20>,
2577    #[validate(length(min = 0,))]
2578    #[serde(rename = "TtlTax", default)]
2579    pub ttl_tax: Vec<Tax39>,
2580    #[serde(rename = "TtlAmt", skip_serializing_if = "Option::is_none")]
2581    pub ttl_amt: Option<ImpliedCurrencyAndAmount>,
2582    #[serde(rename = "Desc", skip_serializing_if = "Option::is_none")]
2583    pub desc: Option<Max256Text>,
2584    #[serde(rename = "AddtlData", skip_serializing_if = "Option::is_none")]
2585    pub addtl_data: Option<Max350Text>,
2586}
2587#[derive(
2588    Debug,
2589    Default,
2590    Clone,
2591    PartialEq,
2592    ::serde::Serialize,
2593    ::serde::Deserialize,
2594    ::derive_builder::Builder,
2595    ::validator::Validate,
2596)]
2597pub struct Instalment4 {
2598    #[serde(rename = "PmtSeqNb", skip_serializing_if = "Option::is_none")]
2599    pub pmt_seq_nb: Option<Number>,
2600    #[validate(length(min = 0,))]
2601    #[serde(rename = "Plan", default)]
2602    pub plan: Vec<Plan2>,
2603}
2604#[derive(
2605    Debug,
2606    Default,
2607    Clone,
2608    PartialEq,
2609    ::serde::Serialize,
2610    ::serde::Deserialize,
2611    ::derive_builder::Builder,
2612    ::validator::Validate,
2613)]
2614pub struct CardholderVerificationCapabilities1 {
2615    #[serde(rename = "Cpblty")]
2616    pub cpblty: CardholderVerificationCapability5Code,
2617    #[serde(rename = "OthrCpblty", skip_serializing_if = "Option::is_none")]
2618    pub othr_cpblty: Option<Max35Text>,
2619}
2620#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2621pub enum LocationAmenity1Code {
2622    #[serde(rename = "AADA")]
2623    Aada,
2624    #[serde(rename = "AFLA")]
2625    Afla,
2626    #[serde(rename = "AVLA")]
2627    Avla,
2628    #[serde(rename = "CRWA")]
2629    Crwa,
2630    #[serde(rename = "CVSA")]
2631    Cvsa,
2632    #[serde(rename = "DISA")]
2633    Disa,
2634    #[serde(rename = "EWAA")]
2635    Ewaa,
2636    #[serde(rename = "MRLA")]
2637    Mrla,
2638    #[serde(rename = "OTHN")]
2639    Othn,
2640    #[serde(rename = "OTHP")]
2641    Othp,
2642    #[serde(rename = "PAPA")]
2643    Papa,
2644    #[serde(rename = "TSHA")]
2645    Tsha,
2646    #[serde(rename = "TSRA")]
2647    Tsra,
2648    #[serde(rename = "TSSA")]
2649    Tssa,
2650    #[serde(rename = "TFHA")]
2651    Tfha,
2652    #[serde(rename = "VSWA")]
2653    Vswa,
2654    #[serde(rename = "VHPA")]
2655    Vhpa,
2656    #[serde(rename = "VMRA")]
2657    Vmra,
2658    #[default]
2659    Unknown,
2660}
2661#[derive(
2662    Debug,
2663    Default,
2664    Clone,
2665    PartialEq,
2666    ::serde::Serialize,
2667    ::serde::Deserialize,
2668    ::derive_builder::Builder,
2669    ::validator::Validate,
2670)]
2671pub struct TemporaryServicesJob1 {
2672    #[serde(rename = "JobCd", skip_serializing_if = "Option::is_none")]
2673    pub job_cd: Option<Max35Text>,
2674    #[serde(rename = "Desc", skip_serializing_if = "Option::is_none")]
2675    pub desc: Option<Max256Text>,
2676    #[serde(rename = "StartDt", skip_serializing_if = "Option::is_none")]
2677    pub start_dt: Option<IsoDate>,
2678    #[serde(rename = "Drtn", skip_serializing_if = "Option::is_none")]
2679    pub drtn: Option<Max5NumericText>,
2680    #[serde(rename = "EndDt", skip_serializing_if = "Option::is_none")]
2681    pub end_dt: Option<IsoDate>,
2682}
2683#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2684pub enum Algorithm5Code {
2685    #[serde(rename = "HS25")]
2686    Hs25,
2687    #[serde(rename = "HS38")]
2688    Hs38,
2689    #[serde(rename = "HS51")]
2690    Hs51,
2691    #[default]
2692    Unknown,
2693}
2694#[derive(
2695    Debug,
2696    Default,
2697    Clone,
2698    PartialEq,
2699    ::serde::Serialize,
2700    ::serde::Deserialize,
2701    ::derive_builder::Builder,
2702    ::validator::Validate,
2703)]
2704pub struct Iso18245MerchantCategoryCode {
2705    #[validate(regex = "ISO_18245_MERCHANT_CATEGORY_CODE_REGEX")]
2706    #[serde(rename = "$text")]
2707    pub value: String,
2708}
2709#[derive(
2710    Debug,
2711    Default,
2712    Clone,
2713    PartialEq,
2714    ::serde::Serialize,
2715    ::serde::Deserialize,
2716    ::derive_builder::Builder,
2717    ::validator::Validate,
2718)]
2719pub struct Exact2NumericText {
2720    #[validate(regex = "EXACT_2_NUMERIC_TEXT_REGEX")]
2721    #[serde(rename = "$text")]
2722    pub value: String,
2723}
2724#[derive(
2725    Debug,
2726    Default,
2727    Clone,
2728    PartialEq,
2729    ::serde::Serialize,
2730    ::serde::Deserialize,
2731    ::derive_builder::Builder,
2732    ::validator::Validate,
2733)]
2734pub struct EncryptedData1ChoiceEnum {
2735    #[serde(rename = "HexBinryVal", skip_serializing_if = "Option::is_none")]
2736    pub hex_binry_val: Option<Max9999HexBinaryText>,
2737    #[serde(rename = "BinryData", skip_serializing_if = "Option::is_none")]
2738    pub binry_data: Option<Max100KBinary>,
2739}
2740#[derive(
2741    Debug,
2742    Default,
2743    Clone,
2744    PartialEq,
2745    ::serde::Serialize,
2746    ::serde::Deserialize,
2747    ::derive_builder::Builder,
2748    ::validator::Validate,
2749)]
2750pub struct EncryptedData1Choice {
2751    #[serde(flatten)]
2752    pub value: EncryptedData1ChoiceEnum,
2753}
2754#[derive(
2755    Debug,
2756    Default,
2757    Clone,
2758    PartialEq,
2759    ::serde::Serialize,
2760    ::serde::Deserialize,
2761    ::derive_builder::Builder,
2762    ::validator::Validate,
2763)]
2764pub struct TransactionContext7 {
2765    #[serde(rename = "MrchntCtgyCd")]
2766    pub mrchnt_ctgy_cd: Iso18245MerchantCategoryCode,
2767    #[serde(
2768        rename = "MrchntCtgySpcfcData",
2769        skip_serializing_if = "Option::is_none"
2770    )]
2771    pub mrchnt_ctgy_spcfc_data: Option<Max35Text>,
2772    #[serde(rename = "CstmrCnsnt", skip_serializing_if = "Option::is_none")]
2773    pub cstmr_cnsnt: Option<TrueFalseIndicator>,
2774    #[serde(rename = "PINPadInprtv", skip_serializing_if = "Option::is_none")]
2775    pub pin_pad_inprtv: Option<TrueFalseIndicator>,
2776    #[serde(rename = "PINNtryBpssInd", skip_serializing_if = "Option::is_none")]
2777    pub pin_ntry_bpss_ind: Option<TrueFalseIndicator>,
2778    #[serde(rename = "ICCFllbckInd", skip_serializing_if = "Option::is_none")]
2779    pub icc_fllbck_ind: Option<TrueFalseIndicator>,
2780    #[serde(rename = "ICCFllbckRsnCd", skip_serializing_if = "Option::is_none")]
2781    pub icc_fllbck_rsn_cd: Option<IccFallbackReason1Code>,
2782    #[serde(rename = "OthrICCFllbckRsnCd", skip_serializing_if = "Option::is_none")]
2783    pub othr_icc_fllbck_rsn_cd: Option<Max35Text>,
2784    #[serde(rename = "MgntcStrpFllbckInd", skip_serializing_if = "Option::is_none")]
2785    pub mgntc_strp_fllbck_ind: Option<TrueFalseIndicator>,
2786    #[serde(rename = "LatePresntmntInd", skip_serializing_if = "Option::is_none")]
2787    pub late_presntmnt_ind: Option<TrueFalseIndicator>,
2788    #[serde(rename = "FnlAuthstnInd", skip_serializing_if = "Option::is_none")]
2789    pub fnl_authstn_ind: Option<TrueFalseIndicator>,
2790    #[serde(rename = "DfrrdDlvryInd", skip_serializing_if = "Option::is_none")]
2791    pub dfrrd_dlvry_ind: Option<TrueFalseIndicator>,
2792    #[serde(rename = "PrtlShipmntInd", skip_serializing_if = "Option::is_none")]
2793    pub prtl_shipmnt_ind: Option<TrueFalseIndicator>,
2794    #[serde(rename = "DelydChrgsInd", skip_serializing_if = "Option::is_none")]
2795    pub delyd_chrgs_ind: Option<TrueFalseIndicator>,
2796    #[serde(rename = "NoShowInd", skip_serializing_if = "Option::is_none")]
2797    pub no_show_ind: Option<TrueFalseIndicator>,
2798    #[serde(rename = "ReauthstnInd", skip_serializing_if = "Option::is_none")]
2799    pub reauthstn_ind: Option<TrueFalseIndicator>,
2800    #[serde(rename = "ReSubmissnInd", skip_serializing_if = "Option::is_none")]
2801    pub re_submissn_ind: Option<TrueFalseIndicator>,
2802    #[serde(rename = "TxInitr", skip_serializing_if = "Option::is_none")]
2803    pub tx_initr: Option<TransactionInitiator1Code>,
2804    #[serde(rename = "AuthntcnOutgInd", skip_serializing_if = "Option::is_none")]
2805    pub authntcn_outg_ind: Option<TrueFalseIndicator>,
2806    #[serde(rename = "CardPrgrmm", skip_serializing_if = "Option::is_none")]
2807    pub card_prgrmm: Option<CardProgramme2>,
2808    #[serde(rename = "Jursdctn", skip_serializing_if = "Option::is_none")]
2809    pub jursdctn: Option<Jurisdiction2>,
2810    #[serde(rename = "SttlmSvc", skip_serializing_if = "Option::is_none")]
2811    pub sttlm_svc: Option<SettlementService3>,
2812    #[serde(rename = "Rcncltn", skip_serializing_if = "Option::is_none")]
2813    pub rcncltn: Option<Reconciliation3>,
2814    #[validate(length(min = 0,))]
2815    #[serde(rename = "XchgRateInf", default)]
2816    pub xchg_rate_inf: Vec<ExchangeRateInformation2>,
2817    #[serde(rename = "CaptrDt", skip_serializing_if = "Option::is_none")]
2818    pub captr_dt: Option<IsoDate>,
2819    #[serde(rename = "DtAntcptd", skip_serializing_if = "Option::is_none")]
2820    pub dt_antcptd: Option<IsoDate>,
2821    #[validate(length(min = 0,))]
2822    #[serde(rename = "AddtlData", default)]
2823    pub addtl_data: Vec<AdditionalData1>,
2824}
2825#[derive(
2826    Debug,
2827    Default,
2828    Clone,
2829    PartialEq,
2830    ::serde::Serialize,
2831    ::serde::Deserialize,
2832    ::derive_builder::Builder,
2833    ::validator::Validate,
2834)]
2835pub struct GeographicPointInDecimalDegrees {
2836    #[validate(length(max = 27,), regex = "GEOGRAPHIC_POINT_IN_DECIMAL_DEGREES_REGEX")]
2837    #[serde(rename = "$text")]
2838    pub value: String,
2839}
2840#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2841pub enum Priority3Code {
2842    #[serde(rename = "URGT")]
2843    Urgt,
2844    #[serde(rename = "HIGH")]
2845    High,
2846    #[serde(rename = "NORM")]
2847    Norm,
2848    #[default]
2849    Unknown,
2850}
2851#[derive(
2852    Debug,
2853    Default,
2854    Clone,
2855    PartialEq,
2856    ::serde::Serialize,
2857    ::serde::Deserialize,
2858    ::derive_builder::Builder,
2859    ::validator::Validate,
2860)]
2861pub struct PartyIdentification254 {
2862    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
2863    pub id: Option<Max35Text>,
2864    #[serde(rename = "Assgnr", skip_serializing_if = "Option::is_none")]
2865    pub assgnr: Option<Max35Text>,
2866    #[serde(rename = "Ctry", skip_serializing_if = "Option::is_none")]
2867    pub ctry: Option<Iso3NumericCountryCode>,
2868    #[serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none")]
2869    pub shrt_nm: Option<Max35Text>,
2870    #[serde(rename = "LglCorpNm", skip_serializing_if = "Option::is_none")]
2871    pub lgl_corp_nm: Option<Max99Text>,
2872    #[serde(rename = "AddtlId", skip_serializing_if = "Option::is_none")]
2873    pub addtl_id: Option<Max35Text>,
2874    #[serde(rename = "NmAndLctn", skip_serializing_if = "Option::is_none")]
2875    pub nm_and_lctn: Option<Max99Text>,
2876    #[serde(rename = "Adr", skip_serializing_if = "Option::is_none")]
2877    pub adr: Option<Address2>,
2878    #[serde(rename = "AddtlAdrInf", skip_serializing_if = "Option::is_none")]
2879    pub addtl_adr_inf: Option<Max256Text>,
2880    #[serde(rename = "GeogcLctn", skip_serializing_if = "Option::is_none")]
2881    pub geogc_lctn: Option<GeographicPointInDecimalDegrees>,
2882    #[serde(rename = "Email", skip_serializing_if = "Option::is_none")]
2883    pub email: Option<Max256Text>,
2884    #[serde(rename = "URLAdr", skip_serializing_if = "Option::is_none")]
2885    pub url_adr: Option<Max256Text>,
2886    #[serde(rename = "PhneNb", skip_serializing_if = "Option::is_none")]
2887    pub phne_nb: Option<Max35Text>,
2888    #[serde(rename = "CstmrSvc", skip_serializing_if = "Option::is_none")]
2889    pub cstmr_svc: Option<Max35Text>,
2890    #[serde(rename = "AddtlCtctInf", skip_serializing_if = "Option::is_none")]
2891    pub addtl_ctct_inf: Option<Max256Text>,
2892    #[serde(rename = "TaxRegnId", skip_serializing_if = "Option::is_none")]
2893    pub tax_regn_id: Option<Max35Text>,
2894    #[validate(length(min = 0,))]
2895    #[serde(rename = "AddtlData", default)]
2896    pub addtl_data: Vec<AdditionalData1>,
2897    #[serde(rename = "LclData", skip_serializing_if = "Option::is_none")]
2898    pub lcl_data: Option<LocalData4>,
2899    #[validate(length(min = 0,))]
2900    #[serde(rename = "SpnsrdMrchnt", default)]
2901    pub spnsrd_mrchnt: Vec<SponsoredMerchant2>,
2902}
2903#[derive(
2904    Debug,
2905    Default,
2906    Clone,
2907    PartialEq,
2908    ::serde::Serialize,
2909    ::serde::Deserialize,
2910    ::derive_builder::Builder,
2911    ::validator::Validate,
2912)]
2913pub struct CardWritingCapabilities1 {
2914    #[serde(rename = "Cpblty")]
2915    pub cpblty: CardDataWriting1Code,
2916    #[serde(rename = "OthrCpblty", skip_serializing_if = "Option::is_none")]
2917    pub othr_cpblty: Option<Max35Text>,
2918}
2919#[derive(
2920    Debug,
2921    Default,
2922    Clone,
2923    PartialEq,
2924    ::serde::Serialize,
2925    ::serde::Deserialize,
2926    ::derive_builder::Builder,
2927    ::validator::Validate,
2928)]
2929pub struct Jurisdiction2 {
2930    #[serde(rename = "DmstInd", skip_serializing_if = "Option::is_none")]
2931    pub dmst_ind: Option<TrueFalseIndicator>,
2932    #[serde(rename = "DmstQlfctn", skip_serializing_if = "Option::is_none")]
2933    pub dmst_qlfctn: Option<Max35Text>,
2934}
2935#[derive(
2936    Debug,
2937    Default,
2938    Clone,
2939    PartialEq,
2940    ::serde::Serialize,
2941    ::serde::Deserialize,
2942    ::derive_builder::Builder,
2943    ::validator::Validate,
2944)]
2945pub struct Kek5 {
2946    #[serde(rename = "Vrsn", skip_serializing_if = "Option::is_none")]
2947    pub vrsn: Option<Number>,
2948    #[validate]
2949    #[serde(rename = "KEKId")]
2950    pub kek_id: KekIdentifier2,
2951    #[validate]
2952    #[serde(rename = "KeyNcrptnAlgo")]
2953    pub key_ncrptn_algo: AlgorithmIdentification23,
2954    #[validate]
2955    #[serde(rename = "NcrptdKey")]
2956    pub ncrptd_key: Max500Binary,
2957}
2958#[derive(
2959    Debug,
2960    Default,
2961    Clone,
2962    PartialEq,
2963    ::serde::Serialize,
2964    ::serde::Deserialize,
2965    ::derive_builder::Builder,
2966    ::validator::Validate,
2967)]
2968pub struct DepartureOrArrival2 {
2969    #[serde(rename = "CrrierCd", skip_serializing_if = "Option::is_none")]
2970    pub crrier_cd: Option<Max35Text>,
2971    #[serde(rename = "RouteNb", skip_serializing_if = "Option::is_none")]
2972    pub route_nb: Option<Max35NumericText>,
2973    #[serde(rename = "Dt", skip_serializing_if = "Option::is_none")]
2974    pub dt: Option<IsoDate>,
2975    #[serde(rename = "Tm", skip_serializing_if = "Option::is_none")]
2976    pub tm: Option<IsoTime>,
2977}
2978#[derive(
2979    Debug,
2980    Default,
2981    Clone,
2982    PartialEq,
2983    ::serde::Serialize,
2984    ::serde::Deserialize,
2985    ::derive_builder::Builder,
2986    ::validator::Validate,
2987)]
2988pub struct Max35NumericText {
2989    #[validate(regex = "MAX_35_NUMERIC_TEXT_REGEX")]
2990    #[serde(rename = "$text")]
2991    pub value: String,
2992}
2993#[derive(
2994    Debug,
2995    Default,
2996    Clone,
2997    PartialEq,
2998    ::serde::Serialize,
2999    ::serde::Deserialize,
3000    ::derive_builder::Builder,
3001    ::validator::Validate,
3002)]
3003pub struct BaseOne25Rate {
3004    #[serde(rename = "$text")]
3005    pub value: f64,
3006}
3007#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3008pub enum MessageFunction29Code {
3009    #[serde(rename = "ADVC")]
3010    Advc,
3011    #[serde(rename = "NOTI")]
3012    Noti,
3013    #[default]
3014    Unknown,
3015}
3016#[derive(
3017    Debug,
3018    Default,
3019    Clone,
3020    PartialEq,
3021    ::serde::Serialize,
3022    ::serde::Deserialize,
3023    ::derive_builder::Builder,
3024    ::validator::Validate,
3025)]
3026pub struct TransactionIdentification18 {
3027    #[serde(rename = "LclDt", skip_serializing_if = "Option::is_none")]
3028    pub lcl_dt: Option<IsoDate>,
3029    #[serde(rename = "LclTm", skip_serializing_if = "Option::is_none")]
3030    pub lcl_tm: Option<IsoTime>,
3031    #[serde(rename = "TmZone", skip_serializing_if = "Option::is_none")]
3032    pub tm_zone: Option<Max70Text>,
3033    #[serde(rename = "TxRef", skip_serializing_if = "Option::is_none")]
3034    pub tx_ref: Option<Max35Text>,
3035    #[serde(rename = "TrnsmssnDtTm", skip_serializing_if = "Option::is_none")]
3036    pub trnsmssn_dt_tm: Option<IsoDateTime>,
3037    #[validate]
3038    #[serde(rename = "SysTracAudtNb")]
3039    pub sys_trac_audt_nb: Max12NumericText,
3040    #[validate]
3041    #[serde(rename = "RtrvlRefNb")]
3042    pub rtrvl_ref_nb: Exact12Text,
3043    #[serde(rename = "LifeCyclSpprtInd", skip_serializing_if = "Option::is_none")]
3044    pub life_cycl_spprt_ind: Option<Exact2NumericText>,
3045    #[serde(rename = "LifeCyclTracIdData", skip_serializing_if = "Option::is_none")]
3046    pub life_cycl_trac_id_data: Option<TransactionLifeCycleIdentification1>,
3047    #[serde(
3048        rename = "LifeCyclTracIdMssng",
3049        skip_serializing_if = "Option::is_none"
3050    )]
3051    pub life_cycl_trac_id_mssng: Option<Max70Text>,
3052    #[serde(rename = "AcqrrRefData", skip_serializing_if = "Option::is_none")]
3053    pub acqrr_ref_data: Option<Max140Text>,
3054    #[serde(rename = "AcqrrRefNb", skip_serializing_if = "Option::is_none")]
3055    pub acqrr_ref_nb: Option<Max23NumericText>,
3056    #[serde(rename = "CardIssrRefData", skip_serializing_if = "Option::is_none")]
3057    pub card_issr_ref_data: Option<Max1000Text>,
3058}
3059#[derive(
3060    Debug,
3061    Default,
3062    Clone,
3063    PartialEq,
3064    ::serde::Serialize,
3065    ::serde::Deserialize,
3066    ::derive_builder::Builder,
3067    ::validator::Validate,
3068)]
3069pub struct VehicleRentalCompany2 {
3070    #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
3071    pub nm: Option<Max70Text>,
3072    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
3073    pub id: Option<PartyIdentification258>,
3074    #[serde(rename = "Adr", skip_serializing_if = "Option::is_none")]
3075    pub adr: Option<Address2>,
3076    #[serde(rename = "Ctct", skip_serializing_if = "Option::is_none")]
3077    pub ctct: Option<Contact3>,
3078    #[serde(rename = "Ctry", skip_serializing_if = "Option::is_none")]
3079    pub ctry: Option<IsoMax3ACountryCode>,
3080    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
3081    pub tp: Option<CarRentalActivity1Code>,
3082    #[serde(rename = "OthrTp", skip_serializing_if = "Option::is_none")]
3083    pub othr_tp: Option<Max35Text>,
3084}
3085#[derive(
3086    Debug,
3087    Default,
3088    Clone,
3089    PartialEq,
3090    ::serde::Serialize,
3091    ::serde::Deserialize,
3092    ::derive_builder::Builder,
3093    ::validator::Validate,
3094)]
3095pub struct Max1000Text {
3096    #[validate(length(min = 1, max = 1000,))]
3097    #[serde(rename = "$text")]
3098    pub value: String,
3099}
3100#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3101pub enum Algorithm18Code {
3102    #[serde(rename = "EA2C")]
3103    Ea2C,
3104    #[serde(rename = "E3DC")]
3105    E3Dc,
3106    #[serde(rename = "DKP9")]
3107    Dkp9,
3108    #[serde(rename = "UKPT")]
3109    Ukpt,
3110    #[serde(rename = "UKA1")]
3111    Uka1,
3112    #[serde(rename = "EA9C")]
3113    Ea9C,
3114    #[serde(rename = "EA5C")]
3115    Ea5C,
3116    #[serde(rename = "DA12")]
3117    Da12,
3118    #[serde(rename = "DA19")]
3119    Da19,
3120    #[serde(rename = "DA25")]
3121    Da25,
3122    #[serde(rename = "N108")]
3123    N108,
3124    #[serde(rename = "EA5R")]
3125    Ea5R,
3126    #[serde(rename = "EA9R")]
3127    Ea9R,
3128    #[serde(rename = "EA2R")]
3129    Ea2R,
3130    #[serde(rename = "E3DR")]
3131    E3Dr,
3132    #[serde(rename = "E36C")]
3133    E36C,
3134    #[serde(rename = "E36R")]
3135    E36R,
3136    #[serde(rename = "SD5C")]
3137    Sd5C,
3138    #[default]
3139    Unknown,
3140}
3141#[derive(
3142    Debug,
3143    Default,
3144    Clone,
3145    PartialEq,
3146    ::serde::Serialize,
3147    ::serde::Deserialize,
3148    ::derive_builder::Builder,
3149    ::validator::Validate,
3150)]
3151pub struct PartyIdentification260 {
3152    #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
3153    pub nm: Option<Max70Text>,
3154    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
3155    pub id: Option<PartyIdentification258>,
3156    #[serde(rename = "Adr", skip_serializing_if = "Option::is_none")]
3157    pub adr: Option<Address2>,
3158    #[serde(rename = "Ctct", skip_serializing_if = "Option::is_none")]
3159    pub ctct: Option<Contact6>,
3160    #[serde(rename = "Instrs", skip_serializing_if = "Option::is_none")]
3161    pub instrs: Option<Max350Text>,
3162}
3163#[derive(
3164    Debug,
3165    Default,
3166    Clone,
3167    PartialEq,
3168    ::serde::Serialize,
3169    ::serde::Deserialize,
3170    ::derive_builder::Builder,
3171    ::validator::Validate,
3172)]
3173pub struct Max76Text {
3174    #[validate(length(min = 1, max = 76,))]
3175    #[serde(rename = "$text")]
3176    pub value: String,
3177}
3178#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3179pub enum MemoryUnit1Code {
3180    #[serde(rename = "BYTE")]
3181    Byte,
3182    #[serde(rename = "EXAB")]
3183    Exab,
3184    #[serde(rename = "GIGA")]
3185    Giga,
3186    #[serde(rename = "KILO")]
3187    Kilo,
3188    #[serde(rename = "MEGA")]
3189    Mega,
3190    #[serde(rename = "PETA")]
3191    Peta,
3192    #[serde(rename = "TERA")]
3193    Tera,
3194    #[default]
3195    Unknown,
3196}
3197#[derive(
3198    Debug,
3199    Default,
3200    Clone,
3201    PartialEq,
3202    ::serde::Serialize,
3203    ::serde::Deserialize,
3204    ::derive_builder::Builder,
3205    ::validator::Validate,
3206)]
3207pub struct Exact1NumericText {
3208    #[validate(regex = "EXACT_1_NUMERIC_TEXT_REGEX")]
3209    #[serde(rename = "$text")]
3210    pub value: String,
3211}
3212#[derive(
3213    Debug,
3214    Default,
3215    Clone,
3216    PartialEq,
3217    ::serde::Serialize,
3218    ::serde::Deserialize,
3219    ::derive_builder::Builder,
3220    ::validator::Validate,
3221)]
3222pub struct ContentInformationType19 {
3223    #[serde(rename = "CnttTp")]
3224    pub cntt_tp: ContentType2Code,
3225    #[serde(rename = "EnvlpdData", skip_serializing_if = "Option::is_none")]
3226    pub envlpd_data: Option<EnvelopedData5>,
3227    #[serde(rename = "AuthntcdData", skip_serializing_if = "Option::is_none")]
3228    pub authntcd_data: Option<AuthenticatedData5>,
3229    #[serde(rename = "SgndData", skip_serializing_if = "Option::is_none")]
3230    pub sgnd_data: Option<SignedData5>,
3231    #[serde(rename = "DgstdData", skip_serializing_if = "Option::is_none")]
3232    pub dgstd_data: Option<DigestedData5>,
3233}
3234#[derive(
3235    Debug,
3236    Default,
3237    Clone,
3238    PartialEq,
3239    ::serde::Serialize,
3240    ::serde::Deserialize,
3241    ::derive_builder::Builder,
3242    ::validator::Validate,
3243)]
3244pub struct Amount20 {
3245    #[serde(rename = "TpOfChrg", skip_serializing_if = "Option::is_none")]
3246    pub tp_of_chrg: Option<TypeOfAmount19Code>,
3247    #[serde(rename = "OthrTpOfChrg", skip_serializing_if = "Option::is_none")]
3248    pub othr_tp_of_chrg: Option<Max35Text>,
3249    #[validate]
3250    #[serde(rename = "Amt")]
3251    pub amt: ImpliedCurrencyAndAmount,
3252    #[serde(rename = "CdtDbt", skip_serializing_if = "Option::is_none")]
3253    pub cdt_dbt: Option<CreditDebit3Code>,
3254}
3255#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3256pub enum ContentType2Code {
3257    #[serde(rename = "DATA")]
3258    Data,
3259    #[serde(rename = "SIGN")]
3260    Sign,
3261    #[serde(rename = "EVLP")]
3262    Evlp,
3263    #[serde(rename = "DGST")]
3264    Dgst,
3265    #[serde(rename = "AUTH")]
3266    Auth,
3267    #[default]
3268    Unknown,
3269}
3270#[derive(
3271    Debug,
3272    Default,
3273    Clone,
3274    PartialEq,
3275    ::serde::Serialize,
3276    ::serde::Deserialize,
3277    ::derive_builder::Builder,
3278    ::validator::Validate,
3279)]
3280pub struct AlgorithmIdentification24 {
3281    #[serde(rename = "Algo")]
3282    pub algo: Algorithm18Code,
3283    #[serde(rename = "Param", skip_serializing_if = "Option::is_none")]
3284    pub param: Option<Parameter12>,
3285}
3286#[derive(
3287    Debug,
3288    Default,
3289    Clone,
3290    PartialEq,
3291    ::serde::Serialize,
3292    ::serde::Deserialize,
3293    ::derive_builder::Builder,
3294    ::validator::Validate,
3295)]
3296pub struct ExchangeRateDetail1 {
3297    #[serde(rename = "EndPt", skip_serializing_if = "Option::is_none")]
3298    pub end_pt: Option<Endpoint1Code>,
3299    #[serde(rename = "OthrEndPt", skip_serializing_if = "Option::is_none")]
3300    pub othr_end_pt: Option<Max35Text>,
3301    #[serde(rename = "CntrCcyCd", skip_serializing_if = "Option::is_none")]
3302    pub cntr_ccy_cd: Option<Iso3NumericCurrencyCode>,
3303    #[serde(rename = "BaseCcyCd", skip_serializing_if = "Option::is_none")]
3304    pub base_ccy_cd: Option<Iso3NumericCurrencyCode>,
3305    #[serde(rename = "Rate", skip_serializing_if = "Option::is_none")]
3306    pub rate: Option<BaseOne25Rate>,
3307    #[serde(rename = "RateTp", skip_serializing_if = "Option::is_none")]
3308    pub rate_tp: Option<ExchangeRateType2Code>,
3309    #[serde(rename = "OthrRateTp", skip_serializing_if = "Option::is_none")]
3310    pub othr_rate_tp: Option<Max35Text>,
3311    #[serde(rename = "AgrmtTp", skip_serializing_if = "Option::is_none")]
3312    pub agrmt_tp: Option<ExchangeRateAgreementType1Code>,
3313    #[serde(rename = "OthrAgrmtTp", skip_serializing_if = "Option::is_none")]
3314    pub othr_agrmt_tp: Option<Max35Text>,
3315}
3316#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3317pub enum GoodAndServiceDeliveryChannel1Code {
3318    #[serde(rename = "EDEL")]
3319    Edel,
3320    #[serde(rename = "PULC")]
3321    Pulc,
3322    #[serde(rename = "NDEL")]
3323    Ndel,
3324    #[serde(rename = "OTHN")]
3325    Othn,
3326    #[serde(rename = "OTHP")]
3327    Othp,
3328    #[serde(rename = "SCBA")]
3329    Scba,
3330    #[serde(rename = "SCSA")]
3331    Scsa,
3332    #[default]
3333    Unknown,
3334}
3335#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3336pub enum GoodAndServiceDeliverySchedule1Code {
3337    #[serde(rename = "OTHN")]
3338    Othn,
3339    #[serde(rename = "OTHP")]
3340    Othp,
3341    #[serde(rename = "ONDL")]
3342    Ondl,
3343    #[serde(rename = "SDDL")]
3344    Sddl,
3345    #[serde(rename = "TDDL")]
3346    Tddl,
3347    #[default]
3348    Unknown,
3349}
3350#[derive(
3351    Debug,
3352    Default,
3353    Clone,
3354    PartialEq,
3355    ::serde::Serialize,
3356    ::serde::Deserialize,
3357    ::derive_builder::Builder,
3358    ::validator::Validate,
3359)]
3360pub struct PaymentTransaction141 {
3361    #[serde(rename = "PurchsTp", skip_serializing_if = "Option::is_none")]
3362    pub purchs_tp: Option<FleetPurchaseType1Code>,
3363    #[serde(rename = "SummryCmmdtyId", skip_serializing_if = "Option::is_none")]
3364    pub summry_cmmdty_id: Option<Max35Text>,
3365    #[serde(rename = "DscntTtl", skip_serializing_if = "Option::is_none")]
3366    pub dscnt_ttl: Option<FleetDiscountTotals1>,
3367    #[validate(length(min = 0,))]
3368    #[serde(rename = "TaxTtl", default)]
3369    pub tax_ttl: Vec<Tax39>,
3370    #[serde(rename = "TtlAmt", skip_serializing_if = "Option::is_none")]
3371    pub ttl_amt: Option<ImpliedCurrencyAndAmount>,
3372}
3373#[derive(
3374    Debug,
3375    Default,
3376    Clone,
3377    PartialEq,
3378    ::serde::Serialize,
3379    ::serde::Deserialize,
3380    ::derive_builder::Builder,
3381    ::validator::Validate,
3382)]
3383pub struct ExternalEncryptedElementIdentification1Code {
3384    #[validate(regex = "EXTERNAL_ENCRYPTED_ELEMENT_IDENTIFICATION_1_CODE_REGEX")]
3385    #[serde(rename = "$text")]
3386    pub value: String,
3387}
3388#[derive(
3389    Debug,
3390    Default,
3391    Clone,
3392    PartialEq,
3393    ::serde::Serialize,
3394    ::serde::Deserialize,
3395    ::derive_builder::Builder,
3396    ::validator::Validate,
3397)]
3398pub struct DepositDetails2 {
3399    #[serde(rename = "Tp")]
3400    pub tp: CardDepositType1Code,
3401    #[serde(rename = "OthrTp", skip_serializing_if = "Option::is_none")]
3402    pub othr_tp: Option<Max35Text>,
3403    #[serde(rename = "Amt", skip_serializing_if = "Option::is_none")]
3404    pub amt: Option<Amount16>,
3405}
3406#[derive(
3407    Debug,
3408    Default,
3409    Clone,
3410    PartialEq,
3411    ::serde::Serialize,
3412    ::serde::Deserialize,
3413    ::derive_builder::Builder,
3414    ::validator::Validate,
3415)]
3416pub struct Amount13 {
3417    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
3418    pub tp: Option<Max35Text>,
3419    #[serde(rename = "Desc", skip_serializing_if = "Option::is_none")]
3420    pub desc: Option<Max35Text>,
3421    #[validate]
3422    #[serde(rename = "Amt")]
3423    pub amt: ImpliedCurrencyAndAmount,
3424}
3425#[derive(
3426    Debug,
3427    Default,
3428    Clone,
3429    PartialEq,
3430    ::serde::Serialize,
3431    ::serde::Deserialize,
3432    ::derive_builder::Builder,
3433    ::validator::Validate,
3434)]
3435pub struct Max4NumericText {
3436    #[validate(regex = "MAX_4_NUMERIC_TEXT_REGEX")]
3437    #[serde(rename = "$text")]
3438    pub value: String,
3439}
3440#[derive(
3441    Debug,
3442    Default,
3443    Clone,
3444    PartialEq,
3445    ::serde::Serialize,
3446    ::serde::Deserialize,
3447    ::derive_builder::Builder,
3448    ::validator::Validate,
3449)]
3450pub struct RiskContext2 {
3451    #[validate(length(min = 0,))]
3452    #[serde(rename = "RskInptData", default)]
3453    pub rsk_inpt_data: Vec<RiskInputData1>,
3454    #[validate(length(min = 0,))]
3455    #[serde(rename = "RskAssmnt", default)]
3456    pub rsk_assmnt: Vec<RiskAssessment2>,
3457}
3458#[derive(
3459    Debug,
3460    Default,
3461    Clone,
3462    PartialEq,
3463    ::serde::Serialize,
3464    ::serde::Deserialize,
3465    ::derive_builder::Builder,
3466    ::validator::Validate,
3467)]
3468pub struct Exact12Text {
3469    #[serde(rename = "$text")]
3470    pub value: String,
3471}
3472#[derive(
3473    Debug,
3474    Default,
3475    Clone,
3476    PartialEq,
3477    ::serde::Serialize,
3478    ::serde::Deserialize,
3479    ::derive_builder::Builder,
3480    ::validator::Validate,
3481)]
3482pub struct KekIdentifier2 {
3483    #[validate]
3484    #[serde(rename = "KeyId")]
3485    pub key_id: Max140Text,
3486    #[validate]
3487    #[serde(rename = "KeyVrsn")]
3488    pub key_vrsn: Max140Text,
3489    #[serde(rename = "SeqNb", skip_serializing_if = "Option::is_none")]
3490    pub seq_nb: Option<Number>,
3491    #[serde(rename = "DerivtnId", skip_serializing_if = "Option::is_none")]
3492    pub derivtn_id: Option<Min5Max16Binary>,
3493}
3494#[derive(
3495    Debug,
3496    Default,
3497    Clone,
3498    PartialEq,
3499    ::serde::Serialize,
3500    ::serde::Deserialize,
3501    ::derive_builder::Builder,
3502    ::validator::Validate,
3503)]
3504pub struct Max23NumericText {
3505    #[validate(regex = "MAX_23_NUMERIC_TEXT_REGEX")]
3506    #[serde(rename = "$text")]
3507    pub value: String,
3508}
3509#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3510pub enum FleetServiceType1Code {
3511    #[serde(rename = "SLSV")]
3512    Slsv,
3513    #[serde(rename = "HSDI")]
3514    Hsdi,
3515    #[serde(rename = "FLSV")]
3516    Flsv,
3517    #[default]
3518    Unknown,
3519}
3520#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3521pub enum CardDepositType1Code {
3522    #[serde(rename = "OTHP")]
3523    Othp,
3524    #[serde(rename = "OTHN")]
3525    Othn,
3526    #[serde(rename = "ENVL")]
3527    Envl,
3528    #[serde(rename = "CHEC")]
3529    Chec,
3530    #[serde(rename = "CASH")]
3531    Cash,
3532    #[default]
3533    Unknown,
3534}
3535#[derive(
3536    Debug,
3537    Default,
3538    Clone,
3539    PartialEq,
3540    ::serde::Serialize,
3541    ::serde::Deserialize,
3542    ::derive_builder::Builder,
3543    ::validator::Validate,
3544)]
3545pub struct TransferService2 {
3546    #[serde(rename = "SvcPrvdr", skip_serializing_if = "Option::is_none")]
3547    pub svc_prvdr: Option<Max35Text>,
3548    #[serde(rename = "SvcNm", skip_serializing_if = "Option::is_none")]
3549    pub svc_nm: Option<Max35Text>,
3550    #[serde(rename = "Ref", skip_serializing_if = "Option::is_none")]
3551    pub r#ref: Option<Max35Text>,
3552    #[serde(rename = "BizPurp", skip_serializing_if = "Option::is_none")]
3553    pub biz_purp: Option<Max500Text>,
3554    #[serde(rename = "Desc", skip_serializing_if = "Option::is_none")]
3555    pub desc: Option<Max256Text>,
3556}
3557#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3558pub enum Verification3Code {
3559    #[serde(rename = "FAIL")]
3560    Fail,
3561    #[serde(rename = "FUTA")]
3562    Futa,
3563    #[serde(rename = "MISS")]
3564    Miss,
3565    #[serde(rename = "NOSP")]
3566    Nosp,
3567    #[serde(rename = "NOVF")]
3568    Novf,
3569    #[serde(rename = "OTHN")]
3570    Othn,
3571    #[serde(rename = "OTHP")]
3572    Othp,
3573    #[serde(rename = "PART")]
3574    Part,
3575    #[serde(rename = "SUCC")]
3576    Succ,
3577    #[serde(rename = "ERRR")]
3578    Errr,
3579    #[default]
3580    Unknown,
3581}
3582#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3583pub enum TaxReclaimMethod1Code {
3584    #[serde(rename = "INPP")]
3585    Inpp,
3586    #[serde(rename = "INPS")]
3587    Inps,
3588    #[serde(rename = "INSU")]
3589    Insu,
3590    #[serde(rename = "OTHR")]
3591    Othr,
3592    #[default]
3593    Unknown,
3594}
3595#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3596pub enum TelephonyCallType1Code {
3597    #[serde(rename = "VCML")]
3598    Vcml,
3599    #[serde(rename = "TFPC")]
3600    Tfpc,
3601    #[serde(rename = "PAGE")]
3602    Page,
3603    #[serde(rename = "OGPC")]
3604    Ogpc,
3605    #[serde(rename = "OTHP")]
3606    Othp,
3607    #[serde(rename = "OTHN")]
3608    Othn,
3609    #[serde(rename = "OTCL")]
3610    Otcl,
3611    #[serde(rename = "ICPC")]
3612    Icpc,
3613    #[default]
3614    Unknown,
3615}
3616#[derive(
3617    Debug,
3618    Default,
3619    Clone,
3620    PartialEq,
3621    ::serde::Serialize,
3622    ::serde::Deserialize,
3623    ::derive_builder::Builder,
3624    ::validator::Validate,
3625)]
3626pub struct DrivingLicense2 {
3627    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
3628    pub tp: Option<Max70Text>,
3629    #[serde(rename = "Form", skip_serializing_if = "Option::is_none")]
3630    pub form: Option<PresentationMedium2Code>,
3631    #[validate]
3632    #[serde(rename = "Id")]
3633    pub id: Max70Text,
3634    #[serde(rename = "Assgnr", skip_serializing_if = "Option::is_none")]
3635    pub assgnr: Option<LegalStructure1Code>,
3636    #[serde(rename = "IssncDt", skip_serializing_if = "Option::is_none")]
3637    pub issnc_dt: Option<IsoDate>,
3638    #[serde(rename = "XprtnDt", skip_serializing_if = "Option::is_none")]
3639    pub xprtn_dt: Option<IsoDate>,
3640    #[serde(rename = "Ctry", skip_serializing_if = "Option::is_none")]
3641    pub ctry: Option<IsoMax3ACountryCode>,
3642    #[serde(rename = "Stat", skip_serializing_if = "Option::is_none")]
3643    pub stat: Option<Max16Text>,
3644    #[serde(rename = "Prvc", skip_serializing_if = "Option::is_none")]
3645    pub prvc: Option<Max16Text>,
3646    #[serde(rename = "OthrAuthrty", skip_serializing_if = "Option::is_none")]
3647    pub othr_authrty: Option<Max16Text>,
3648}
3649#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3650pub enum TransportType1Code {
3651    #[serde(rename = "AIRR")]
3652    Airr,
3653    #[serde(rename = "BUSS")]
3654    Buss,
3655    #[serde(rename = "OTHN")]
3656    Othn,
3657    #[serde(rename = "OTHP")]
3658    Othp,
3659    #[serde(rename = "RAIL")]
3660    Rail,
3661    #[serde(rename = "SHIP")]
3662    Ship,
3663    #[default]
3664    Unknown,
3665}
3666#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3667pub enum Algorithm23Code {
3668    #[serde(rename = "EA2C")]
3669    Ea2C,
3670    #[serde(rename = "E3DC")]
3671    E3Dc,
3672    #[serde(rename = "EA9C")]
3673    Ea9C,
3674    #[serde(rename = "EA5C")]
3675    Ea5C,
3676    #[serde(rename = "EA2R")]
3677    Ea2R,
3678    #[serde(rename = "EA9R")]
3679    Ea9R,
3680    #[serde(rename = "EA5R")]
3681    Ea5R,
3682    #[serde(rename = "E3DR")]
3683    E3Dr,
3684    #[serde(rename = "E36C")]
3685    E36C,
3686    #[serde(rename = "E36R")]
3687    E36R,
3688    #[serde(rename = "SD5C")]
3689    Sd5C,
3690    #[default]
3691    Unknown,
3692}
3693#[derive(
3694    Debug,
3695    Default,
3696    Clone,
3697    PartialEq,
3698    ::serde::Serialize,
3699    ::serde::Deserialize,
3700    ::derive_builder::Builder,
3701    ::validator::Validate,
3702)]
3703pub struct VerificationInformation1 {
3704    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
3705    pub tp: Option<Max35Text>,
3706    #[serde(rename = "Val", skip_serializing_if = "Option::is_none")]
3707    pub val: Option<VerificationValue1Choice>,
3708    #[validate(length(min = 0,))]
3709    #[serde(rename = "Rsn", default)]
3710    pub rsn: Vec<Max35Text>,
3711    #[serde(rename = "DtTm", skip_serializing_if = "Option::is_none")]
3712    pub dt_tm: Option<IsoDateTime>,
3713    #[serde(rename = "VldtyEndDt", skip_serializing_if = "Option::is_none")]
3714    pub vldty_end_dt: Option<IsoDate>,
3715    #[serde(rename = "VldtyEndTm", skip_serializing_if = "Option::is_none")]
3716    pub vldty_end_tm: Option<IsoTime>,
3717}
3718#[derive(
3719    Debug,
3720    Default,
3721    Clone,
3722    PartialEq,
3723    ::serde::Serialize,
3724    ::serde::Deserialize,
3725    ::derive_builder::Builder,
3726    ::validator::Validate,
3727)]
3728pub struct RelativeDistinguishedName1 {
3729    #[serde(rename = "AttrTp")]
3730    pub attr_tp: AttributeType1Code,
3731    #[validate]
3732    #[serde(rename = "AttrVal")]
3733    pub attr_val: Max140Text,
3734}
3735#[derive(
3736    Debug,
3737    Default,
3738    Clone,
3739    PartialEq,
3740    ::serde::Serialize,
3741    ::serde::Deserialize,
3742    ::derive_builder::Builder,
3743    ::validator::Validate,
3744)]
3745pub struct Invoice2 {
3746    #[serde(rename = "Summry", skip_serializing_if = "Option::is_none")]
3747    pub summry: Option<InvoiceSummary2>,
3748    #[validate(length(min = 0,))]
3749    #[serde(rename = "LineItm", default)]
3750    pub line_itm: Vec<InvoiceLineItem2>,
3751}
3752#[derive(
3753    Debug,
3754    Default,
3755    Clone,
3756    PartialEq,
3757    ::serde::Serialize,
3758    ::serde::Deserialize,
3759    ::derive_builder::Builder,
3760    ::validator::Validate,
3761)]
3762pub struct Verification5 {
3763    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
3764    pub tp: Option<ExternalAuthenticationMethod1Code>,
3765    #[serde(rename = "OthrTp", skip_serializing_if = "Option::is_none")]
3766    pub othr_tp: Option<Max35Text>,
3767    #[serde(rename = "SubTp", skip_serializing_if = "Option::is_none")]
3768    pub sub_tp: Option<Max35Text>,
3769    #[validate(length(min = 0,))]
3770    #[serde(rename = "VrfctnInf", default)]
3771    pub vrfctn_inf: Vec<VerificationInformation1>,
3772    #[validate(length(min = 0,))]
3773    #[serde(rename = "VrfctnRslt", default)]
3774    pub vrfctn_rslt: Vec<VerificationResult2>,
3775}
3776#[derive(
3777    Debug,
3778    Default,
3779    Clone,
3780    PartialEq,
3781    ::serde::Serialize,
3782    ::serde::Deserialize,
3783    ::derive_builder::Builder,
3784    ::validator::Validate,
3785)]
3786pub struct DisplayCapabilities6 {
3787    #[serde(rename = "Dstn")]
3788    pub dstn: UserInterface1Code,
3789    #[validate(length(min = 0,))]
3790    #[serde(rename = "AvlblFrmt", default)]
3791    pub avlbl_frmt: Vec<OutputFormat1Code>,
3792    #[serde(rename = "NbOfLines", skip_serializing_if = "Option::is_none")]
3793    pub nb_of_lines: Option<Number>,
3794    #[serde(rename = "LineWidth", skip_serializing_if = "Option::is_none")]
3795    pub line_width: Option<Number>,
3796    #[validate(length(min = 0,))]
3797    #[serde(rename = "AvlblLang", default)]
3798    pub avlbl_lang: Vec<LanguageCode>,
3799}
3800#[derive(
3801    Debug,
3802    Default,
3803    Clone,
3804    PartialEq,
3805    ::serde::Serialize,
3806    ::serde::Deserialize,
3807    ::derive_builder::Builder,
3808    ::validator::Validate,
3809)]
3810pub struct Amount16 {
3811    #[validate]
3812    #[serde(rename = "Amt")]
3813    pub amt: ImpliedCurrencyAndAmount,
3814    #[serde(rename = "CdtDbt", skip_serializing_if = "Option::is_none")]
3815    pub cdt_dbt: Option<CreditDebit3Code>,
3816}
3817#[derive(
3818    Debug,
3819    Default,
3820    Clone,
3821    PartialEq,
3822    ::serde::Serialize,
3823    ::serde::Deserialize,
3824    ::derive_builder::Builder,
3825    ::validator::Validate,
3826)]
3827pub struct Min2Max3NumericText {
3828    #[validate(regex = "MIN_2_MAX_3_NUMERIC_TEXT_REGEX")]
3829    #[serde(rename = "$text")]
3830    pub value: String,
3831}
3832#[derive(
3833    Debug,
3834    Default,
3835    Clone,
3836    PartialEq,
3837    ::serde::Serialize,
3838    ::serde::Deserialize,
3839    ::derive_builder::Builder,
3840    ::validator::Validate,
3841)]
3842pub struct DeviceOperatingSystem1 {
3843    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
3844    pub id: Option<Max70Text>,
3845    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
3846    pub tp: Option<DeviceOperatingSystemType1Code>,
3847    #[serde(rename = "OthrTp", skip_serializing_if = "Option::is_none")]
3848    pub othr_tp: Option<Max35Text>,
3849    #[serde(rename = "Vrsn", skip_serializing_if = "Option::is_none")]
3850    pub vrsn: Option<Max35Text>,
3851    #[serde(rename = "Bld", skip_serializing_if = "Option::is_none")]
3852    pub bld: Option<Max70Text>,
3853}
3854#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3855pub enum Identification3Code {
3856    #[serde(rename = "DRID")]
3857    Drid,
3858    #[serde(rename = "NTID")]
3859    Ntid,
3860    #[serde(rename = "PASS")]
3861    Pass,
3862    #[serde(rename = "SSYN")]
3863    Ssyn,
3864    #[serde(rename = "ARNB")]
3865    Arnb,
3866    #[serde(rename = "OTHP")]
3867    Othp,
3868    #[serde(rename = "OTHN")]
3869    Othn,
3870    #[serde(rename = "EMAL")]
3871    Emal,
3872    #[serde(rename = "PHNB")]
3873    Phnb,
3874    #[serde(rename = "CUID")]
3875    Cuid,
3876    #[serde(rename = "TXID")]
3877    Txid,
3878    #[serde(rename = "PRXY")]
3879    Prxy,
3880    #[default]
3881    Unknown,
3882}
3883#[derive(
3884    Debug,
3885    Default,
3886    Clone,
3887    PartialEq,
3888    ::serde::Serialize,
3889    ::serde::Deserialize,
3890    ::derive_builder::Builder,
3891    ::validator::Validate,
3892)]
3893pub struct OriginalTransaction2 {
3894    #[serde(rename = "Envt", skip_serializing_if = "Option::is_none")]
3895    pub envt: Option<Environment20>,
3896    #[serde(rename = "Cntxt", skip_serializing_if = "Option::is_none")]
3897    pub cntxt: Option<Context12>,
3898    #[serde(rename = "Tx", skip_serializing_if = "Option::is_none")]
3899    pub tx: Option<Transaction147>,
3900    #[serde(rename = "PrcgRslt", skip_serializing_if = "Option::is_none")]
3901    pub prcg_rslt: Option<ProcessingResult10>,
3902}
3903#[derive(
3904    Debug,
3905    Default,
3906    Clone,
3907    PartialEq,
3908    ::serde::Serialize,
3909    ::serde::Deserialize,
3910    ::derive_builder::Builder,
3911    ::validator::Validate,
3912)]
3913pub struct LocalData4 {
3914    #[serde(rename = "Lang")]
3915    pub lang: IsoMax3ALanguageCode,
3916    #[serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none")]
3917    pub shrt_nm: Option<Max70Text>,
3918    #[serde(rename = "LglCorpNm", skip_serializing_if = "Option::is_none")]
3919    pub lgl_corp_nm: Option<Max210Text>,
3920    #[serde(rename = "NmAndLctn", skip_serializing_if = "Option::is_none")]
3921    pub nm_and_lctn: Option<Max200Text>,
3922    #[serde(rename = "Adr", skip_serializing_if = "Option::is_none")]
3923    pub adr: Option<Address3>,
3924    #[serde(rename = "AddtlAdrInf", skip_serializing_if = "Option::is_none")]
3925    pub addtl_adr_inf: Option<Max512Text>,
3926    #[serde(rename = "AddtlCtctInf", skip_serializing_if = "Option::is_none")]
3927    pub addtl_ctct_inf: Option<Max512Text>,
3928    #[validate(length(min = 0,))]
3929    #[serde(rename = "AddtlData", default)]
3930    pub addtl_data: Vec<AdditionalData1>,
3931}
3932#[derive(
3933    Debug,
3934    Default,
3935    Clone,
3936    PartialEq,
3937    ::serde::Serialize,
3938    ::serde::Deserialize,
3939    ::derive_builder::Builder,
3940    ::validator::Validate,
3941)]
3942pub struct Max16HexBinaryText {
3943    #[validate(regex = "MAX_16_HEX_BINARY_TEXT_REGEX")]
3944    #[serde(rename = "$text")]
3945    pub value: String,
3946}
3947#[derive(
3948    Debug,
3949    Default,
3950    Clone,
3951    PartialEq,
3952    ::serde::Serialize,
3953    ::serde::Deserialize,
3954    ::derive_builder::Builder,
3955    ::validator::Validate,
3956)]
3957pub struct Plan2 {
3958    #[serde(rename = "PlanId", skip_serializing_if = "Option::is_none")]
3959    pub plan_id: Option<Max70Text>,
3960    #[serde(rename = "PlanOwnr", skip_serializing_if = "Option::is_none")]
3961    pub plan_ownr: Option<PlanOwner1Code>,
3962    #[serde(rename = "OthrPlanOwnr", skip_serializing_if = "Option::is_none")]
3963    pub othr_plan_ownr: Option<Max35Text>,
3964    #[serde(rename = "InstlmtPmtTp", skip_serializing_if = "Option::is_none")]
3965    pub instlmt_pmt_tp: Option<Max35Text>,
3966    #[serde(rename = "DfrrdInstlmtInd", skip_serializing_if = "Option::is_none")]
3967    pub dfrrd_instlmt_ind: Option<TrueFalseIndicator>,
3968    #[serde(rename = "PrdUnit", skip_serializing_if = "Option::is_none")]
3969    pub prd_unit: Option<Frequency18Code>,
3970    #[serde(rename = "NbOfPrds", skip_serializing_if = "Option::is_none")]
3971    pub nb_of_prds: Option<Number>,
3972    #[validate(length(min = 0,))]
3973    #[serde(rename = "IntrstRate", default)]
3974    pub intrst_rate: Vec<InterestRateDetails2>,
3975    #[serde(rename = "FrstPmtDt", skip_serializing_if = "Option::is_none")]
3976    pub frst_pmt_dt: Option<IsoDate>,
3977    #[serde(rename = "FrstAmt", skip_serializing_if = "Option::is_none")]
3978    pub frst_amt: Option<ImpliedCurrencyAndAmount>,
3979    #[serde(rename = "NrmlPmtAmt", skip_serializing_if = "Option::is_none")]
3980    pub nrml_pmt_amt: Option<ImpliedCurrencyAndAmount>,
3981    #[serde(rename = "TtlNbOfPmts", skip_serializing_if = "Option::is_none")]
3982    pub ttl_nb_of_pmts: Option<Number>,
3983    #[serde(rename = "InstlmtCcy", skip_serializing_if = "Option::is_none")]
3984    pub instlmt_ccy: Option<Iso3NumericCurrencyCode>,
3985    #[serde(rename = "GracePrd", skip_serializing_if = "Option::is_none")]
3986    pub grace_prd: Option<GracePeriod2>,
3987    #[validate(length(min = 0,))]
3988    #[serde(rename = "AmtDtls", default)]
3989    pub amt_dtls: Vec<InstalmentAmountDetails2>,
3990    #[serde(rename = "GrdTtlAmt", skip_serializing_if = "Option::is_none")]
3991    pub grd_ttl_amt: Option<ImpliedCurrencyAndAmount>,
3992    #[validate(length(min = 0,))]
3993    #[serde(rename = "AddtlData", default)]
3994    pub addtl_data: Vec<AdditionalData1>,
3995}
3996#[derive(
3997    Debug,
3998    Default,
3999    Clone,
4000    PartialEq,
4001    ::serde::Serialize,
4002    ::serde::Deserialize,
4003    ::derive_builder::Builder,
4004    ::validator::Validate,
4005)]
4006pub struct PointOfInteractionComponentStatus3 {
4007    #[serde(rename = "VrsnNb", skip_serializing_if = "Option::is_none")]
4008    pub vrsn_nb: Option<Max256Text>,
4009    #[serde(rename = "Sts", skip_serializing_if = "Option::is_none")]
4010    pub sts: Option<PoiComponentStatus1Code>,
4011    #[serde(rename = "XpryDt", skip_serializing_if = "Option::is_none")]
4012    pub xpry_dt: Option<IsoDate>,
4013}
4014#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
4015pub enum LodgingActivity1Code {
4016    #[serde(rename = "APTM")]
4017    Aptm,
4018    #[serde(rename = "BEBR")]
4019    Bebr,
4020    #[serde(rename = "COTT")]
4021    Cott,
4022    #[serde(rename = "CRUI")]
4023    Crui,
4024    #[serde(rename = "HOME")]
4025    Home,
4026    #[serde(rename = "HOST")]
4027    Host,
4028    #[serde(rename = "HOTL")]
4029    Hotl,
4030    #[serde(rename = "LODG")]
4031    Lodg,
4032    #[serde(rename = "MOTL")]
4033    Motl,
4034    #[serde(rename = "OTHN")]
4035    Othn,
4036    #[serde(rename = "OTHP")]
4037    Othp,
4038    #[serde(rename = "RESO")]
4039    Reso,
4040    #[serde(rename = "ROAB")]
4041    Roab,
4042    #[serde(rename = "TOSH")]
4043    Tosh,
4044    #[default]
4045    Unknown,
4046}
4047#[derive(
4048    Debug,
4049    Default,
4050    Clone,
4051    PartialEq,
4052    ::serde::Serialize,
4053    ::serde::Deserialize,
4054    ::derive_builder::Builder,
4055    ::validator::Validate,
4056)]
4057pub struct AdditionalAcceptorData1 {
4058    #[serde(rename = "AddtlTxRefNb", skip_serializing_if = "Option::is_none")]
4059    pub addtl_tx_ref_nb: Option<Max70Text>,
4060    #[serde(rename = "TaxRegnId", skip_serializing_if = "Option::is_none")]
4061    pub tax_regn_id: Option<Max70Text>,
4062    #[serde(rename = "CorpTaxId", skip_serializing_if = "Option::is_none")]
4063    pub corp_tax_id: Option<Max35Text>,
4064    #[serde(rename = "CorpTaxIdTp", skip_serializing_if = "Option::is_none")]
4065    pub corp_tax_id_tp: Option<CorporateTaxType1Code>,
4066    #[validate(length(min = 0,))]
4067    #[serde(rename = "AddtlId", default)]
4068    pub addtl_id: Vec<AdditionalIdentification1>,
4069    #[serde(rename = "Chrtcs", skip_serializing_if = "Option::is_none")]
4070    pub chrtcs: Option<AdditionalCharacteristics1>,
4071    #[serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none")]
4072    pub addtl_inf: Option<Max350Text>,
4073}
4074#[derive(
4075    Debug,
4076    Default,
4077    Clone,
4078    PartialEq,
4079    ::serde::Serialize,
4080    ::serde::Deserialize,
4081    ::derive_builder::Builder,
4082    ::validator::Validate,
4083)]
4084pub struct TravelDocument2 {
4085    #[serde(rename = "Tp")]
4086    pub tp: OfficialDocumentType1Code,
4087    #[serde(rename = "Form", skip_serializing_if = "Option::is_none")]
4088    pub form: Option<PresentationMedium2Code>,
4089    #[validate]
4090    #[serde(rename = "Id")]
4091    pub id: Max70Text,
4092    #[serde(rename = "Assgnr", skip_serializing_if = "Option::is_none")]
4093    pub assgnr: Option<Max70Text>,
4094    #[serde(rename = "IssncDt", skip_serializing_if = "Option::is_none")]
4095    pub issnc_dt: Option<IsoDate>,
4096    #[serde(rename = "XprtnDt", skip_serializing_if = "Option::is_none")]
4097    pub xprtn_dt: Option<IsoDate>,
4098    #[serde(rename = "Ctry", skip_serializing_if = "Option::is_none")]
4099    pub ctry: Option<IsoMax3ACountryCode>,
4100}
4101#[derive(
4102    Debug,
4103    Default,
4104    Clone,
4105    PartialEq,
4106    ::serde::Serialize,
4107    ::serde::Deserialize,
4108    ::derive_builder::Builder,
4109    ::validator::Validate,
4110)]
4111pub struct TelecomCallDetails2 {
4112    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
4113    pub tp: Option<TelephonyCallType1Code>,
4114    #[serde(rename = "OthrTp", skip_serializing_if = "Option::is_none")]
4115    pub othr_tp: Option<Max70Text>,
4116    #[serde(rename = "PhneNb", skip_serializing_if = "Option::is_none")]
4117    pub phne_nb: Option<PhoneNumber>,
4118    #[serde(rename = "City", skip_serializing_if = "Option::is_none")]
4119    pub city: Option<Max35Text>,
4120    #[serde(rename = "Stat", skip_serializing_if = "Option::is_none")]
4121    pub stat: Option<Max16Text>,
4122    #[serde(rename = "Prvc", skip_serializing_if = "Option::is_none")]
4123    pub prvc: Option<Max35Text>,
4124    #[serde(rename = "Ctry", skip_serializing_if = "Option::is_none")]
4125    pub ctry: Option<IsoMax3ACountryCode>,
4126}
4127#[derive(
4128    Debug,
4129    Default,
4130    Clone,
4131    PartialEq,
4132    ::serde::Serialize,
4133    ::serde::Deserialize,
4134    ::derive_builder::Builder,
4135    ::validator::Validate,
4136)]
4137pub struct Kek6 {
4138    #[serde(rename = "Vrsn", skip_serializing_if = "Option::is_none")]
4139    pub vrsn: Option<Number>,
4140    #[validate]
4141    #[serde(rename = "KEKId")]
4142    pub kek_id: KekIdentifier6,
4143    #[validate]
4144    #[serde(rename = "KeyNcrptnAlgo")]
4145    pub key_ncrptn_algo: AlgorithmIdentification28,
4146    #[serde(rename = "NcrptdKey", skip_serializing_if = "Option::is_none")]
4147    pub ncrptd_key: Option<Max500Binary>,
4148}
4149#[derive(
4150    Debug,
4151    Default,
4152    Clone,
4153    PartialEq,
4154    ::serde::Serialize,
4155    ::serde::Deserialize,
4156    ::derive_builder::Builder,
4157    ::validator::Validate,
4158)]
4159pub struct IsoDateTime {
4160    #[serde(rename = "$text")]
4161    pub value: ::chrono::DateTime<::chrono::Utc>,
4162}
4163#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
4164pub enum TypeOfAmount20Code {
4165    #[serde(rename = "AMTH")]
4166    Amth,
4167    #[serde(rename = "BAGG")]
4168    Bagg,
4169    #[serde(rename = "CARG")]
4170    Carg,
4171    #[serde(rename = "CHTC")]
4172    Chtc,
4173    #[serde(rename = "CLUB")]
4174    Club,
4175    #[serde(rename = "DUTY")]
4176    Duty,
4177    #[serde(rename = "EXTK")]
4178    Extk,
4179    #[serde(rename = "EXTF")]
4180    Extf,
4181    #[serde(rename = "EXTR")]
4182    Extr,
4183    #[serde(rename = "FARE")]
4184    Fare,
4185    #[serde(rename = "FDBV")]
4186    Fdbv,
4187    #[serde(rename = "INSU")]
4188    Insu,
4189    #[serde(rename = "MISC")]
4190    Misc,
4191    #[serde(rename = "OTHN")]
4192    Othn,
4193    #[serde(rename = "OTHP")]
4194    Othp,
4195    #[serde(rename = "PETC")]
4196    Petc,
4197    #[serde(rename = "PHNE")]
4198    Phne,
4199    #[serde(rename = "PRPY")]
4200    Prpy,
4201    #[serde(rename = "TOTL")]
4202    Totl,
4203    #[serde(rename = "TOUR")]
4204    Tour,
4205    #[serde(rename = "UPGD")]
4206    Upgd,
4207    #[serde(rename = "TKDL")]
4208    Tkdl,
4209    #[default]
4210    Unknown,
4211}
4212#[derive(
4213    Debug,
4214    Default,
4215    Clone,
4216    PartialEq,
4217    ::serde::Serialize,
4218    ::serde::Deserialize,
4219    ::derive_builder::Builder,
4220    ::validator::Validate,
4221)]
4222pub struct ECommerceData1 {
4223    #[validate]
4224    #[serde(rename = "Tp")]
4225    pub tp: Max35Text,
4226    #[validate]
4227    #[serde(rename = "Val")]
4228    pub val: Max2048Text,
4229}
4230#[derive(
4231    Debug,
4232    Default,
4233    Clone,
4234    PartialEq,
4235    ::serde::Serialize,
4236    ::serde::Deserialize,
4237    ::derive_builder::Builder,
4238    ::validator::Validate,
4239)]
4240pub struct Amount18 {
4241    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
4242    pub tp: Option<CarRentalServiceType2Code>,
4243    #[serde(rename = "OthrTp", skip_serializing_if = "Option::is_none")]
4244    pub othr_tp: Option<Max35Text>,
4245    #[serde(rename = "Amt", skip_serializing_if = "Option::is_none")]
4246    pub amt: Option<ImpliedCurrencyAndAmount>,
4247    #[serde(rename = "CdtDbt", skip_serializing_if = "Option::is_none")]
4248    pub cdt_dbt: Option<CreditDebit3Code>,
4249    #[serde(rename = "CstmrNtfdInd", skip_serializing_if = "Option::is_none")]
4250    pub cstmr_ntfd_ind: Option<TrueFalseIndicator>,
4251}
4252#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
4253pub enum GoodsAndServicesSubType1Code {
4254    #[serde(rename = "CRCU")]
4255    Crcu,
4256    #[serde(rename = "FORX")]
4257    Forx,
4258    #[serde(rename = "OTHN")]
4259    Othn,
4260    #[serde(rename = "OTHP")]
4261    Othp,
4262    #[serde(rename = "SECS")]
4263    Secs,
4264    #[default]
4265    Unknown,
4266}
4267#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
4268pub enum OnLineCapability2Code {
4269    #[serde(rename = "OFLN")]
4270    Ofln,
4271    #[serde(rename = "ONLN")]
4272    Onln,
4273    #[serde(rename = "BOTH")]
4274    Both,
4275    #[default]
4276    Unknown,
4277}
4278#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
4279pub enum PresentationMedium2Code {
4280    #[serde(rename = "BIOM")]
4281    Biom,
4282    #[serde(rename = "ELEC")]
4283    Elec,
4284    #[serde(rename = "PAPR")]
4285    Papr,
4286    #[serde(rename = "BOTH")]
4287    Both,
4288    #[default]
4289    Unknown,
4290}
4291#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
4292pub enum CustomerAssigner1Code {
4293    #[serde(rename = "AUTH")]
4294    Auth,
4295    #[serde(rename = "CRCY")]
4296    Crcy,
4297    #[serde(rename = "CUST")]
4298    Cust,
4299    #[serde(rename = "ONFL")]
4300    Onfl,
4301    #[serde(rename = "OTHR")]
4302    Othr,
4303    #[serde(rename = "TRAY")]
4304    Tray,
4305    #[default]
4306    Unknown,
4307}
4308#[derive(
4309    Debug,
4310    Default,
4311    Clone,
4312    PartialEq,
4313    ::serde::Serialize,
4314    ::serde::Deserialize,
4315    ::derive_builder::Builder,
4316    ::validator::Validate,
4317)]
4318pub struct ApprovalEntity2 {
4319    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
4320    pub id: Option<Max35Text>,
4321    #[serde(rename = "Tp")]
4322    pub tp: PartyType26Code,
4323    #[serde(rename = "OthrTp", skip_serializing_if = "Option::is_none")]
4324    pub othr_tp: Option<Max35Text>,
4325    #[serde(rename = "Assgnr", skip_serializing_if = "Option::is_none")]
4326    pub assgnr: Option<PartyType9Code>,
4327    #[serde(rename = "Ctry", skip_serializing_if = "Option::is_none")]
4328    pub ctry: Option<IsoMax3ACountryCode>,
4329    #[serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none")]
4330    pub shrt_nm: Option<Max35Text>,
4331}
4332#[derive(
4333    Debug,
4334    Default,
4335    Clone,
4336    PartialEq,
4337    ::serde::Serialize,
4338    ::serde::Deserialize,
4339    ::derive_builder::Builder,
4340    ::validator::Validate,
4341)]
4342pub struct TransactionAmounts2 {
4343    #[serde(rename = "AmtQlfr", skip_serializing_if = "Option::is_none")]
4344    pub amt_qlfr: Option<TypeOfAmount22Code>,
4345    #[validate]
4346    #[serde(rename = "TxAmt")]
4347    pub tx_amt: TransactionAmount1,
4348    #[serde(rename = "CrdhldrBllgAmt", skip_serializing_if = "Option::is_none")]
4349    pub crdhldr_bllg_amt: Option<Amount15>,
4350    #[serde(rename = "RcncltnAmt", skip_serializing_if = "Option::is_none")]
4351    pub rcncltn_amt: Option<Amount15>,
4352    #[validate(length(min = 0,))]
4353    #[serde(rename = "DtldAmt", default)]
4354    pub dtld_amt: Vec<DetailedAmount22>,
4355    #[serde(rename = "OrgnlTxAmts", skip_serializing_if = "Option::is_none")]
4356    pub orgnl_tx_amts: Option<OriginalTransactionAmount2>,
4357}
4358#[derive(
4359    Debug,
4360    Default,
4361    Clone,
4362    PartialEq,
4363    ::serde::Serialize,
4364    ::serde::Deserialize,
4365    ::derive_builder::Builder,
4366    ::validator::Validate,
4367)]
4368pub struct TransactionIdentification12 {
4369    #[validate]
4370    #[serde(rename = "SysTracAudtNb")]
4371    pub sys_trac_audt_nb: Max12NumericText,
4372    #[validate]
4373    #[serde(rename = "TrnsmssnDtTm")]
4374    pub trnsmssn_dt_tm: IsoDateTime,
4375    #[serde(rename = "RtrvlRefNb", skip_serializing_if = "Option::is_none")]
4376    pub rtrvl_ref_nb: Option<Exact12Text>,
4377    #[serde(rename = "LifeCyclTracIdData", skip_serializing_if = "Option::is_none")]
4378    pub life_cycl_trac_id_data: Option<TransactionLifeCycleIdentification2>,
4379}
4380#[derive(
4381    Debug,
4382    Default,
4383    Clone,
4384    PartialEq,
4385    ::serde::Serialize,
4386    ::serde::Deserialize,
4387    ::derive_builder::Builder,
4388    ::validator::Validate,
4389)]
4390pub struct Wallet2 {
4391    #[serde(rename = "Prvdr", skip_serializing_if = "Option::is_none")]
4392    pub prvdr: Option<PartyIdentification258>,
4393    #[serde(rename = "PANAge", skip_serializing_if = "Option::is_none")]
4394    pub pan_age: Option<Max5PositiveNumber>,
4395    #[serde(rename = "UsrAcctAge", skip_serializing_if = "Option::is_none")]
4396    pub usr_acct_age: Option<Max5PositiveNumber>,
4397    #[serde(rename = "WlltAcctAge", skip_serializing_if = "Option::is_none")]
4398    pub wllt_acct_age: Option<Max5PositiveNumber>,
4399    #[serde(rename = "DaysSncLastActvty", skip_serializing_if = "Option::is_none")]
4400    pub days_snc_last_actvty: Option<Max5PositiveNumber>,
4401    #[serde(rename = "Actvty", skip_serializing_if = "Option::is_none")]
4402    pub actvty: Option<Max10PositiveNumber>,
4403    #[serde(rename = "ActvtyIntrvl", skip_serializing_if = "Option::is_none")]
4404    pub actvty_intrvl: Option<Frequency12Code>,
4405    #[serde(rename = "LastWlltChng", skip_serializing_if = "Option::is_none")]
4406    pub last_wllt_chng: Option<Max5PositiveNumber>,
4407    #[serde(rename = "SspdCrds", skip_serializing_if = "Option::is_none")]
4408    pub sspd_crds: Option<Max5PositiveNumber>,
4409    #[serde(rename = "WlltAcctCtry", skip_serializing_if = "Option::is_none")]
4410    pub wllt_acct_ctry: Option<IsoMax3ACountryCode>,
4411    #[serde(rename = "CardDataNtryMd", skip_serializing_if = "Option::is_none")]
4412    pub card_data_ntry_md: Option<CardDataReading9Code>,
4413    #[serde(rename = "OthrCardDataNtryMd", skip_serializing_if = "Option::is_none")]
4414    pub othr_card_data_ntry_md: Option<Max35Text>,
4415    #[serde(rename = "WlltAcctEmailAge", skip_serializing_if = "Option::is_none")]
4416    pub wllt_acct_email_age: Option<Max5PositiveNumber>,
4417    #[serde(rename = "WlltPrvdrRskAssmnt", skip_serializing_if = "Option::is_none")]
4418    pub wllt_prvdr_rsk_assmnt: Option<RiskAssessment1Code>,
4419    #[serde(
4420        rename = "WlltPrvdrRskAssmntMdlVrsn",
4421        skip_serializing_if = "Option::is_none"
4422    )]
4423    pub wllt_prvdr_rsk_assmnt_mdl_vrsn: Option<Max35Text>,
4424    #[serde(rename = "WlltPrvdrPhneScore", skip_serializing_if = "Option::is_none")]
4425    pub wllt_prvdr_phne_score: Option<Max5PositiveNumber>,
4426    #[serde(rename = "WlltPrvdrDvcScore", skip_serializing_if = "Option::is_none")]
4427    pub wllt_prvdr_dvc_score: Option<Max5PositiveNumber>,
4428    #[serde(rename = "WlltPrvdrAcctScore", skip_serializing_if = "Option::is_none")]
4429    pub wllt_prvdr_acct_score: Option<Max5PositiveNumber>,
4430    #[validate(length(min = 0,))]
4431    #[serde(rename = "AddtlData", default)]
4432    pub addtl_data: Vec<AdditionalData1>,
4433}
4434#[derive(
4435    Debug,
4436    Default,
4437    Clone,
4438    PartialEq,
4439    ::serde::Serialize,
4440    ::serde::Deserialize,
4441    ::derive_builder::Builder,
4442    ::validator::Validate,
4443)]
4444pub struct PassengerTransport2 {
4445    #[serde(rename = "Summry", skip_serializing_if = "Option::is_none")]
4446    pub summry: Option<PassengerTransportSummary2>,
4447    #[validate(length(min = 0,))]
4448    #[serde(rename = "TripLeg", default)]
4449    pub trip_leg: Vec<TripLeg2>,
4450    #[validate(length(min = 0,))]
4451    #[serde(rename = "AncllryPurchs", default)]
4452    pub ancllry_purchs: Vec<AncillaryPurchase2>,
4453    #[validate(length(min = 0,))]
4454    #[serde(rename = "HirdVhclDtls", default)]
4455    pub hird_vhcl_dtls: Vec<HiredVehicle2>,
4456}
4457#[derive(
4458    Debug,
4459    Default,
4460    Clone,
4461    PartialEq,
4462    ::serde::Serialize,
4463    ::serde::Deserialize,
4464    ::derive_builder::Builder,
4465    ::validator::Validate,
4466)]
4467pub struct VerificationValue1ChoiceEnum {
4468    #[serde(rename = "TxtVal", skip_serializing_if = "Option::is_none")]
4469    pub txt_val: Option<Max2048Text>,
4470    #[serde(rename = "BinryVal", skip_serializing_if = "Option::is_none")]
4471    pub binry_val: Option<Max5000Binary>,
4472    #[serde(rename = "HexBinryVal", skip_serializing_if = "Option::is_none")]
4473    pub hex_binry_val: Option<Max9999HexBinaryText>,
4474    #[serde(rename = "PINData", skip_serializing_if = "Option::is_none")]
4475    pub pin_data: Option<PinData1>,
4476}
4477#[derive(
4478    Debug,
4479    Default,
4480    Clone,
4481    PartialEq,
4482    ::serde::Serialize,
4483    ::serde::Deserialize,
4484    ::derive_builder::Builder,
4485    ::validator::Validate,
4486)]
4487pub struct VerificationValue1Choice {
4488    #[serde(flatten)]
4489    pub value: VerificationValue1ChoiceEnum,
4490}
4491#[derive(
4492    Debug,
4493    Default,
4494    Clone,
4495    PartialEq,
4496    ::serde::Serialize,
4497    ::serde::Deserialize,
4498    ::derive_builder::Builder,
4499    ::validator::Validate,
4500)]
4501pub struct Reconciliation3 {
4502    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
4503    pub id: Option<Max35Text>,
4504    #[serde(rename = "Dt", skip_serializing_if = "Option::is_none")]
4505    pub dt: Option<IsoDate>,
4506    #[serde(rename = "ChckptRef", skip_serializing_if = "Option::is_none")]
4507    pub chckpt_ref: Option<Max35Text>,
4508}
4509#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
4510pub enum EncryptedDataFormat1Code {
4511    #[serde(rename = "ASCI")]
4512    Asci,
4513    #[serde(rename = "BINF")]
4514    Binf,
4515    #[serde(rename = "EBCD")]
4516    Ebcd,
4517    #[serde(rename = "HEXF")]
4518    Hexf,
4519    #[serde(rename = "OTHN")]
4520    Othn,
4521    #[serde(rename = "OTHP")]
4522    Othp,
4523    #[default]
4524    Unknown,
4525}
4526#[derive(
4527    Debug,
4528    Default,
4529    Clone,
4530    PartialEq,
4531    ::serde::Serialize,
4532    ::serde::Deserialize,
4533    ::derive_builder::Builder,
4534    ::validator::Validate,
4535)]
4536pub struct PercentageRate {
4537    #[serde(rename = "$text")]
4538    pub value: f64,
4539}
4540#[derive(
4541    Debug,
4542    Default,
4543    Clone,
4544    PartialEq,
4545    ::serde::Serialize,
4546    ::serde::Deserialize,
4547    ::derive_builder::Builder,
4548    ::validator::Validate,
4549)]
4550pub struct Iso8583TransactionTypeCode {
4551    #[validate(regex = "ISO_8583_TRANSACTION_TYPE_CODE_REGEX")]
4552    #[serde(rename = "$text")]
4553    pub value: String,
4554}
4555#[derive(
4556    Debug,
4557    Default,
4558    Clone,
4559    PartialEq,
4560    ::serde::Serialize,
4561    ::serde::Deserialize,
4562    ::derive_builder::Builder,
4563    ::validator::Validate,
4564)]
4565pub struct Content1 {
4566    #[validate]
4567    #[serde(rename = "Val")]
4568    pub val: Max20KText,
4569    #[serde(rename = "Sgntr", skip_serializing_if = "Option::is_none")]
4570    pub sgntr: Option<Max140Binary>,
4571    #[serde(rename = "CertId", skip_serializing_if = "Option::is_none")]
4572    pub cert_id: Option<Max70Text>,
4573}
4574#[derive(
4575    Debug,
4576    Default,
4577    Clone,
4578    PartialEq,
4579    ::serde::Serialize,
4580    ::serde::Deserialize,
4581    ::derive_builder::Builder,
4582    ::validator::Validate,
4583)]
4584pub struct Max2048Text {
4585    #[validate(length(min = 1, max = 2048,))]
4586    #[serde(rename = "$text")]
4587    pub value: String,
4588}
4589#[derive(
4590    Debug,
4591    Default,
4592    Clone,
4593    PartialEq,
4594    ::serde::Serialize,
4595    ::serde::Deserialize,
4596    ::derive_builder::Builder,
4597    ::validator::Validate,
4598)]
4599pub struct TransactionAmount1 {
4600    #[validate]
4601    #[serde(rename = "Amt")]
4602    pub amt: ImpliedCurrencyAndAmount,
4603    #[serde(rename = "Ccy")]
4604    pub ccy: Iso3NumericCurrencyCode,
4605}
4606#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
4607pub enum AdditionalIdentificationType1Code {
4608    #[serde(rename = "OTHP")]
4609    Othp,
4610    #[serde(rename = "OTHN")]
4611    Othn,
4612    #[serde(rename = "ICSN")]
4613    Icsn,
4614    #[serde(rename = "ATNU")]
4615    Atnu,
4616    #[default]
4617    Unknown,
4618}
4619#[derive(
4620    Debug,
4621    Default,
4622    Clone,
4623    PartialEq,
4624    ::serde::Serialize,
4625    ::serde::Deserialize,
4626    ::derive_builder::Builder,
4627    ::validator::Validate,
4628)]
4629pub struct Contact2 {
4630    #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
4631    pub nm: Option<Max70Text>,
4632    #[serde(rename = "HomePhneNb", skip_serializing_if = "Option::is_none")]
4633    pub home_phne_nb: Option<PhoneNumber>,
4634    #[serde(rename = "BizPhneNb", skip_serializing_if = "Option::is_none")]
4635    pub biz_phne_nb: Option<PhoneNumber>,
4636    #[serde(rename = "MobPhneNb", skip_serializing_if = "Option::is_none")]
4637    pub mob_phne_nb: Option<PhoneNumber>,
4638    #[serde(rename = "OthrPhneNb", skip_serializing_if = "Option::is_none")]
4639    pub othr_phne_nb: Option<PhoneNumber>,
4640    #[serde(rename = "PrsnlEmailAdr", skip_serializing_if = "Option::is_none")]
4641    pub prsnl_email_adr: Option<Max256Text>,
4642    #[serde(rename = "BizEmailAdr", skip_serializing_if = "Option::is_none")]
4643    pub biz_email_adr: Option<Max256Text>,
4644    #[serde(rename = "OthrEmailAdr", skip_serializing_if = "Option::is_none")]
4645    pub othr_email_adr: Option<Max256Text>,
4646    #[serde(rename = "HomeFaxNb", skip_serializing_if = "Option::is_none")]
4647    pub home_fax_nb: Option<PhoneNumber>,
4648    #[serde(rename = "BizFaxNb", skip_serializing_if = "Option::is_none")]
4649    pub biz_fax_nb: Option<PhoneNumber>,
4650    #[serde(rename = "URLAdr", skip_serializing_if = "Option::is_none")]
4651    pub url_adr: Option<Max256Text>,
4652    #[serde(rename = "Lang", skip_serializing_if = "Option::is_none")]
4653    pub lang: Option<Iso2ALanguageCode>,
4654}
4655#[derive(
4656    Debug,
4657    Default,
4658    Clone,
4659    PartialEq,
4660    ::serde::Serialize,
4661    ::serde::Deserialize,
4662    ::derive_builder::Builder,
4663    ::validator::Validate,
4664)]
4665pub struct Terminal5 {
4666    #[serde(rename = "TermnlId", skip_serializing_if = "Option::is_none")]
4667    pub termnl_id: Option<TerminalIdentification3>,
4668    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
4669    pub tp: Option<TerminalType1Code>,
4670    #[serde(rename = "OthrTp", skip_serializing_if = "Option::is_none")]
4671    pub othr_tp: Option<Max35Text>,
4672    #[serde(rename = "Cpblties", skip_serializing_if = "Option::is_none")]
4673    pub cpblties: Option<Capabilities2>,
4674    #[serde(rename = "TermnlIntgtn", skip_serializing_if = "Option::is_none")]
4675    pub termnl_intgtn: Option<TerminalIntegrationCategory1Code>,
4676    #[serde(rename = "GeogcLctn", skip_serializing_if = "Option::is_none")]
4677    pub geogc_lctn: Option<GeographicPointInDecimalDegrees>,
4678    #[serde(rename = "OutdrInd", skip_serializing_if = "Option::is_none")]
4679    pub outdr_ind: Option<TrueFalseIndicator>,
4680    #[serde(rename = "OffPrmissInd", skip_serializing_if = "Option::is_none")]
4681    pub off_prmiss_ind: Option<TrueFalseIndicator>,
4682    #[serde(rename = "OnBrdInd", skip_serializing_if = "Option::is_none")]
4683    pub on_brd_ind: Option<TrueFalseIndicator>,
4684    #[validate(length(min = 0,))]
4685    #[serde(rename = "POICmpnt", default)]
4686    pub poi_cmpnt: Vec<PointOfInteractionComponent13>,
4687}
4688#[derive(
4689    Debug,
4690    Default,
4691    Clone,
4692    PartialEq,
4693    ::serde::Serialize,
4694    ::serde::Deserialize,
4695    ::derive_builder::Builder,
4696    ::validator::Validate,
4697)]
4698pub struct Max20Text {
4699    #[validate(length(min = 1, max = 20,))]
4700    #[serde(rename = "$text")]
4701    pub value: String,
4702}
4703#[derive(
4704    Debug,
4705    Default,
4706    Clone,
4707    PartialEq,
4708    ::serde::Serialize,
4709    ::serde::Deserialize,
4710    ::derive_builder::Builder,
4711    ::validator::Validate,
4712)]
4713pub struct EncryptedContent5 {
4714    #[serde(rename = "CnttTp")]
4715    pub cntt_tp: ContentType2Code,
4716    #[validate]
4717    #[serde(rename = "CnttNcrptnAlgo")]
4718    pub cntt_ncrptn_algo: AlgorithmIdentification25,
4719    #[validate(length(min = 1,))]
4720    #[serde(rename = "NcrptdDataElmt", default)]
4721    pub ncrptd_data_elmt: Vec<EncryptedDataElement1>,
4722}
4723#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
4724pub enum OutputFormat1Code {
4725    #[serde(rename = "MREF")]
4726    Mref,
4727    #[serde(rename = "TEXT")]
4728    Text,
4729    #[serde(rename = "HTML")]
4730    Html,
4731    #[default]
4732    Unknown,
4733}
4734#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
4735pub enum TypeOfAmount21Code {
4736    #[serde(rename = "INTC")]
4737    Intc,
4738    #[serde(rename = "FEEP")]
4739    Feep,
4740    #[serde(rename = "OTHN")]
4741    Othn,
4742    #[serde(rename = "OTHP")]
4743    Othp,
4744    #[serde(rename = "FEEA")]
4745    Feea,
4746    #[serde(rename = "CSIF")]
4747    Csif,
4748    #[serde(rename = "MXIF")]
4749    Mxif,
4750    #[serde(rename = "MNIF")]
4751    Mnif,
4752    #[default]
4753    Unknown,
4754}
4755#[derive(
4756    Debug,
4757    Default,
4758    Clone,
4759    PartialEq,
4760    ::serde::Serialize,
4761    ::serde::Deserialize,
4762    ::derive_builder::Builder,
4763    ::validator::Validate,
4764)]
4765pub struct OriginalTransactionAmount2 {
4766    #[serde(rename = "AmtQlfr", skip_serializing_if = "Option::is_none")]
4767    pub amt_qlfr: Option<TypeOfAmount22Code>,
4768    #[validate]
4769    #[serde(rename = "TxAmt")]
4770    pub tx_amt: TransactionAmount1,
4771    #[serde(rename = "CrdhldrBllgAmt", skip_serializing_if = "Option::is_none")]
4772    pub crdhldr_bllg_amt: Option<Amount15>,
4773    #[serde(rename = "RcncltnAmt", skip_serializing_if = "Option::is_none")]
4774    pub rcncltn_amt: Option<Amount15>,
4775}
4776#[derive(
4777    Debug,
4778    Default,
4779    Clone,
4780    PartialEq,
4781    ::serde::Serialize,
4782    ::serde::Deserialize,
4783    ::derive_builder::Builder,
4784    ::validator::Validate,
4785)]
4786pub struct Iso8583AmountTypeCode {
4787    #[validate(regex = "ISO_8583_AMOUNT_TYPE_CODE_REGEX")]
4788    #[serde(rename = "$text")]
4789    pub value: String,
4790}
4791#[derive(
4792    Debug,
4793    Default,
4794    Clone,
4795    PartialEq,
4796    ::serde::Serialize,
4797    ::serde::Deserialize,
4798    ::derive_builder::Builder,
4799    ::validator::Validate,
4800)]
4801pub struct Max10Text {
4802    #[validate(length(min = 1, max = 10,))]
4803    #[serde(rename = "$text")]
4804    pub value: String,
4805}
4806#[derive(
4807    Debug,
4808    Default,
4809    Clone,
4810    PartialEq,
4811    ::serde::Serialize,
4812    ::serde::Deserialize,
4813    ::derive_builder::Builder,
4814    ::validator::Validate,
4815)]
4816pub struct Max5PositiveNumber {
4817    #[validate(range(min = 1,))]
4818    #[serde(rename = "$text")]
4819    pub value: f64,
4820}
4821#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
4822pub enum TransactionAttribute2Code {
4823    #[serde(rename = "AGGR")]
4824    Aggr,
4825    #[serde(rename = "CADB")]
4826    Cadb,
4827    #[serde(rename = "CPLT")]
4828    Cplt,
4829    #[serde(rename = "DBRC")]
4830    Dbrc,
4831    #[serde(rename = "DBRP")]
4832    Dbrp,
4833    #[serde(rename = "DFRD")]
4834    Dfrd,
4835    #[serde(rename = "INCR")]
4836    Incr,
4837    #[serde(rename = "FRCP")]
4838    Frcp,
4839    #[serde(rename = "INST")]
4840    Inst,
4841    #[serde(rename = "OTHN")]
4842    Othn,
4843    #[serde(rename = "OTHP")]
4844    Othp,
4845    #[serde(rename = "PAUT")]
4846    Paut,
4847    #[serde(rename = "PACP")]
4848    Pacp,
4849    #[serde(rename = "PPYT")]
4850    Ppyt,
4851    #[serde(rename = "RCPT")]
4852    Rcpt,
4853    #[serde(rename = "SUBR")]
4854    Subr,
4855    #[serde(rename = "TPUP")]
4856    Tpup,
4857    #[serde(rename = "UCOF")]
4858    Ucof,
4859    #[default]
4860    Unknown,
4861}
4862#[derive(
4863    Debug,
4864    Default,
4865    Clone,
4866    PartialEq,
4867    ::serde::Serialize,
4868    ::serde::Deserialize,
4869    ::derive_builder::Builder,
4870    ::validator::Validate,
4871)]
4872pub struct Max210Text {
4873    #[validate(length(min = 1, max = 210,))]
4874    #[serde(rename = "$text")]
4875    pub value: String,
4876}
4877#[derive(
4878    Debug,
4879    Default,
4880    Clone,
4881    PartialEq,
4882    ::serde::Serialize,
4883    ::serde::Deserialize,
4884    ::derive_builder::Builder,
4885    ::validator::Validate,
4886)]
4887pub struct Parameter5 {
4888    #[serde(rename = "DgstAlgo", skip_serializing_if = "Option::is_none")]
4889    pub dgst_algo: Option<Algorithm11Code>,
4890}
4891#[derive(
4892    Debug,
4893    Default,
4894    Clone,
4895    PartialEq,
4896    ::serde::Serialize,
4897    ::serde::Deserialize,
4898    ::derive_builder::Builder,
4899    ::validator::Validate,
4900)]
4901pub struct VerificationResult2 {
4902    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
4903    pub tp: Option<Max35Text>,
4904    #[serde(rename = "Ntty", skip_serializing_if = "Option::is_none")]
4905    pub ntty: Option<VerificationEntity2Code>,
4906    #[serde(rename = "OthrNtty", skip_serializing_if = "Option::is_none")]
4907    pub othr_ntty: Option<Max35Text>,
4908    #[serde(rename = "Rslt", skip_serializing_if = "Option::is_none")]
4909    pub rslt: Option<Verification3Code>,
4910    #[serde(rename = "OthrRslt", skip_serializing_if = "Option::is_none")]
4911    pub othr_rslt: Option<Max500Text>,
4912    #[validate(length(min = 0,))]
4913    #[serde(rename = "RsltDtls", default)]
4914    pub rslt_dtls: Vec<AdditionalData1>,
4915}
4916#[derive(
4917    Debug,
4918    Default,
4919    Clone,
4920    PartialEq,
4921    ::serde::Serialize,
4922    ::serde::Deserialize,
4923    ::derive_builder::Builder,
4924    ::validator::Validate,
4925)]
4926pub struct AlgorithmIdentification22 {
4927    #[serde(rename = "Algo")]
4928    pub algo: Algorithm17Code,
4929    #[serde(rename = "Param", skip_serializing_if = "Option::is_none")]
4930    pub param: Option<Parameter7>,
4931}
4932#[derive(
4933    Debug,
4934    Default,
4935    Clone,
4936    PartialEq,
4937    ::serde::Serialize,
4938    ::serde::Deserialize,
4939    ::derive_builder::Builder,
4940    ::validator::Validate,
4941)]
4942pub struct LocalData5 {
4943    #[serde(rename = "Lang")]
4944    pub lang: IsoMax3ALanguageCode,
4945    #[serde(rename = "CmonNm", skip_serializing_if = "Option::is_none")]
4946    pub cmon_nm: Option<Max280Text>,
4947    #[serde(rename = "LglCorpNm", skip_serializing_if = "Option::is_none")]
4948    pub lgl_corp_nm: Option<Max210Text>,
4949    #[serde(rename = "Adr", skip_serializing_if = "Option::is_none")]
4950    pub adr: Option<Address3>,
4951    #[serde(rename = "AddtlAdrInf", skip_serializing_if = "Option::is_none")]
4952    pub addtl_adr_inf: Option<Max512Text>,
4953    #[validate(length(min = 0,))]
4954    #[serde(rename = "AddtlData", default)]
4955    pub addtl_data: Vec<AdditionalData1>,
4956}
4957#[derive(
4958    Debug,
4959    Default,
4960    Clone,
4961    PartialEq,
4962    ::serde::Serialize,
4963    ::serde::Deserialize,
4964    ::derive_builder::Builder,
4965    ::validator::Validate,
4966)]
4967pub struct Tax39 {
4968    #[serde(rename = "Tp")]
4969    pub tp: AddendumTaxType2Code,
4970    #[serde(rename = "OthrTp", skip_serializing_if = "Option::is_none")]
4971    pub othr_tp: Option<Max35Text>,
4972    #[serde(rename = "Desc", skip_serializing_if = "Option::is_none")]
4973    pub desc: Option<Max35Text>,
4974    #[serde(rename = "TaxXmptn", skip_serializing_if = "Option::is_none")]
4975    pub tax_xmptn: Option<TrueFalseIndicator>,
4976    #[serde(rename = "TaxXmptRsn", skip_serializing_if = "Option::is_none")]
4977    pub tax_xmpt_rsn: Option<Max35Text>,
4978    #[validate]
4979    #[serde(rename = "Amt")]
4980    pub amt: ImpliedCurrencyAndAmount,
4981    #[serde(rename = "Rate", skip_serializing_if = "Option::is_none")]
4982    pub rate: Option<PercentageRate>,
4983    #[serde(rename = "InclInTtlInd", skip_serializing_if = "Option::is_none")]
4984    pub incl_in_ttl_ind: Option<TrueFalseIndicator>,
4985    #[serde(rename = "CdtDbt", skip_serializing_if = "Option::is_none")]
4986    pub cdt_dbt: Option<CreditDebit3Code>,
4987}
4988#[derive(
4989    Debug,
4990    Default,
4991    Clone,
4992    PartialEq,
4993    ::serde::Serialize,
4994    ::serde::Deserialize,
4995    ::derive_builder::Builder,
4996    ::validator::Validate,
4997)]
4998pub struct Context12 {
4999    #[serde(rename = "PtOfSvcCntxt", skip_serializing_if = "Option::is_none")]
5000    pub pt_of_svc_cntxt: Option<PointOfServiceContext3>,
5001    #[validate]
5002    #[serde(rename = "TxCntxt")]
5003    pub tx_cntxt: TransactionContext7,
5004    #[validate(length(min = 0,))]
5005    #[serde(rename = "Vrfctn", default)]
5006    pub vrfctn: Vec<Verification4>,
5007    #[serde(rename = "RskCntxt", skip_serializing_if = "Option::is_none")]
5008    pub rsk_cntxt: Option<RiskContext2>,
5009    #[serde(rename = "SaleCntxt", skip_serializing_if = "Option::is_none")]
5010    pub sale_cntxt: Option<SaleContext8>,
5011}
5012#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
5013pub enum PartyType20Code {
5014    #[serde(rename = "ACCP")]
5015    Accp,
5016    #[serde(rename = "ACQR")]
5017    Acqr,
5018    #[serde(rename = "CRDH")]
5019    Crdh,
5020    #[serde(rename = "CISS")]
5021    Ciss,
5022    #[serde(rename = "AGNT")]
5023    Agnt,
5024    #[default]
5025    Unknown,
5026}
5027#[derive(
5028    Debug,
5029    Default,
5030    Clone,
5031    PartialEq,
5032    ::serde::Serialize,
5033    ::serde::Deserialize,
5034    ::derive_builder::Builder,
5035    ::validator::Validate,
5036)]
5037pub struct SaleSummary1 {
5038    #[serde(rename = "SummryCmmdtyId", skip_serializing_if = "Option::is_none")]
5039    pub summry_cmmdty_id: Option<Max35Text>,
5040    #[serde(rename = "LltyPrgrmm", skip_serializing_if = "Option::is_none")]
5041    pub llty_prgrmm: Option<LoyaltyProgramme2>,
5042    #[validate(length(min = 0,))]
5043    #[serde(rename = "Adjstmnt", default)]
5044    pub adjstmnt: Vec<Adjustment9>,
5045}
5046#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
5047pub enum TypeOfAmount22Code {
5048    #[serde(rename = "ACTL")]
5049    Actl,
5050    #[serde(rename = "DFLT")]
5051    Dflt,
5052    #[serde(rename = "DPST")]
5053    Dpst,
5054    #[serde(rename = "ESTM")]
5055    Estm,
5056    #[serde(rename = "MAXI")]
5057    Maxi,
5058    #[serde(rename = "PRXY")]
5059    Prxy,
5060    #[serde(rename = "RESD")]
5061    Resd,
5062    #[default]
5063    Unknown,
5064}
5065#[derive(
5066    Debug,
5067    Default,
5068    Clone,
5069    PartialEq,
5070    ::serde::Serialize,
5071    ::serde::Deserialize,
5072    ::derive_builder::Builder,
5073    ::validator::Validate,
5074)]
5075pub struct DocumentReference1 {
5076    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
5077    pub tp: Option<Max35Text>,
5078    #[serde(rename = "Ref", skip_serializing_if = "Option::is_none")]
5079    pub r#ref: Option<Max70Text>,
5080}
5081#[derive(
5082    Debug,
5083    Default,
5084    Clone,
5085    PartialEq,
5086    ::serde::Serialize,
5087    ::serde::Deserialize,
5088    ::derive_builder::Builder,
5089    ::validator::Validate,
5090)]
5091pub struct PartyIdentification258 {
5092    #[validate]
5093    #[serde(rename = "Id")]
5094    pub id: Max35Text,
5095    #[serde(rename = "Assgnr", skip_serializing_if = "Option::is_none")]
5096    pub assgnr: Option<Max35Text>,
5097    #[serde(rename = "Ctry", skip_serializing_if = "Option::is_none")]
5098    pub ctry: Option<Iso3NumericCountryCode>,
5099    #[serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none")]
5100    pub shrt_nm: Option<Max35Text>,
5101    #[serde(rename = "LglCorpNm", skip_serializing_if = "Option::is_none")]
5102    pub lgl_corp_nm: Option<Max99Text>,
5103    #[serde(rename = "AddtlId", skip_serializing_if = "Option::is_none")]
5104    pub addtl_id: Option<AdditionalData1>,
5105    #[serde(rename = "LclData", skip_serializing_if = "Option::is_none")]
5106    pub lcl_data: Option<LocalData1>,
5107}
5108#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
5109pub enum Algorithm7Code {
5110    #[serde(rename = "ERSA")]
5111    Ersa,
5112    #[serde(rename = "RSAO")]
5113    Rsao,
5114    #[default]
5115    Unknown,
5116}
5117#[derive(
5118    Debug,
5119    Default,
5120    Clone,
5121    PartialEq,
5122    ::serde::Serialize,
5123    ::serde::Deserialize,
5124    ::derive_builder::Builder,
5125    ::validator::Validate,
5126)]
5127pub struct VehicleRentalInvoice2 {
5128    #[serde(rename = "NoShowInd", skip_serializing_if = "Option::is_none")]
5129    pub no_show_ind: Option<TrueFalseIndicator>,
5130    #[serde(rename = "AdjstdInd", skip_serializing_if = "Option::is_none")]
5131    pub adjstd_ind: Option<TrueFalseIndicator>,
5132    #[serde(rename = "RtrLctn", skip_serializing_if = "Option::is_none")]
5133    pub rtr_lctn: Option<Address2>,
5134    #[serde(rename = "ChckOutDt", skip_serializing_if = "Option::is_none")]
5135    pub chck_out_dt: Option<IsoDate>,
5136    #[serde(rename = "ChckOutTm", skip_serializing_if = "Option::is_none")]
5137    pub chck_out_tm: Option<IsoTime>,
5138    #[serde(rename = "ChckInDt", skip_serializing_if = "Option::is_none")]
5139    pub chck_in_dt: Option<IsoDate>,
5140    #[serde(rename = "ChckInTm", skip_serializing_if = "Option::is_none")]
5141    pub chck_in_tm: Option<IsoTime>,
5142    #[serde(rename = "Drtn", skip_serializing_if = "Option::is_none")]
5143    pub drtn: Option<Max4NumericText>,
5144    #[serde(rename = "VhclClssInvcd", skip_serializing_if = "Option::is_none")]
5145    pub vhcl_clss_invcd: Option<Vehicle4>,
5146    #[serde(rename = "VhclClssPrvdd", skip_serializing_if = "Option::is_none")]
5147    pub vhcl_clss_prvdd: Option<Vehicle4>,
5148    #[serde(rename = "TrvlDstnc", skip_serializing_if = "Option::is_none")]
5149    pub trvl_dstnc: Option<Distance1>,
5150    #[validate(length(min = 0,))]
5151    #[serde(rename = "RntlChrg", default)]
5152    pub rntl_chrg: Vec<RentalRate1>,
5153    #[serde(rename = "SummryCmmdtyId", skip_serializing_if = "Option::is_none")]
5154    pub summry_cmmdty_id: Option<Max35Text>,
5155    #[serde(rename = "InsrncInd", skip_serializing_if = "Option::is_none")]
5156    pub insrnc_ind: Option<TrueFalseIndicator>,
5157    #[validate(length(min = 0,))]
5158    #[serde(rename = "AddtlAmt", default)]
5159    pub addtl_amt: Vec<Amount18>,
5160    #[validate(length(min = 0,))]
5161    #[serde(rename = "Tax", default)]
5162    pub tax: Vec<Tax39>,
5163}
5164#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
5165pub enum PeriodUnit3Code {
5166    #[serde(rename = "OTHP")]
5167    Othp,
5168    #[serde(rename = "OTHN")]
5169    Othn,
5170    #[serde(rename = "MNTH")]
5171    Mnth,
5172    #[serde(rename = "WEEK")]
5173    Week,
5174    #[serde(rename = "YEAR")]
5175    Year,
5176    #[serde(rename = "DAYS")]
5177    Days,
5178    #[serde(rename = "EXDY")]
5179    Exdy,
5180    #[default]
5181    Unknown,
5182}
5183#[derive(
5184    Debug,
5185    Default,
5186    Clone,
5187    PartialEq,
5188    ::serde::Serialize,
5189    ::serde::Deserialize,
5190    ::derive_builder::Builder,
5191    ::validator::Validate,
5192)]
5193pub struct Contact6 {
5194    #[serde(rename = "HomePhneNb", skip_serializing_if = "Option::is_none")]
5195    pub home_phne_nb: Option<PhoneNumber>,
5196    #[serde(rename = "BizPhneNb", skip_serializing_if = "Option::is_none")]
5197    pub biz_phne_nb: Option<PhoneNumber>,
5198    #[serde(rename = "MobPhneNb", skip_serializing_if = "Option::is_none")]
5199    pub mob_phne_nb: Option<PhoneNumber>,
5200    #[serde(rename = "OthrPhneNb", skip_serializing_if = "Option::is_none")]
5201    pub othr_phne_nb: Option<PhoneNumber>,
5202    #[serde(rename = "PrsnlEmailAdr", skip_serializing_if = "Option::is_none")]
5203    pub prsnl_email_adr: Option<Max256Text>,
5204    #[serde(rename = "BizEmailAdr", skip_serializing_if = "Option::is_none")]
5205    pub biz_email_adr: Option<Max256Text>,
5206    #[serde(rename = "OthrEmailAdr", skip_serializing_if = "Option::is_none")]
5207    pub othr_email_adr: Option<Max256Text>,
5208    #[serde(rename = "HomeFaxNb", skip_serializing_if = "Option::is_none")]
5209    pub home_fax_nb: Option<PhoneNumber>,
5210    #[serde(rename = "BizFaxNb", skip_serializing_if = "Option::is_none")]
5211    pub biz_fax_nb: Option<PhoneNumber>,
5212    #[serde(rename = "URLAdr", skip_serializing_if = "Option::is_none")]
5213    pub url_adr: Option<Max256Text>,
5214    #[serde(rename = "Lang", skip_serializing_if = "Option::is_none")]
5215    pub lang: Option<LanguageCode>,
5216}
5217#[derive(
5218    Debug,
5219    Default,
5220    Clone,
5221    PartialEq,
5222    ::serde::Serialize,
5223    ::serde::Deserialize,
5224    ::derive_builder::Builder,
5225    ::validator::Validate,
5226)]
5227pub struct Recipient7ChoiceEnum {
5228    #[serde(rename = "KEK", skip_serializing_if = "Option::is_none")]
5229    pub kek: Option<Kek6>,
5230    #[serde(rename = "KeyIdr", skip_serializing_if = "Option::is_none")]
5231    pub key_idr: Option<KekIdentifier6>,
5232    #[serde(rename = "KeyTrnsprt", skip_serializing_if = "Option::is_none")]
5233    pub key_trnsprt: Option<KeyTransport6>,
5234}
5235#[derive(
5236    Debug,
5237    Default,
5238    Clone,
5239    PartialEq,
5240    ::serde::Serialize,
5241    ::serde::Deserialize,
5242    ::derive_builder::Builder,
5243    ::validator::Validate,
5244)]
5245pub struct Recipient7Choice {
5246    #[serde(flatten)]
5247    pub value: Recipient7ChoiceEnum,
5248}
5249#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
5250pub enum PeriodUnit2Code {
5251    #[serde(rename = "HOUR")]
5252    Hour,
5253    #[serde(rename = "HFDA")]
5254    Hfda,
5255    #[serde(rename = "DAYS")]
5256    Days,
5257    #[serde(rename = "WEEK")]
5258    Week,
5259    #[serde(rename = "MNTH")]
5260    Mnth,
5261    #[serde(rename = "YEAR")]
5262    Year,
5263    #[serde(rename = "MINU")]
5264    Minu,
5265    #[serde(rename = "OTHR")]
5266    Othr,
5267    #[default]
5268    Unknown,
5269}
5270#[derive(
5271    Debug,
5272    Default,
5273    Clone,
5274    PartialEq,
5275    ::serde::Serialize,
5276    ::serde::Deserialize,
5277    ::derive_builder::Builder,
5278    ::validator::Validate,
5279)]
5280pub struct Token2 {
5281    #[serde(rename = "PmtTkn", skip_serializing_if = "Option::is_none")]
5282    pub pmt_tkn: Option<Max19NumericText>,
5283    #[serde(rename = "TknXpryDt", skip_serializing_if = "Option::is_none")]
5284    pub tkn_xpry_dt: Option<IsoYearMonth>,
5285    #[serde(rename = "TknRqstrId", skip_serializing_if = "Option::is_none")]
5286    pub tkn_rqstr_id: Option<Max11NumericText>,
5287    #[serde(rename = "TknAssrncData", skip_serializing_if = "Option::is_none")]
5288    pub tkn_assrnc_data: Option<Max140Text>,
5289    #[serde(rename = "TknAssrncMtd", skip_serializing_if = "Option::is_none")]
5290    pub tkn_assrnc_mtd: Option<Max2NumericText>,
5291    #[serde(rename = "TknInittdInd", skip_serializing_if = "Option::is_none")]
5292    pub tkn_inittd_ind: Option<TrueFalseIndicator>,
5293    #[serde(rename = "StorgLctn", skip_serializing_if = "Option::is_none")]
5294    pub storg_lctn: Option<StorageLocation1Code>,
5295    #[serde(rename = "OthrStorgLctn", skip_serializing_if = "Option::is_none")]
5296    pub othr_storg_lctn: Option<Max35Text>,
5297    #[serde(rename = "PrtcnMtd", skip_serializing_if = "Option::is_none")]
5298    pub prtcn_mtd: Option<ProtectionMethod1Code>,
5299    #[serde(rename = "OthrPrtcnMtd", skip_serializing_if = "Option::is_none")]
5300    pub othr_prtcn_mtd: Option<Max35Text>,
5301    #[validate(length(min = 0,))]
5302    #[serde(rename = "AddtlData", default)]
5303    pub addtl_data: Vec<AdditionalData1>,
5304}
5305#[derive(
5306    Debug,
5307    Default,
5308    Clone,
5309    PartialEq,
5310    ::serde::Serialize,
5311    ::serde::Deserialize,
5312    ::derive_builder::Builder,
5313    ::validator::Validate,
5314)]
5315pub struct SponsoredMerchant2 {
5316    #[validate]
5317    #[serde(rename = "Id")]
5318    pub id: PartyIdentification262,
5319    #[serde(rename = "CmonNm", skip_serializing_if = "Option::is_none")]
5320    pub cmon_nm: Option<Max140Text>,
5321    #[serde(rename = "LglCorpNm", skip_serializing_if = "Option::is_none")]
5322    pub lgl_corp_nm: Option<Max99Text>,
5323    #[serde(rename = "Adr", skip_serializing_if = "Option::is_none")]
5324    pub adr: Option<Address2>,
5325    #[serde(rename = "AddtlAdrInf", skip_serializing_if = "Option::is_none")]
5326    pub addtl_adr_inf: Option<Max256Text>,
5327    #[serde(rename = "GeogcLctn", skip_serializing_if = "Option::is_none")]
5328    pub geogc_lctn: Option<GeographicPointInDecimalDegrees>,
5329    #[validate(length(min = 0,))]
5330    #[serde(rename = "AddtlData", default)]
5331    pub addtl_data: Vec<AdditionalData1>,
5332    #[serde(rename = "LclData", skip_serializing_if = "Option::is_none")]
5333    pub lcl_data: Option<LocalData5>,
5334}
5335#[derive(
5336    Debug,
5337    Default,
5338    Clone,
5339    PartialEq,
5340    ::serde::Serialize,
5341    ::serde::Deserialize,
5342    ::derive_builder::Builder,
5343    ::validator::Validate,
5344)]
5345pub struct Max140Binary {
5346    #[validate(length(min = 1, max = 140,), regex = "MAX_140_BINARY_REGEX")]
5347    pub value: String,
5348}
5349#[derive(
5350    Debug,
5351    Default,
5352    Clone,
5353    PartialEq,
5354    ::serde::Serialize,
5355    ::serde::Deserialize,
5356    ::derive_builder::Builder,
5357    ::validator::Validate,
5358)]
5359pub struct Parameter14 {
5360    #[serde(rename = "NcrptnFrmt", skip_serializing_if = "Option::is_none")]
5361    pub ncrptn_frmt: Option<EncryptionFormat3Code>,
5362    #[serde(rename = "InitlstnVctr", skip_serializing_if = "Option::is_none")]
5363    pub initlstn_vctr: Option<Max500Binary>,
5364    #[serde(rename = "BPddg", skip_serializing_if = "Option::is_none")]
5365    pub b_pddg: Option<BytePadding1Code>,
5366}
5367#[derive(
5368    Debug,
5369    Default,
5370    Clone,
5371    PartialEq,
5372    ::serde::Serialize,
5373    ::serde::Deserialize,
5374    ::derive_builder::Builder,
5375    ::validator::Validate,
5376)]
5377pub struct SpecialProgrammeQualification1 {
5378    #[serde(rename = "Prgrmm", skip_serializing_if = "Option::is_none")]
5379    pub prgrmm: Option<Max35Text>,
5380    #[validate(length(min = 0,))]
5381    #[serde(rename = "Dtl", default)]
5382    pub dtl: Vec<SpecialProgrammeDetails1>,
5383}
5384#[derive(
5385    Debug,
5386    Default,
5387    Clone,
5388    PartialEq,
5389    ::serde::Serialize,
5390    ::serde::Deserialize,
5391    ::derive_builder::Builder,
5392    ::validator::Validate,
5393)]
5394pub struct LoyaltyMember2 {
5395    #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
5396    pub nm: Option<CardholderName3>,
5397    #[serde(rename = "Adr", skip_serializing_if = "Option::is_none")]
5398    pub adr: Option<Address2>,
5399    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
5400    pub id: Option<Max35Text>,
5401    #[serde(rename = "MmbSts", skip_serializing_if = "Option::is_none")]
5402    pub mmb_sts: Option<Max35Text>,
5403    #[serde(rename = "XprtnDt", skip_serializing_if = "Option::is_none")]
5404    pub xprtn_dt: Option<IsoDate>,
5405    #[serde(rename = "LltyVal", skip_serializing_if = "Option::is_none")]
5406    pub llty_val: Option<Max10NumericText>,
5407    #[serde(rename = "LltyValTp", skip_serializing_if = "Option::is_none")]
5408    pub llty_val_tp: Option<LoyaltyValueType1Code>,
5409    #[serde(rename = "OthrLltyValTp", skip_serializing_if = "Option::is_none")]
5410    pub othr_llty_val_tp: Option<Max35Text>,
5411    #[serde(rename = "ValToCdt", skip_serializing_if = "Option::is_none")]
5412    pub val_to_cdt: Option<Max10NumericText>,
5413    #[serde(rename = "ValToDbt", skip_serializing_if = "Option::is_none")]
5414    pub val_to_dbt: Option<Max10NumericText>,
5415    #[serde(rename = "Bal", skip_serializing_if = "Option::is_none")]
5416    pub bal: Option<Max10NumericText>,
5417}
5418#[derive(
5419    Debug,
5420    Default,
5421    Clone,
5422    PartialEq,
5423    ::serde::Serialize,
5424    ::serde::Deserialize,
5425    ::derive_builder::Builder,
5426    ::validator::Validate,
5427)]
5428pub struct Device2 {
5429    #[serde(rename = "Manfctr", skip_serializing_if = "Option::is_none")]
5430    pub manfctr: Option<Max70Text>,
5431    #[serde(rename = "ManfctrMdlId", skip_serializing_if = "Option::is_none")]
5432    pub manfctr_mdl_id: Option<Max70Text>,
5433    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
5434    pub tp: Option<CustomerDeviceType2Code>,
5435    #[serde(rename = "OthrTp", skip_serializing_if = "Option::is_none")]
5436    pub othr_tp: Option<Max35Text>,
5437    #[serde(rename = "Lang", skip_serializing_if = "Option::is_none")]
5438    pub lang: Option<LanguageCode>,
5439    #[serde(rename = "PhneNb", skip_serializing_if = "Option::is_none")]
5440    pub phne_nb: Option<PhoneNumber>,
5441    #[serde(rename = "GeogcLctn", skip_serializing_if = "Option::is_none")]
5442    pub geogc_lctn: Option<GeographicPointInDecimalDegrees>,
5443    #[serde(rename = "LctnCtryCd", skip_serializing_if = "Option::is_none")]
5444    pub lctn_ctry_cd: Option<Iso3NumericCountryCode>,
5445    #[serde(rename = "IPAdr", skip_serializing_if = "Option::is_none")]
5446    pub ip_adr: Option<Max70Text>,
5447    #[serde(rename = "Email", skip_serializing_if = "Option::is_none")]
5448    pub email: Option<Max256Text>,
5449    #[serde(rename = "DvcNm", skip_serializing_if = "Option::is_none")]
5450    pub dvc_nm: Option<Max100Text>,
5451    #[serde(rename = "DvcNmNrmlzd", skip_serializing_if = "Option::is_none")]
5452    pub dvc_nm_nrmlzd: Option<Max100Text>,
5453}
5454#[derive(
5455    Debug,
5456    Default,
5457    Clone,
5458    PartialEq,
5459    ::serde::Serialize,
5460    ::serde::Deserialize,
5461    ::derive_builder::Builder,
5462    ::validator::Validate,
5463)]
5464pub struct SettlementServiceDate2 {
5465    #[serde(rename = "ReqdSttlmDt", skip_serializing_if = "Option::is_none")]
5466    pub reqd_sttlm_dt: Option<IsoDate>,
5467    #[serde(rename = "DfrrdSttlmInd", skip_serializing_if = "Option::is_none")]
5468    pub dfrrd_sttlm_ind: Option<TrueFalseIndicator>,
5469    #[serde(rename = "SttlmDt", skip_serializing_if = "Option::is_none")]
5470    pub sttlm_dt: Option<IsoDate>,
5471    #[serde(rename = "SttlmTm", skip_serializing_if = "Option::is_none")]
5472    pub sttlm_tm: Option<IsoTime>,
5473    #[serde(rename = "SttlmPrd", skip_serializing_if = "Option::is_none")]
5474    pub sttlm_prd: Option<Max35Text>,
5475    #[serde(rename = "SttlmCutOffTm", skip_serializing_if = "Option::is_none")]
5476    pub sttlm_cut_off_tm: Option<IsoDateTime>,
5477}
5478#[derive(
5479    Debug,
5480    Default,
5481    Clone,
5482    PartialEq,
5483    ::serde::Serialize,
5484    ::serde::Deserialize,
5485    ::derive_builder::Builder,
5486    ::validator::Validate,
5487)]
5488pub struct PinData1 {
5489    #[serde(rename = "Ctrl", skip_serializing_if = "Option::is_none")]
5490    pub ctrl: Option<Exact1HexBinaryText>,
5491    #[serde(rename = "KeySetIdr", skip_serializing_if = "Option::is_none")]
5492    pub key_set_idr: Option<Max8NumericText>,
5493    #[serde(rename = "DrvdInf", skip_serializing_if = "Option::is_none")]
5494    pub drvd_inf: Option<Max32HexBinaryText>,
5495    #[serde(rename = "Algo", skip_serializing_if = "Option::is_none")]
5496    pub algo: Option<Max2NumericText>,
5497    #[serde(rename = "KeyLngth", skip_serializing_if = "Option::is_none")]
5498    pub key_lngth: Option<Max4NumericText>,
5499    #[serde(rename = "KeyPrtcn", skip_serializing_if = "Option::is_none")]
5500    pub key_prtcn: Option<Max2NumericText>,
5501    #[serde(rename = "KeyIndx", skip_serializing_if = "Option::is_none")]
5502    pub key_indx: Option<Max5NumericText>,
5503    #[validate]
5504    #[serde(rename = "PINBlckFrmt")]
5505    pub pin_blck_frmt: Max2NumericText,
5506    #[validate]
5507    #[serde(rename = "NcrptdPINBlck")]
5508    pub ncrptd_pin_blck: Max16HexBinaryText,
5509}
5510#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
5511pub enum CryptographicKeyType3Code {
5512    #[serde(rename = "AES2")]
5513    Aes2,
5514    #[serde(rename = "EDE3")]
5515    Ede3,
5516    #[serde(rename = "DKP9")]
5517    Dkp9,
5518    #[serde(rename = "AES9")]
5519    Aes9,
5520    #[serde(rename = "AES5")]
5521    Aes5,
5522    #[serde(rename = "EDE4")]
5523    Ede4,
5524    #[default]
5525    Unknown,
5526}
5527#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
5528pub enum ReceiptType1Code {
5529    #[serde(rename = "EMAL")]
5530    Emal,
5531    #[serde(rename = "OTHR")]
5532    Othr,
5533    #[serde(rename = "PAPR")]
5534    Papr,
5535    #[serde(rename = "SMSM")]
5536    Smsm,
5537    #[serde(rename = "URID")]
5538    Urid,
5539    #[default]
5540    Unknown,
5541}
5542#[derive(
5543    Debug,
5544    Default,
5545    Clone,
5546    PartialEq,
5547    ::serde::Serialize,
5548    ::serde::Deserialize,
5549    ::derive_builder::Builder,
5550    ::validator::Validate,
5551)]
5552pub struct PartyIdentification259 {
5553    #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
5554    pub nm: Option<Max70Text>,
5555    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
5556    pub id: Option<PartyIdentification258>,
5557    #[serde(rename = "Adr", skip_serializing_if = "Option::is_none")]
5558    pub adr: Option<Address2>,
5559    #[serde(rename = "Ctct", skip_serializing_if = "Option::is_none")]
5560    pub ctct: Option<Contact3>,
5561    #[serde(rename = "TaxRegnId", skip_serializing_if = "Option::is_none")]
5562    pub tax_regn_id: Option<Max70Text>,
5563    #[serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none")]
5564    pub addtl_inf: Option<Max1000Text>,
5565}
5566#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
5567pub enum Response8Code {
5568    #[serde(rename = "PRCS")]
5569    Prcs,
5570    #[serde(rename = "UNPR")]
5571    Unpr,
5572    #[serde(rename = "UNRV")]
5573    Unrv,
5574    #[serde(rename = "REJT")]
5575    Rejt,
5576    #[serde(rename = "TECH")]
5577    Tech,
5578    #[serde(rename = "OTHN")]
5579    Othn,
5580    #[serde(rename = "OTHP")]
5581    Othp,
5582    #[default]
5583    Unknown,
5584}
5585#[derive(
5586    Debug,
5587    Default,
5588    Clone,
5589    PartialEq,
5590    ::serde::Serialize,
5591    ::serde::Deserialize,
5592    ::derive_builder::Builder,
5593    ::validator::Validate,
5594)]
5595pub struct CardProgrammeMode2 {
5596    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
5597    pub tp: Option<Max35Text>,
5598    #[validate(length(min = 1,))]
5599    #[serde(rename = "Id", default)]
5600    pub id: Vec<Max35Text>,
5601}
5602#[derive(
5603    Debug,
5604    Default,
5605    Clone,
5606    PartialEq,
5607    ::serde::Serialize,
5608    ::serde::Deserialize,
5609    ::derive_builder::Builder,
5610    ::validator::Validate,
5611)]
5612pub struct Customer7 {
5613    #[serde(rename = "CstmrId", skip_serializing_if = "Option::is_none")]
5614    pub cstmr_id: Option<Max35Text>,
5615    #[serde(rename = "CstmrDsgnt", skip_serializing_if = "Option::is_none")]
5616    pub cstmr_dsgnt: Option<Max2NumericText>,
5617    #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
5618    pub nm: Option<CardholderName3>,
5619    #[serde(rename = "Adr", skip_serializing_if = "Option::is_none")]
5620    pub adr: Option<Address2>,
5621    #[serde(rename = "CtctInf", skip_serializing_if = "Option::is_none")]
5622    pub ctct_inf: Option<Contact6>,
5623    #[validate(length(min = 0,))]
5624    #[serde(rename = "Crdntls", default)]
5625    pub crdntls: Vec<Credentials2>,
5626    #[serde(rename = "Ntlty", skip_serializing_if = "Option::is_none")]
5627    pub ntlty: Option<IsoMax3ACountryCode>,
5628    #[serde(rename = "CtryOfBirth", skip_serializing_if = "Option::is_none")]
5629    pub ctry_of_birth: Option<IsoMax3ACountryCode>,
5630    #[serde(rename = "DtOfBirth", skip_serializing_if = "Option::is_none")]
5631    pub dt_of_birth: Option<IsoDate>,
5632    #[serde(rename = "LclData", skip_serializing_if = "Option::is_none")]
5633    pub lcl_data: Option<LocalData3>,
5634    #[validate(length(min = 0,))]
5635    #[serde(rename = "AddtlData", default)]
5636    pub addtl_data: Vec<AdditionalData1>,
5637}
5638#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
5639pub enum UnitOfMeasure1Code {
5640    #[serde(rename = "PIEC")]
5641    Piec,
5642    #[serde(rename = "TONS")]
5643    Tons,
5644    #[serde(rename = "FOOT")]
5645    Foot,
5646    #[serde(rename = "GBGA")]
5647    Gbga,
5648    #[serde(rename = "USGA")]
5649    Usga,
5650    #[serde(rename = "GRAM")]
5651    Gram,
5652    #[serde(rename = "INCH")]
5653    Inch,
5654    #[serde(rename = "KILO")]
5655    Kilo,
5656    #[serde(rename = "PUND")]
5657    Pund,
5658    #[serde(rename = "METR")]
5659    Metr,
5660    #[serde(rename = "CMET")]
5661    Cmet,
5662    #[serde(rename = "MMET")]
5663    Mmet,
5664    #[serde(rename = "LITR")]
5665    Litr,
5666    #[serde(rename = "CELI")]
5667    Celi,
5668    #[serde(rename = "MILI")]
5669    Mili,
5670    #[serde(rename = "GBOU")]
5671    Gbou,
5672    #[serde(rename = "USOU")]
5673    Usou,
5674    #[serde(rename = "GBQA")]
5675    Gbqa,
5676    #[serde(rename = "USQA")]
5677    Usqa,
5678    #[serde(rename = "GBPI")]
5679    Gbpi,
5680    #[serde(rename = "USPI")]
5681    Uspi,
5682    #[serde(rename = "MILE")]
5683    Mile,
5684    #[serde(rename = "KMET")]
5685    Kmet,
5686    #[serde(rename = "YARD")]
5687    Yard,
5688    #[serde(rename = "SQKI")]
5689    Sqki,
5690    #[serde(rename = "HECT")]
5691    Hect,
5692    #[serde(rename = "ARES")]
5693    Ares,
5694    #[serde(rename = "SMET")]
5695    Smet,
5696    #[serde(rename = "SCMT")]
5697    Scmt,
5698    #[serde(rename = "SMIL")]
5699    Smil,
5700    #[serde(rename = "SQMI")]
5701    Sqmi,
5702    #[serde(rename = "SQYA")]
5703    Sqya,
5704    #[serde(rename = "SQFO")]
5705    Sqfo,
5706    #[serde(rename = "SQIN")]
5707    Sqin,
5708    #[serde(rename = "ACRE")]
5709    Acre,
5710    #[default]
5711    Unknown,
5712}
5713#[derive(
5714    Debug,
5715    Default,
5716    Clone,
5717    PartialEq,
5718    ::serde::Serialize,
5719    ::serde::Deserialize,
5720    ::derive_builder::Builder,
5721    ::validator::Validate,
5722)]
5723pub struct Max5000Binary {
5724    #[validate(length(min = 1, max = 5000,), regex = "MAX_5000_BINARY_REGEX")]
5725    pub value: String,
5726}
5727#[derive(
5728    Debug,
5729    Default,
5730    Clone,
5731    PartialEq,
5732    ::serde::Serialize,
5733    ::serde::Deserialize,
5734    ::derive_builder::Builder,
5735    ::validator::Validate,
5736)]
5737pub struct IsoYearMonth {
5738    #[validate(regex = "ISO_YEAR_MONTH_REGEX")]
5739    #[serde(rename = "$text")]
5740    pub value: String,
5741}
5742#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
5743pub enum QrCodePresentmentMode1Code {
5744    #[serde(rename = "CPMD")]
5745    Cpmd,
5746    #[serde(rename = "OTHN")]
5747    Othn,
5748    #[serde(rename = "OTHP")]
5749    Othp,
5750    #[serde(rename = "MPMD")]
5751    Mpmd,
5752    #[default]
5753    Unknown,
5754}
5755#[derive(
5756    Debug,
5757    Default,
5758    Clone,
5759    PartialEq,
5760    ::serde::Serialize,
5761    ::serde::Deserialize,
5762    ::derive_builder::Builder,
5763    ::validator::Validate,
5764)]
5765pub struct DisputeReference1 {
5766    #[serde(rename = "AssgnrNtty", skip_serializing_if = "Option::is_none")]
5767    pub assgnr_ntty: Option<PartyType32Code>,
5768    #[serde(rename = "OthrAssgnrNtty", skip_serializing_if = "Option::is_none")]
5769    pub othr_assgnr_ntty: Option<Max35Text>,
5770    #[validate(length(min = 1,))]
5771    #[serde(rename = "DsptId", default)]
5772    pub dspt_id: Vec<DisputeIdentification1>,
5773}
5774#[derive(
5775    Debug,
5776    Default,
5777    Clone,
5778    PartialEq,
5779    ::serde::Serialize,
5780    ::serde::Deserialize,
5781    ::derive_builder::Builder,
5782    ::validator::Validate,
5783)]
5784pub struct Transaction147 {
5785    #[serde(rename = "TxTp", skip_serializing_if = "Option::is_none")]
5786    pub tx_tp: Option<Iso8583TransactionTypeCode>,
5787    #[serde(rename = "TxSubTp", skip_serializing_if = "Option::is_none")]
5788    pub tx_sub_tp: Option<Max35Text>,
5789    #[serde(rename = "TxAttr", skip_serializing_if = "Option::is_none")]
5790    pub tx_attr: Option<TransactionAttribute2Code>,
5791    #[serde(rename = "OthrTxAttr", skip_serializing_if = "Option::is_none")]
5792    pub othr_tx_attr: Option<Max35Text>,
5793    #[validate(length(min = 0,))]
5794    #[serde(rename = "MsgRsn", default)]
5795    pub msg_rsn: Vec<Iso8583MessageReasonCode>,
5796    #[validate(length(min = 0,))]
5797    #[serde(rename = "AltrnMsgRsn", default)]
5798    pub altrn_msg_rsn: Vec<Max35Text>,
5799    #[serde(rename = "PreAuthstnTmLmt", skip_serializing_if = "Option::is_none")]
5800    pub pre_authstn_tm_lmt: Option<Max6NumericText>,
5801    #[validate(length(min = 0,))]
5802    #[serde(rename = "AddtlSvc", default)]
5803    pub addtl_svc: Vec<AdditionalService2>,
5804    #[serde(rename = "AssoctdDataRef", skip_serializing_if = "Option::is_none")]
5805    pub assoctd_data_ref: Option<Max70Text>,
5806    #[validate(length(min = 0,))]
5807    #[serde(rename = "SpclPrgrmmQlfctn", default)]
5808    pub spcl_prgrmm_qlfctn: Vec<SpecialProgrammeQualification1>,
5809    #[serde(rename = "TxId", skip_serializing_if = "Option::is_none")]
5810    pub tx_id: Option<TransactionIdentification18>,
5811    #[validate(length(min = 0,))]
5812    #[serde(rename = "DsptData", default)]
5813    pub dspt_data: Vec<DisputeData3>,
5814    #[serde(rename = "TxAmts", skip_serializing_if = "Option::is_none")]
5815    pub tx_amts: Option<TransactionAmounts2>,
5816    #[validate(length(min = 0,))]
5817    #[serde(rename = "AddtlAmt", default)]
5818    pub addtl_amt: Vec<AdditionalAmounts3>,
5819    #[validate(length(min = 0,))]
5820    #[serde(rename = "AddtlFee", default)]
5821    pub addtl_fee: Vec<AdditionalFee2>,
5822    #[validate(length(min = 0,))]
5823    #[serde(rename = "OrgnlAddtlFee", default)]
5824    pub orgnl_addtl_fee: Vec<AdditionalFee2>,
5825    #[validate(length(min = 0,))]
5826    #[serde(rename = "DpstDtls", default)]
5827    pub dpst_dtls: Vec<DepositDetails2>,
5828    #[serde(rename = "FndsSvcs", skip_serializing_if = "Option::is_none")]
5829    pub fnds_svcs: Option<FundingService2>,
5830    #[serde(rename = "AcctFr", skip_serializing_if = "Option::is_none")]
5831    pub acct_fr: Option<AccountDetails3>,
5832    #[serde(rename = "AcctTo", skip_serializing_if = "Option::is_none")]
5833    pub acct_to: Option<AccountDetails3>,
5834    #[serde(rename = "TxDesc", skip_serializing_if = "Option::is_none")]
5835    pub tx_desc: Option<Max1000Text>,
5836    #[validate(length(min = 0,))]
5837    #[serde(rename = "AddtlData", default)]
5838    pub addtl_data: Vec<AdditionalData1>,
5839}
5840#[derive(
5841    Debug,
5842    Default,
5843    Clone,
5844    PartialEq,
5845    ::serde::Serialize,
5846    ::serde::Deserialize,
5847    ::derive_builder::Builder,
5848    ::validator::Validate,
5849)]
5850pub struct CardProgrammeMode3 {
5851    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
5852    pub tp: Option<Max35Text>,
5853    #[validate]
5854    #[serde(rename = "Id")]
5855    pub id: Max35Text,
5856    #[validate(length(min = 0,))]
5857    #[serde(rename = "AddtlId", default)]
5858    pub addtl_id: Vec<AdditionalData1>,
5859}
5860#[derive(
5861    Debug,
5862    Default,
5863    Clone,
5864    PartialEq,
5865    ::serde::Serialize,
5866    ::serde::Deserialize,
5867    ::derive_builder::Builder,
5868    ::validator::Validate,
5869)]
5870pub struct RiskAssessmentDataEntityProvider1 {
5871    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
5872    pub tp: Option<PartyType28Code>,
5873    #[serde(rename = "OthrTp", skip_serializing_if = "Option::is_none")]
5874    pub othr_tp: Option<Max35Text>,
5875}
5876#[derive(
5877    Debug,
5878    Default,
5879    Clone,
5880    PartialEq,
5881    ::serde::Serialize,
5882    ::serde::Deserialize,
5883    ::derive_builder::Builder,
5884    ::validator::Validate,
5885)]
5886pub struct AdditionalInformation29 {
5887    #[serde(rename = "Rcpt", skip_serializing_if = "Option::is_none")]
5888    pub rcpt: Option<PartyType22Code>,
5889    #[serde(rename = "OthrRcpt", skip_serializing_if = "Option::is_none")]
5890    pub othr_rcpt: Option<Max35Text>,
5891    #[validate(length(min = 0,))]
5892    #[serde(rename = "Trgt", default)]
5893    pub trgt: Vec<UserInterface6Code>,
5894    #[serde(rename = "OthrTrgt", skip_serializing_if = "Option::is_none")]
5895    pub othr_trgt: Option<Max35Text>,
5896    #[serde(rename = "Frmt", skip_serializing_if = "Option::is_none")]
5897    pub frmt: Option<OutputFormat4Code>,
5898    #[serde(rename = "OthrFrmt", skip_serializing_if = "Option::is_none")]
5899    pub othr_frmt: Option<Max35Text>,
5900    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
5901    pub tp: Option<Max35Text>,
5902    #[serde(rename = "Lang")]
5903    pub lang: IsoMax3ALanguageCode,
5904    #[validate]
5905    #[serde(rename = "Val")]
5906    pub val: Max20KText,
5907}
5908#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
5909pub enum ProductCodeType1Code {
5910    #[serde(rename = "EA13")]
5911    Ea13,
5912    #[serde(rename = "EAN8")]
5913    Ean8,
5914    #[serde(rename = "GTIN")]
5915    Gtin,
5916    #[serde(rename = "OTHR")]
5917    Othr,
5918    #[serde(rename = "PLUP")]
5919    Plup,
5920    #[serde(rename = "RS14")]
5921    Rs14,
5922    #[serde(rename = "UPCA")]
5923    Upca,
5924    #[serde(rename = "UPCE")]
5925    Upce,
5926    #[default]
5927    Unknown,
5928}
5929#[derive(
5930    Debug,
5931    Default,
5932    Clone,
5933    PartialEq,
5934    ::serde::Serialize,
5935    ::serde::Deserialize,
5936    ::derive_builder::Builder,
5937    ::validator::Validate,
5938)]
5939pub struct Max15NumericText {
5940    #[validate(regex = "MAX_15_NUMERIC_TEXT_REGEX")]
5941    #[serde(rename = "$text")]
5942    pub value: String,
5943}
5944#[derive(
5945    Debug,
5946    Default,
5947    Clone,
5948    PartialEq,
5949    ::serde::Serialize,
5950    ::serde::Deserialize,
5951    ::derive_builder::Builder,
5952    ::validator::Validate,
5953)]
5954pub struct Sale2 {
5955    #[serde(rename = "Summry", skip_serializing_if = "Option::is_none")]
5956    pub summry: Option<SaleSummary1>,
5957    #[validate(length(min = 0,))]
5958    #[serde(rename = "LineItm", default)]
5959    pub line_itm: Vec<SaleItem3>,
5960}
5961#[derive(
5962    Debug,
5963    Default,
5964    Clone,
5965    PartialEq,
5966    ::serde::Serialize,
5967    ::serde::Deserialize,
5968    ::derive_builder::Builder,
5969    ::validator::Validate,
5970)]
5971pub struct JourneyInformation1 {
5972    #[serde(rename = "JrnyTp", skip_serializing_if = "Option::is_none")]
5973    pub jrny_tp: Option<JourneyType1Code>,
5974    #[serde(rename = "JrnyData", skip_serializing_if = "Option::is_none")]
5975    pub jrny_data: Option<Max35Text>,
5976    #[serde(rename = "DtAndTm", skip_serializing_if = "Option::is_none")]
5977    pub dt_and_tm: Option<IsoDateTime>,
5978}
5979#[derive(
5980    Debug,
5981    Default,
5982    Clone,
5983    PartialEq,
5984    ::serde::Serialize,
5985    ::serde::Deserialize,
5986    ::derive_builder::Builder,
5987    ::validator::Validate,
5988)]
5989pub struct Customer8 {
5990    #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
5991    pub nm: Option<Max70Text>,
5992    #[validate]
5993    #[serde(rename = "Id")]
5994    pub id: PartyIdentification208,
5995    #[serde(rename = "CstmrFileRefNb", skip_serializing_if = "Option::is_none")]
5996    pub cstmr_file_ref_nb: Option<Max70Text>,
5997    #[serde(rename = "Age", skip_serializing_if = "Option::is_none")]
5998    pub age: Option<Max2NumericText>,
5999    #[serde(rename = "Adr", skip_serializing_if = "Option::is_none")]
6000    pub adr: Option<Address2>,
6001    #[serde(rename = "Ctct", skip_serializing_if = "Option::is_none")]
6002    pub ctct: Option<Contact6>,
6003}
6004#[derive(
6005    Debug,
6006    Default,
6007    Clone,
6008    PartialEq,
6009    ::serde::Serialize,
6010    ::serde::Deserialize,
6011    ::derive_builder::Builder,
6012    ::validator::Validate,
6013)]
6014pub struct FleetDiscountTotals1 {
6015    #[serde(rename = "TtlAmt", skip_serializing_if = "Option::is_none")]
6016    pub ttl_amt: Option<ImpliedCurrencyAndAmount>,
6017    #[serde(rename = "FuelAmt", skip_serializing_if = "Option::is_none")]
6018    pub fuel_amt: Option<ImpliedCurrencyAndAmount>,
6019    #[serde(rename = "NonFuelAmt", skip_serializing_if = "Option::is_none")]
6020    pub non_fuel_amt: Option<ImpliedCurrencyAndAmount>,
6021}
6022#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
6023pub enum Algorithm8Code {
6024    #[serde(rename = "MGF1")]
6025    Mgf1,
6026    #[default]
6027    Unknown,
6028}
6029#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
6030pub enum LegalStructure1Code {
6031    #[serde(rename = "STAE")]
6032    Stae,
6033    #[serde(rename = "PVIN")]
6034    Pvin,
6035    #[serde(rename = "MUNI")]
6036    Muni,
6037    #[serde(rename = "CNTY")]
6038    Cnty,
6039    #[serde(rename = "NATI")]
6040    Nati,
6041    #[default]
6042    Unknown,
6043}
6044#[derive(
6045    Debug,
6046    Default,
6047    Clone,
6048    PartialEq,
6049    ::serde::Serialize,
6050    ::serde::Deserialize,
6051    ::derive_builder::Builder,
6052    ::validator::Validate,
6053)]
6054pub struct Max40KText {
6055    #[validate(length(min = 1, max = 40000,))]
6056    #[serde(rename = "$text")]
6057    pub value: String,
6058}
6059#[derive(
6060    Debug,
6061    Default,
6062    Clone,
6063    PartialEq,
6064    ::serde::Serialize,
6065    ::serde::Deserialize,
6066    ::derive_builder::Builder,
6067    ::validator::Validate,
6068)]
6069pub struct CardProgramme2 {
6070    #[validate(length(min = 0,))]
6071    #[serde(rename = "CardPrgrmmPropsd", default)]
6072    pub card_prgrmm_propsd: Vec<CardProgrammeMode2>,
6073    #[serde(rename = "CardPrgrmmApld", skip_serializing_if = "Option::is_none")]
6074    pub card_prgrmm_apld: Option<CardProgrammeMode3>,
6075}
6076#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
6077pub enum PartyType32Code {
6078    #[serde(rename = "ACQR")]
6079    Acqr,
6080    #[serde(rename = "AGNT")]
6081    Agnt,
6082    #[serde(rename = "ISUR")]
6083    Isur,
6084    #[serde(rename = "OTHN")]
6085    Othn,
6086    #[serde(rename = "OTHP")]
6087    Othp,
6088    #[default]
6089    Unknown,
6090}
6091#[derive(
6092    Debug,
6093    Default,
6094    Clone,
6095    PartialEq,
6096    ::serde::Serialize,
6097    ::serde::Deserialize,
6098    ::derive_builder::Builder,
6099    ::validator::Validate,
6100)]
6101pub struct Max280Text {
6102    #[validate(length(min = 1, max = 280,))]
6103    #[serde(rename = "$text")]
6104    pub value: String,
6105}
6106#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
6107pub enum InstalmentPeriod1Code {
6108    #[serde(rename = "MNTH")]
6109    Mnth,
6110    #[serde(rename = "ANNU")]
6111    Annu,
6112    #[default]
6113    Unknown,
6114}
6115#[derive(
6116    Debug,
6117    Default,
6118    Clone,
6119    PartialEq,
6120    ::serde::Serialize,
6121    ::serde::Deserialize,
6122    ::derive_builder::Builder,
6123    ::validator::Validate,
6124)]
6125pub struct AlgorithmIdentification26 {
6126    #[serde(rename = "Algo")]
6127    pub algo: Algorithm8Code,
6128    #[serde(rename = "Param", skip_serializing_if = "Option::is_none")]
6129    pub param: Option<Algorithm5Code>,
6130}
6131#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
6132pub enum CompanyAssigner2Code {
6133    #[serde(rename = "ASSO")]
6134    Asso,
6135    #[serde(rename = "AUTH")]
6136    Auth,
6137    #[serde(rename = "CPNY")]
6138    Cpny,
6139    #[serde(rename = "LEII")]
6140    Leii,
6141    #[serde(rename = "TRAG")]
6142    Trag,
6143    #[serde(rename = "OTHP")]
6144    Othp,
6145    #[serde(rename = "OTHN")]
6146    Othn,
6147    #[default]
6148    Unknown,
6149}
6150#[derive(
6151    Debug,
6152    Default,
6153    Clone,
6154    PartialEq,
6155    ::serde::Serialize,
6156    ::serde::Deserialize,
6157    ::derive_builder::Builder,
6158    ::validator::Validate,
6159)]
6160pub struct Max6NumberFraction2 {
6161    #[serde(rename = "$text")]
6162    pub value: f64,
6163}
6164#[derive(
6165    Debug,
6166    Default,
6167    Clone,
6168    PartialEq,
6169    ::serde::Serialize,
6170    ::serde::Deserialize,
6171    ::derive_builder::Builder,
6172    ::validator::Validate,
6173)]
6174pub struct DecimalNumber {
6175    #[serde(rename = "$text")]
6176    pub value: f64,
6177}
6178#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
6179pub enum UserInterface1Code {
6180    #[serde(rename = "CDSP")]
6181    Cdsp,
6182    #[serde(rename = "CRCP")]
6183    Crcp,
6184    #[serde(rename = "MDSP")]
6185    Mdsp,
6186    #[serde(rename = "MRCP")]
6187    Mrcp,
6188    #[default]
6189    Unknown,
6190}
6191#[derive(
6192    Debug,
6193    Default,
6194    Clone,
6195    PartialEq,
6196    ::serde::Serialize,
6197    ::serde::Deserialize,
6198    ::derive_builder::Builder,
6199    ::validator::Validate,
6200)]
6201pub struct GenericIdentification48 {
6202    #[validate]
6203    #[serde(rename = "Id")]
6204    pub id: Max35Text,
6205    #[validate]
6206    #[serde(rename = "Vrsn")]
6207    pub vrsn: Max35Text,
6208    #[validate]
6209    #[serde(rename = "Issr")]
6210    pub issr: Max35Text,
6211}
6212#[derive(
6213    Debug,
6214    Default,
6215    Clone,
6216    PartialEq,
6217    ::serde::Serialize,
6218    ::serde::Deserialize,
6219    ::derive_builder::Builder,
6220    ::validator::Validate,
6221)]
6222pub struct Address3 {
6223    #[serde(rename = "AdrLine1", skip_serializing_if = "Option::is_none")]
6224    pub adr_line_1: Option<Max200Text>,
6225    #[serde(rename = "AdrLine2", skip_serializing_if = "Option::is_none")]
6226    pub adr_line_2: Option<Max200Text>,
6227    #[serde(rename = "StrtNm", skip_serializing_if = "Option::is_none")]
6228    pub strt_nm: Option<Max200Text>,
6229    #[serde(rename = "BldgNb", skip_serializing_if = "Option::is_none")]
6230    pub bldg_nb: Option<Max35Text>,
6231    #[serde(rename = "PstlCd", skip_serializing_if = "Option::is_none")]
6232    pub pstl_cd: Option<Max35Text>,
6233    #[serde(rename = "TwnNm", skip_serializing_if = "Option::is_none")]
6234    pub twn_nm: Option<Max100Text>,
6235    #[serde(rename = "CtrySubDvsnMnrNm", skip_serializing_if = "Option::is_none")]
6236    pub ctry_sub_dvsn_mnr_nm: Option<Max100Text>,
6237    #[serde(rename = "CtrySubDvsnMjrNm", skip_serializing_if = "Option::is_none")]
6238    pub ctry_sub_dvsn_mjr_nm: Option<Max100Text>,
6239    #[serde(rename = "Ctry", skip_serializing_if = "Option::is_none")]
6240    pub ctry: Option<IsoMax3ACountryCode>,
6241}
6242#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
6243pub enum VerificationEntity2Code {
6244    #[serde(rename = "MERC")]
6245    Merc,
6246    #[serde(rename = "ACQR")]
6247    Acqr,
6248    #[serde(rename = "AGNT")]
6249    Agnt,
6250    #[serde(rename = "ISSR")]
6251    Issr,
6252    #[serde(rename = "OTHN")]
6253    Othn,
6254    #[serde(rename = "OTHP")]
6255    Othp,
6256    #[serde(rename = "CDAD")]
6257    Cdad,
6258    #[serde(rename = "ICCA")]
6259    Icca,
6260    #[default]
6261    Unknown,
6262}
6263#[derive(
6264    Debug,
6265    Default,
6266    Clone,
6267    PartialEq,
6268    ::serde::Serialize,
6269    ::serde::Deserialize,
6270    ::derive_builder::Builder,
6271    ::validator::Validate,
6272)]
6273pub struct AdditionalData2 {
6274    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
6275    pub tp: Option<Max35Text>,
6276    #[validate(length(min = 0,))]
6277    #[serde(rename = "Dtls", default)]
6278    pub dtls: Vec<AdditionalData1>,
6279}
6280#[derive(
6281    Debug,
6282    Default,
6283    Clone,
6284    PartialEq,
6285    ::serde::Serialize,
6286    ::serde::Deserialize,
6287    ::derive_builder::Builder,
6288    ::validator::Validate,
6289)]
6290pub struct FundingSource2 {
6291    #[serde(rename = "SrcTp", skip_serializing_if = "Option::is_none")]
6292    pub src_tp: Option<FundingSourceType2Code>,
6293    #[serde(rename = "OthrSrcTp", skip_serializing_if = "Option::is_none")]
6294    pub othr_src_tp: Option<Max35Text>,
6295    #[serde(rename = "Ref", skip_serializing_if = "Option::is_none")]
6296    pub r#ref: Option<Max35Text>,
6297}
6298#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
6299pub enum Frequency18Code {
6300    #[serde(rename = "YEAR")]
6301    Year,
6302    #[serde(rename = "DAIL")]
6303    Dail,
6304    #[serde(rename = "FRTN")]
6305    Frtn,
6306    #[serde(rename = "MNTH")]
6307    Mnth,
6308    #[serde(rename = "QURT")]
6309    Qurt,
6310    #[serde(rename = "MIAN")]
6311    Mian,
6312    #[serde(rename = "TEND")]
6313    Tend,
6314    #[serde(rename = "WEEK")]
6315    Week,
6316    #[serde(rename = "TWWK")]
6317    Twwk,
6318    #[default]
6319    Unknown,
6320}
6321#[derive(
6322    Debug,
6323    Default,
6324    Clone,
6325    PartialEq,
6326    ::serde::Serialize,
6327    ::serde::Deserialize,
6328    ::derive_builder::Builder,
6329    ::validator::Validate,
6330)]
6331pub struct Max40Text {
6332    #[validate(length(min = 1, max = 40,))]
6333    #[serde(rename = "$text")]
6334    pub value: String,
6335}
6336#[derive(
6337    Debug,
6338    Default,
6339    Clone,
6340    PartialEq,
6341    ::serde::Serialize,
6342    ::serde::Deserialize,
6343    ::derive_builder::Builder,
6344    ::validator::Validate,
6345)]
6346pub struct PhoneNumber {
6347    #[validate(regex = "PHONE_NUMBER_REGEX")]
6348    #[serde(rename = "$text")]
6349    pub value: String,
6350}
6351#[derive(
6352    Debug,
6353    Default,
6354    Clone,
6355    PartialEq,
6356    ::serde::Serialize,
6357    ::serde::Deserialize,
6358    ::derive_builder::Builder,
6359    ::validator::Validate,
6360)]
6361pub struct Parameter12 {
6362    #[serde(rename = "NcrptnFrmt", skip_serializing_if = "Option::is_none")]
6363    pub ncrptn_frmt: Option<EncryptionFormat2Code>,
6364    #[serde(rename = "InitlstnVctr", skip_serializing_if = "Option::is_none")]
6365    pub initlstn_vctr: Option<Max500Binary>,
6366    #[serde(rename = "BPddg", skip_serializing_if = "Option::is_none")]
6367    pub b_pddg: Option<BytePadding1Code>,
6368}
6369#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
6370pub enum OfficialDocumentType1Code {
6371    #[serde(rename = "ARNU")]
6372    Arnu,
6373    #[serde(rename = "AUTH")]
6374    Auth,
6375    #[serde(rename = "DIPL")]
6376    Dipl,
6377    #[serde(rename = "DVLC")]
6378    Dvlc,
6379    #[serde(rename = "EURO")]
6380    Euro,
6381    #[serde(rename = "IDEN")]
6382    Iden,
6383    #[serde(rename = "INTE")]
6384    Inte,
6385    #[serde(rename = "INPO")]
6386    Inpo,
6387    #[serde(rename = "LZPR")]
6388    Lzpr,
6389    #[serde(rename = "OTHN")]
6390    Othn,
6391    #[serde(rename = "OTHP")]
6392    Othp,
6393    #[serde(rename = "PASS")]
6394    Pass,
6395    #[serde(rename = "VISA")]
6396    Visa,
6397    #[serde(rename = "PERM")]
6398    Perm,
6399    #[serde(rename = "REFU")]
6400    Refu,
6401    #[default]
6402    Unknown,
6403}
6404#[derive(
6405    Debug,
6406    Default,
6407    Clone,
6408    PartialEq,
6409    ::serde::Serialize,
6410    ::serde::Deserialize,
6411    ::derive_builder::Builder,
6412    ::validator::Validate,
6413)]
6414pub struct ImpliedCurrencyAndAmount {
6415    #[validate(range(min = 0,))]
6416    #[serde(rename = "$text")]
6417    pub value: f64,
6418}
6419#[derive(
6420    Debug,
6421    Default,
6422    Clone,
6423    PartialEq,
6424    ::serde::Serialize,
6425    ::serde::Deserialize,
6426    ::derive_builder::Builder,
6427    ::validator::Validate,
6428)]
6429pub struct DeviceIdentification1 {
6430    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
6431    pub tp: Option<DeviceIdentificationType1Code>,
6432    #[serde(rename = "OthrTp", skip_serializing_if = "Option::is_none")]
6433    pub othr_tp: Option<Max35Text>,
6434    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
6435    pub id: Option<Max70Text>,
6436    #[serde(rename = "Assgnr", skip_serializing_if = "Option::is_none")]
6437    pub assgnr: Option<Max70Text>,
6438}
6439#[derive(
6440    Debug,
6441    Default,
6442    Clone,
6443    PartialEq,
6444    ::serde::Serialize,
6445    ::serde::Deserialize,
6446    ::derive_builder::Builder,
6447    ::validator::Validate,
6448)]
6449pub struct Max20KText {
6450    #[validate(length(min = 1, max = 20000,))]
6451    #[serde(rename = "$text")]
6452    pub value: String,
6453}
6454#[derive(
6455    Debug,
6456    Default,
6457    Clone,
6458    PartialEq,
6459    ::serde::Serialize,
6460    ::serde::Deserialize,
6461    ::derive_builder::Builder,
6462    ::validator::Validate,
6463)]
6464pub struct SaleContext8 {
6465    #[serde(rename = "SaleId", skip_serializing_if = "Option::is_none")]
6466    pub sale_id: Option<Max35Text>,
6467    #[serde(rename = "SaleRefId", skip_serializing_if = "Option::is_none")]
6468    pub sale_ref_id: Option<Max35Text>,
6469    #[serde(rename = "SaleRefNb", skip_serializing_if = "Option::is_none")]
6470    pub sale_ref_nb: Option<Max35Text>,
6471    #[serde(rename = "GoodsAndSvcsTp", skip_serializing_if = "Option::is_none")]
6472    pub goods_and_svcs_tp: Option<GoodsAndServices1Code>,
6473    #[serde(rename = "GoodAndSvcsSubTp", skip_serializing_if = "Option::is_none")]
6474    pub good_and_svcs_sub_tp: Option<GoodsAndServicesSubType1Code>,
6475    #[serde(
6476        rename = "GoodAndSvcsOthrSubTp",
6477        skip_serializing_if = "Option::is_none"
6478    )]
6479    pub good_and_svcs_othr_sub_tp: Option<Max35Text>,
6480    #[serde(
6481        rename = "GoodAndSvcDlvryChanl",
6482        skip_serializing_if = "Option::is_none"
6483    )]
6484    pub good_and_svc_dlvry_chanl: Option<GoodAndServiceDeliveryChannel1Code>,
6485    #[serde(
6486        rename = "OthrGoodAndSvcDlvryChanl",
6487        skip_serializing_if = "Option::is_none"
6488    )]
6489    pub othr_good_and_svc_dlvry_chanl: Option<Max35Text>,
6490    #[serde(
6491        rename = "GoodAndSvcDlvrySchdl",
6492        skip_serializing_if = "Option::is_none"
6493    )]
6494    pub good_and_svc_dlvry_schdl: Option<GoodAndServiceDeliverySchedule1Code>,
6495    #[serde(
6496        rename = "OthrGoodAndSvcDlvrySchdl",
6497        skip_serializing_if = "Option::is_none"
6498    )]
6499    pub othr_good_and_svc_dlvry_schdl: Option<Max35Text>,
6500    #[serde(rename = "SpltPmtInd", skip_serializing_if = "Option::is_none")]
6501    pub splt_pmt_ind: Option<TrueFalseIndicator>,
6502    #[serde(rename = "RctReqInd", skip_serializing_if = "Option::is_none")]
6503    pub rct_req_ind: Option<TrueFalseIndicator>,
6504    #[validate(length(min = 0,))]
6505    #[serde(rename = "RctTp", default)]
6506    pub rct_tp: Vec<ReceiptType1Code>,
6507    #[serde(rename = "RctDstn", skip_serializing_if = "Option::is_none")]
6508    pub rct_dstn: Option<Max70Text>,
6509    #[validate(length(min = 0,))]
6510    #[serde(rename = "AddtlData", default)]
6511    pub addtl_data: Vec<AdditionalData1>,
6512}
6513#[derive(
6514    Debug,
6515    Default,
6516    Clone,
6517    PartialEq,
6518    ::serde::Serialize,
6519    ::serde::Deserialize,
6520    ::derive_builder::Builder,
6521    ::validator::Validate,
6522)]
6523pub struct TelecomServices2 {
6524    #[serde(rename = "Summry", skip_serializing_if = "Option::is_none")]
6525    pub summry: Option<TelecomServicesSummary2>,
6526    #[validate(length(min = 0,))]
6527    #[serde(rename = "LineItm", default)]
6528    pub line_itm: Vec<TelecomServicesLineItem2>,
6529}
6530#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
6531pub enum TypeOfAmount19Code {
6532    #[serde(rename = "CONN")]
6533    Conn,
6534    #[serde(rename = "INSU")]
6535    Insu,
6536    #[serde(rename = "LNDS")]
6537    Lnds,
6538    #[serde(rename = "MISC")]
6539    Misc,
6540    #[serde(rename = "OTHN")]
6541    Othn,
6542    #[serde(rename = "OTHP")]
6543    Othp,
6544    #[serde(rename = "USGE")]
6545    Usge,
6546    #[default]
6547    Unknown,
6548}
6549#[derive(
6550    Debug,
6551    Default,
6552    Clone,
6553    PartialEq,
6554    ::serde::Serialize,
6555    ::serde::Deserialize,
6556    ::derive_builder::Builder,
6557    ::validator::Validate,
6558)]
6559pub struct KeyTransport5 {
6560    #[serde(rename = "Vrsn", skip_serializing_if = "Option::is_none")]
6561    pub vrsn: Option<Number>,
6562    #[serde(rename = "RcptId")]
6563    pub rcpt_id: Recipient5Choice,
6564    #[validate]
6565    #[serde(rename = "KeyNcrptnAlgo")]
6566    pub key_ncrptn_algo: AlgorithmIdentification19,
6567    #[validate]
6568    #[serde(rename = "NcrptdKey")]
6569    pub ncrptd_key: Max5000Binary,
6570}
6571#[derive(
6572    Debug,
6573    Default,
6574    Clone,
6575    PartialEq,
6576    ::serde::Serialize,
6577    ::serde::Deserialize,
6578    ::derive_builder::Builder,
6579    ::validator::Validate,
6580)]
6581pub struct LocalData2 {
6582    #[serde(rename = "Lang")]
6583    pub lang: IsoMax3ALanguageCode,
6584    #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
6585    pub nm: Option<Max70Text>,
6586    #[serde(rename = "Adr", skip_serializing_if = "Option::is_none")]
6587    pub adr: Option<Address3>,
6588    #[serde(rename = "AddtlCtctInf", skip_serializing_if = "Option::is_none")]
6589    pub addtl_ctct_inf: Option<Max512Text>,
6590    #[validate(length(min = 0,))]
6591    #[serde(rename = "AddtlData", default)]
6592    pub addtl_data: Vec<AdditionalData1>,
6593}
6594#[derive(
6595    Debug,
6596    Default,
6597    Clone,
6598    PartialEq,
6599    ::serde::Serialize,
6600    ::serde::Deserialize,
6601    ::derive_builder::Builder,
6602    ::validator::Validate,
6603)]
6604pub struct Vehicle2 {
6605    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
6606    pub tp: Option<Max35Text>,
6607    #[serde(rename = "NtryMd", skip_serializing_if = "Option::is_none")]
6608    pub ntry_md: Option<CardDataReading5Code>,
6609    #[validate]
6610    #[serde(rename = "Data")]
6611    pub data: Max35Text,
6612}
6613#[derive(
6614    Debug,
6615    Default,
6616    Clone,
6617    PartialEq,
6618    ::serde::Serialize,
6619    ::serde::Deserialize,
6620    ::derive_builder::Builder,
6621    ::validator::Validate,
6622)]
6623pub struct TravelAgency3 {
6624    #[serde(rename = "Cpny", skip_serializing_if = "Option::is_none")]
6625    pub cpny: Option<PartyIdentification261>,
6626    #[validate(length(min = 0,))]
6627    #[serde(rename = "TrvlPackg", default)]
6628    pub trvl_packg: Vec<TravelAgencyPackage1>,
6629    #[serde(rename = "AddtlData", skip_serializing_if = "Option::is_none")]
6630    pub addtl_data: Option<Max350Text>,
6631}
6632#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
6633pub enum PinEntrySecurityCharacteristic1Code {
6634    #[serde(rename = "OTHN")]
6635    Othn,
6636    #[serde(rename = "OTHP")]
6637    Othp,
6638    #[serde(rename = "SECS")]
6639    Secs,
6640    #[serde(rename = "SECH")]
6641    Sech,
6642    #[default]
6643    Unknown,
6644}
6645#[derive(
6646    Debug,
6647    Default,
6648    Clone,
6649    PartialEq,
6650    ::serde::Serialize,
6651    ::serde::Deserialize,
6652    ::derive_builder::Builder,
6653    ::validator::Validate,
6654)]
6655pub struct Max32HexBinaryText {
6656    #[validate(regex = "MAX_32_HEX_BINARY_TEXT_REGEX")]
6657    #[serde(rename = "$text")]
6658    pub value: String,
6659}
6660#[derive(
6661    Debug,
6662    Default,
6663    Clone,
6664    PartialEq,
6665    ::serde::Serialize,
6666    ::serde::Deserialize,
6667    ::derive_builder::Builder,
6668    ::validator::Validate,
6669)]
6670pub struct LoyaltyProgramme2 {
6671    #[serde(rename = "PrgrmmTp", skip_serializing_if = "Option::is_none")]
6672    pub prgrmm_tp: Option<Max35Text>,
6673    #[serde(rename = "PrgmId", skip_serializing_if = "Option::is_none")]
6674    pub prgm_id: Option<Max70Text>,
6675    #[serde(rename = "PtcptId", skip_serializing_if = "Option::is_none")]
6676    pub ptcpt_id: Option<Max70Text>,
6677}
6678#[derive(
6679    Debug,
6680    Default,
6681    Clone,
6682    PartialEq,
6683    ::serde::Serialize,
6684    ::serde::Deserialize,
6685    ::derive_builder::Builder,
6686    ::validator::Validate,
6687)]
6688pub struct TrueFalseIndicator {
6689    #[serde(rename = "$text")]
6690    pub value: bool,
6691}
6692#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
6693pub enum Frequency12Code {
6694    #[serde(rename = "YEAR")]
6695    Year,
6696    #[serde(rename = "DAIL")]
6697    Dail,
6698    #[serde(rename = "FRTN")]
6699    Frtn,
6700    #[serde(rename = "MNTH")]
6701    Mnth,
6702    #[serde(rename = "QURT")]
6703    Qurt,
6704    #[serde(rename = "MIAN")]
6705    Mian,
6706    #[serde(rename = "TEND")]
6707    Tend,
6708    #[serde(rename = "WEEK")]
6709    Week,
6710    #[default]
6711    Unknown,
6712}
6713#[derive(
6714    Debug,
6715    Default,
6716    Clone,
6717    PartialEq,
6718    ::serde::Serialize,
6719    ::serde::Deserialize,
6720    ::derive_builder::Builder,
6721    ::validator::Validate,
6722)]
6723pub struct Max35Binary {
6724    #[validate(length(min = 1, max = 35,), regex = "MAX_35_BINARY_REGEX")]
6725    pub value: String,
6726}
6727#[derive(
6728    Debug,
6729    Default,
6730    Clone,
6731    PartialEq,
6732    ::serde::Serialize,
6733    ::serde::Deserialize,
6734    ::derive_builder::Builder,
6735    ::validator::Validate,
6736)]
6737pub struct Max200Text {
6738    #[validate(length(min = 1, max = 200,))]
6739    #[serde(rename = "$text")]
6740    pub value: String,
6741}
6742#[derive(
6743    Debug,
6744    Default,
6745    Clone,
6746    PartialEq,
6747    ::serde::Serialize,
6748    ::serde::Deserialize,
6749    ::derive_builder::Builder,
6750    ::validator::Validate,
6751)]
6752pub struct Max37Text {
6753    #[validate(length(min = 1, max = 37,))]
6754    #[serde(rename = "$text")]
6755    pub value: String,
6756}
6757#[derive(
6758    Debug,
6759    Default,
6760    Clone,
6761    PartialEq,
6762    ::serde::Serialize,
6763    ::serde::Deserialize,
6764    ::derive_builder::Builder,
6765    ::validator::Validate,
6766)]
6767pub struct AmountDetails2 {
6768    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
6769    pub tp: Option<TypeOfAmount20Code>,
6770    #[serde(rename = "OthrTp", skip_serializing_if = "Option::is_none")]
6771    pub othr_tp: Option<Max35Text>,
6772    #[validate]
6773    #[serde(rename = "Amt")]
6774    pub amt: ImpliedCurrencyAndAmount,
6775    #[serde(rename = "CdtDbt", skip_serializing_if = "Option::is_none")]
6776    pub cdt_dbt: Option<CreditDebit3Code>,
6777    #[validate(length(min = 0,))]
6778    #[serde(rename = "Tax", default)]
6779    pub tax: Vec<Tax39>,
6780}
6781#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
6782pub enum TemporaryServicesCharge1Code {
6783    #[serde(rename = "WKND")]
6784    Wknd,
6785    #[serde(rename = "REGL")]
6786    Regl,
6787    #[serde(rename = "OVRT")]
6788    Ovrt,
6789    #[serde(rename = "OTHP")]
6790    Othp,
6791    #[serde(rename = "OTHN")]
6792    Othn,
6793    #[serde(rename = "ONCL")]
6794    Oncl,
6795    #[serde(rename = "NITE")]
6796    Nite,
6797    #[serde(rename = "HOLI")]
6798    Holi,
6799    #[serde(rename = "HAZD")]
6800    Hazd,
6801    #[default]
6802    Unknown,
6803}
6804#[derive(
6805    Debug,
6806    Default,
6807    Clone,
6808    PartialEq,
6809    ::serde::Serialize,
6810    ::serde::Deserialize,
6811    ::derive_builder::Builder,
6812    ::validator::Validate,
6813)]
6814pub struct AdditionalService2 {
6815    #[serde(rename = "Tp")]
6816    pub tp: AdditionalServiceType2Code,
6817    #[serde(rename = "OthrTp", skip_serializing_if = "Option::is_none")]
6818    pub othr_tp: Option<Max35Text>,
6819    #[serde(rename = "Rslt", skip_serializing_if = "Option::is_none")]
6820    pub rslt: Option<AdditionalServiceResult1Code>,
6821    #[serde(rename = "OthrRslt", skip_serializing_if = "Option::is_none")]
6822    pub othr_rslt: Option<Max35Text>,
6823    #[validate(length(min = 0,))]
6824    #[serde(rename = "SvcDtl", default)]
6825    pub svc_dtl: Vec<AdditionalData1>,
6826}
6827#[derive(
6828    Debug,
6829    Default,
6830    Clone,
6831    PartialEq,
6832    ::serde::Serialize,
6833    ::serde::Deserialize,
6834    ::derive_builder::Builder,
6835    ::validator::Validate,
6836)]
6837pub struct FleetLineItem4 {
6838    #[validate]
6839    #[serde(rename = "FuelInd")]
6840    pub fuel_ind: TrueFalseIndicator,
6841    #[serde(rename = "SvcTp", skip_serializing_if = "Option::is_none")]
6842    pub svc_tp: Option<FleetServiceType1Code>,
6843    #[serde(rename = "FuelBrndCd", skip_serializing_if = "Option::is_none")]
6844    pub fuel_brnd_cd: Option<Max4Text>,
6845    #[serde(rename = "FleetPdctCd", skip_serializing_if = "Option::is_none")]
6846    pub fleet_pdct_cd: Option<Max4Text>,
6847    #[serde(rename = "FleetPdctCtgy", skip_serializing_if = "Option::is_none")]
6848    pub fleet_pdct_ctgy: Option<Max35Text>,
6849    #[serde(rename = "FleetPdctQlfr", skip_serializing_if = "Option::is_none")]
6850    pub fleet_pdct_qlfr: Option<Max6Text>,
6851    #[serde(rename = "FleetPdctCdAssgnr", skip_serializing_if = "Option::is_none")]
6852    pub fleet_pdct_cd_assgnr: Option<Max35Text>,
6853    #[serde(rename = "UnitPricTaxInd", skip_serializing_if = "Option::is_none")]
6854    pub unit_pric_tax_ind: Option<TrueFalseIndicator>,
6855    #[serde(rename = "UnitPric", skip_serializing_if = "Option::is_none")]
6856    pub unit_pric: Option<ImpliedCurrencyAndAmount>,
6857    #[serde(rename = "UnitOfMeasr", skip_serializing_if = "Option::is_none")]
6858    pub unit_of_measr: Option<UnitOfMeasure1Code>,
6859    #[serde(rename = "OthrUnitOfMeasr", skip_serializing_if = "Option::is_none")]
6860    pub othr_unit_of_measr: Option<Max35Text>,
6861    #[serde(rename = "PdctQty", skip_serializing_if = "Option::is_none")]
6862    pub pdct_qty: Option<DecimalNumber>,
6863    #[serde(rename = "DscntAmt", skip_serializing_if = "Option::is_none")]
6864    pub dscnt_amt: Option<ImpliedCurrencyAndAmount>,
6865    #[serde(rename = "NonTaxblInd", skip_serializing_if = "Option::is_none")]
6866    pub non_taxbl_ind: Option<TrueFalseIndicator>,
6867    #[validate(length(min = 0,))]
6868    #[serde(rename = "Tax", default)]
6869    pub tax: Vec<Tax39>,
6870    #[serde(rename = "TtlAmtExclgTax", skip_serializing_if = "Option::is_none")]
6871    pub ttl_amt_exclg_tax: Option<ImpliedCurrencyAndAmount>,
6872    #[serde(rename = "TtlAmtInclgTax", skip_serializing_if = "Option::is_none")]
6873    pub ttl_amt_inclg_tax: Option<ImpliedCurrencyAndAmount>,
6874}
6875#[derive(
6876    Debug,
6877    Default,
6878    Clone,
6879    PartialEq,
6880    ::serde::Serialize,
6881    ::serde::Deserialize,
6882    ::derive_builder::Builder,
6883    ::validator::Validate,
6884)]
6885pub struct TravelAgencyPackage1 {
6886    #[serde(rename = "RsvatnNb", skip_serializing_if = "Option::is_none")]
6887    pub rsvatn_nb: Option<Max35Text>,
6888    #[serde(rename = "TrvlPackgTp", skip_serializing_if = "Option::is_none")]
6889    pub trvl_packg_tp: Option<Max70Text>,
6890    #[serde(rename = "NbInPty", skip_serializing_if = "Option::is_none")]
6891    pub nb_in_pty: Option<Max10NumericText>,
6892    #[validate(length(min = 0,))]
6893    #[serde(rename = "CstmrRef", default)]
6894    pub cstmr_ref: Vec<CustomerReference1>,
6895    #[serde(rename = "DataSrc", skip_serializing_if = "Option::is_none")]
6896    pub data_src: Option<Max35Text>,
6897    #[serde(rename = "DlvryOrdrNb", skip_serializing_if = "Option::is_none")]
6898    pub dlvry_ordr_nb: Option<Max35Text>,
6899    #[serde(rename = "CdtCardSlipNb", skip_serializing_if = "Option::is_none")]
6900    pub cdt_card_slip_nb: Option<Max35Text>,
6901    #[serde(rename = "InsrncInd", skip_serializing_if = "Option::is_none")]
6902    pub insrnc_ind: Option<TrueFalseIndicator>,
6903    #[serde(rename = "InsrncAmt", skip_serializing_if = "Option::is_none")]
6904    pub insrnc_amt: Option<ImpliedCurrencyAndAmount>,
6905    #[serde(rename = "Fee", skip_serializing_if = "Option::is_none")]
6906    pub fee: Option<ImpliedCurrencyAndAmount>,
6907}
6908#[derive(
6909    Debug,
6910    Default,
6911    Clone,
6912    PartialEq,
6913    ::serde::Serialize,
6914    ::serde::Deserialize,
6915    ::derive_builder::Builder,
6916    ::validator::Validate,
6917)]
6918pub struct Transaction144 {
6919    #[serde(rename = "AdmstvTp")]
6920    pub admstv_tp: AdministrativeType1Code,
6921    #[serde(rename = "OthrAdmstvTp", skip_serializing_if = "Option::is_none")]
6922    pub othr_admstv_tp: Option<Max35Text>,
6923    #[validate(length(min = 0,))]
6924    #[serde(rename = "MsgRsn", default)]
6925    pub msg_rsn: Vec<Iso8583MessageReasonCode>,
6926    #[validate(length(min = 0,))]
6927    #[serde(rename = "AltrnMsgRsn", default)]
6928    pub altrn_msg_rsn: Vec<Max256Text>,
6929    #[validate(length(min = 0,))]
6930    #[serde(rename = "AddtlSvc", default)]
6931    pub addtl_svc: Vec<AdditionalService2>,
6932    #[serde(rename = "AssoctdDataInd", skip_serializing_if = "Option::is_none")]
6933    pub assoctd_data_ind: Option<TrueFalseIndicator>,
6934    #[serde(rename = "AssoctdDataRef", skip_serializing_if = "Option::is_none")]
6935    pub assoctd_data_ref: Option<Max70Text>,
6936    #[serde(rename = "AssoctdDataDstn", skip_serializing_if = "Option::is_none")]
6937    pub assoctd_data_dstn: Option<Max35Text>,
6938    #[validate(length(min = 0,))]
6939    #[serde(rename = "SpclPrgrmmQlfctn", default)]
6940    pub spcl_prgrmm_qlfctn: Vec<SpecialProgrammeQualification1>,
6941    #[validate]
6942    #[serde(rename = "TxId")]
6943    pub tx_id: TransactionIdentification12,
6944    #[serde(rename = "TxtMsg", skip_serializing_if = "Option::is_none")]
6945    pub txt_msg: Option<Max20KText>,
6946    #[validate(length(min = 0,))]
6947    #[serde(rename = "LclData", default)]
6948    pub lcl_data: Vec<LocalData9>,
6949    #[serde(rename = "TxDesc", skip_serializing_if = "Option::is_none")]
6950    pub tx_desc: Option<Max1000Text>,
6951    #[validate(length(min = 0,))]
6952    #[serde(rename = "AddtlData", default)]
6953    pub addtl_data: Vec<AdditionalData2>,
6954}
6955#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
6956pub enum CardDataReading5Code {
6957    #[serde(rename = "TAGC")]
6958    Tagc,
6959    #[serde(rename = "PHYS")]
6960    Phys,
6961    #[serde(rename = "BRCD")]
6962    Brcd,
6963    #[serde(rename = "MGST")]
6964    Mgst,
6965    #[serde(rename = "CICC")]
6966    Cicc,
6967    #[serde(rename = "DFLE")]
6968    Dfle,
6969    #[serde(rename = "CTLS")]
6970    Ctls,
6971    #[serde(rename = "ECTL")]
6972    Ectl,
6973    #[serde(rename = "CDFL")]
6974    Cdfl,
6975    #[default]
6976    Unknown,
6977}
6978#[derive(
6979    Debug,
6980    Default,
6981    Clone,
6982    PartialEq,
6983    ::serde::Serialize,
6984    ::serde::Deserialize,
6985    ::derive_builder::Builder,
6986    ::validator::Validate,
6987)]
6988pub struct CardholderName2 {
6989    #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
6990    pub nm: Option<Max140Text>,
6991    #[serde(rename = "GvnNm", skip_serializing_if = "Option::is_none")]
6992    pub gvn_nm: Option<Max70Text>,
6993    #[serde(rename = "MddlNm", skip_serializing_if = "Option::is_none")]
6994    pub mddl_nm: Option<Max70Text>,
6995    #[serde(rename = "LastNm", skip_serializing_if = "Option::is_none")]
6996    pub last_nm: Option<Max70Text>,
6997}
6998#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
6999pub enum PartyType22Code {
7000    #[serde(rename = "CRDH")]
7001    Crdh,
7002    #[serde(rename = "MERC")]
7003    Merc,
7004    #[serde(rename = "OTHN")]
7005    Othn,
7006    #[serde(rename = "OTHP")]
7007    Othp,
7008    #[serde(rename = "AGNT")]
7009    Agnt,
7010    #[default]
7011    Unknown,
7012}
7013#[derive(
7014    Debug,
7015    Default,
7016    Clone,
7017    PartialEq,
7018    ::serde::Serialize,
7019    ::serde::Deserialize,
7020    ::derive_builder::Builder,
7021    ::validator::Validate,
7022)]
7023pub struct GenericIdentification183 {
7024    #[validate]
7025    #[serde(rename = "Id")]
7026    pub id: Max35Text,
7027    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
7028    pub tp: Option<PartyType17Code>,
7029    #[serde(rename = "OthrTp", skip_serializing_if = "Option::is_none")]
7030    pub othr_tp: Option<Max35Text>,
7031    #[serde(rename = "Assgnr", skip_serializing_if = "Option::is_none")]
7032    pub assgnr: Option<PartyType18Code>,
7033    #[serde(rename = "Ctry", skip_serializing_if = "Option::is_none")]
7034    pub ctry: Option<IsoMax3ACountryCode>,
7035    #[serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none")]
7036    pub shrt_nm: Option<Max35Text>,
7037}
7038#[derive(
7039    Debug,
7040    Default,
7041    Clone,
7042    PartialEq,
7043    ::serde::Serialize,
7044    ::serde::Deserialize,
7045    ::derive_builder::Builder,
7046    ::validator::Validate,
7047)]
7048pub struct Vehicle4 {
7049    #[serde(rename = "Clss", skip_serializing_if = "Option::is_none")]
7050    pub clss: Option<Max35Text>,
7051    #[serde(rename = "Make", skip_serializing_if = "Option::is_none")]
7052    pub make: Option<Max35NumericText>,
7053    #[serde(rename = "Mdl", skip_serializing_if = "Option::is_none")]
7054    pub mdl: Option<Max35NumericText>,
7055    #[serde(rename = "RegnNb", skip_serializing_if = "Option::is_none")]
7056    pub regn_nb: Option<Max35Text>,
7057}
7058#[derive(
7059    Debug,
7060    Default,
7061    Clone,
7062    PartialEq,
7063    ::serde::Serialize,
7064    ::serde::Deserialize,
7065    ::derive_builder::Builder,
7066    ::validator::Validate,
7067)]
7068pub struct PartyIdentification210 {
7069    #[serde(rename = "PrsnlId", skip_serializing_if = "Option::is_none")]
7070    pub prsnl_id: Option<Max35Text>,
7071    #[serde(rename = "MplyeeId", skip_serializing_if = "Option::is_none")]
7072    pub mplyee_id: Option<PhoneNumber>,
7073    #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
7074    pub nm: Option<Max70Text>,
7075    #[serde(rename = "PrfssnlLvl", skip_serializing_if = "Option::is_none")]
7076    pub prfssnl_lvl: Option<Max35Text>,
7077}
7078#[derive(
7079    Debug,
7080    Default,
7081    Clone,
7082    PartialEq,
7083    ::serde::Serialize,
7084    ::serde::Deserialize,
7085    ::derive_builder::Builder,
7086    ::validator::Validate,
7087)]
7088pub struct BaseOneRate {
7089    #[serde(rename = "$text")]
7090    pub value: f64,
7091}
7092#[derive(
7093    Debug,
7094    Default,
7095    Clone,
7096    PartialEq,
7097    ::serde::Serialize,
7098    ::serde::Deserialize,
7099    ::derive_builder::Builder,
7100    ::validator::Validate,
7101)]
7102pub struct PointOfInteractionComponentCharacteristics4 {
7103    #[validate(length(min = 0,))]
7104    #[serde(rename = "Mmry", default)]
7105    pub mmry: Vec<MemoryCharacteristics1>,
7106    #[validate(length(min = 0,))]
7107    #[serde(rename = "Com", default)]
7108    pub com: Vec<CommunicationCharacteristics3>,
7109    #[serde(rename = "SctyAccsMdls", skip_serializing_if = "Option::is_none")]
7110    pub scty_accs_mdls: Option<Number>,
7111    #[serde(rename = "SbcbrIdntyMdls", skip_serializing_if = "Option::is_none")]
7112    pub sbcbr_idnty_mdls: Option<Number>,
7113    #[validate(length(min = 0,))]
7114    #[serde(rename = "SctyElmt", default)]
7115    pub scty_elmt: Vec<CryptographicKey13>,
7116}
7117#[derive(
7118    Debug,
7119    Default,
7120    Clone,
7121    PartialEq,
7122    ::serde::Serialize,
7123    ::serde::Deserialize,
7124    ::derive_builder::Builder,
7125    ::validator::Validate,
7126)]
7127pub struct LocalData1 {
7128    #[serde(rename = "Lang")]
7129    pub lang: IsoMax3ALanguageCode,
7130    #[serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none")]
7131    pub shrt_nm: Option<Max70Text>,
7132    #[serde(rename = "LglCorpNm", skip_serializing_if = "Option::is_none")]
7133    pub lgl_corp_nm: Option<Max210Text>,
7134    #[validate(length(min = 0,))]
7135    #[serde(rename = "AddtlData", default)]
7136    pub addtl_data: Vec<AdditionalData1>,
7137}
7138#[derive(
7139    Debug,
7140    Default,
7141    Clone,
7142    PartialEq,
7143    ::serde::Serialize,
7144    ::serde::Deserialize,
7145    ::derive_builder::Builder,
7146    ::validator::Validate,
7147)]
7148pub struct Iso3NumericCurrencyCode {
7149    #[validate(regex = "ISO_3_NUMERIC_CURRENCY_CODE_REGEX")]
7150    #[serde(rename = "$text")]
7151    pub value: String,
7152}
7153#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
7154pub enum CustomerDeviceType2Code {
7155    #[serde(rename = "MOBL")]
7156    Mobl,
7157    #[serde(rename = "OTHN")]
7158    Othn,
7159    #[serde(rename = "OTHP")]
7160    Othp,
7161    #[serde(rename = "PECR")]
7162    Pecr,
7163    #[serde(rename = "TBLT")]
7164    Tblt,
7165    #[serde(rename = "NSCR")]
7166    Nscr,
7167    #[serde(rename = "SECR")]
7168    Secr,
7169    #[serde(rename = "EMBD")]
7170    Embd,
7171    #[serde(rename = "VHCL")]
7172    Vhcl,
7173    #[serde(rename = "WRBL")]
7174    Wrbl,
7175    #[serde(rename = "WATC")]
7176    Watc,
7177    #[serde(rename = "GAMB")]
7178    Gamb,
7179    #[serde(rename = "JEWL")]
7180    Jewl,
7181    #[serde(rename = "KFOB")]
7182    Kfob,
7183    #[serde(rename = "STIC")]
7184    Stic,
7185    #[serde(rename = "UNKW")]
7186    Unkw,
7187    #[default]
7188    Unknown,
7189}
7190#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
7191pub enum OutputFormat4Code {
7192    #[serde(rename = "FLNM")]
7193    Flnm,
7194    #[serde(rename = "MREF")]
7195    Mref,
7196    #[serde(rename = "OTHN")]
7197    Othn,
7198    #[serde(rename = "OTHP")]
7199    Othp,
7200    #[serde(rename = "SMSI")]
7201    Smsi,
7202    #[serde(rename = "TEXT")]
7203    Text,
7204    #[serde(rename = "URLI")]
7205    Urli,
7206    #[serde(rename = "HTML")]
7207    Html,
7208    #[default]
7209    Unknown,
7210}
7211#[derive(
7212    Debug,
7213    Default,
7214    Clone,
7215    PartialEq,
7216    ::serde::Serialize,
7217    ::serde::Deserialize,
7218    ::derive_builder::Builder,
7219    ::validator::Validate,
7220)]
7221pub struct AdministrativeResponseV01<
7222    A: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
7223> {
7224    #[validate]
7225    #[serde(rename = "Hdr")]
7226    pub hdr: Header66,
7227    #[validate]
7228    #[serde(rename = "Body")]
7229    pub body: AdministrativeResponse1<A>,
7230    #[serde(rename = "SctyTrlr", skip_serializing_if = "Option::is_none")]
7231    pub scty_trlr: Option<ContentInformationType20>,
7232}
7233#[derive(
7234    Debug,
7235    Default,
7236    Clone,
7237    PartialEq,
7238    ::serde::Serialize,
7239    ::serde::Deserialize,
7240    ::derive_builder::Builder,
7241    ::validator::Validate,
7242)]
7243pub struct PartyIdentification208 {
7244    #[validate]
7245    #[serde(rename = "Tp")]
7246    pub tp: Max4Text,
7247    #[serde(rename = "OthrTp", skip_serializing_if = "Option::is_none")]
7248    pub othr_tp: Option<Max35Text>,
7249    #[validate]
7250    #[serde(rename = "Id")]
7251    pub id: Max70Text,
7252    #[serde(rename = "Assgnr", skip_serializing_if = "Option::is_none")]
7253    pub assgnr: Option<Max35Text>,
7254}
7255#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
7256pub enum StorageLocation1Code {
7257    #[serde(rename = "CAWL")]
7258    Cawl,
7259    #[serde(rename = "DVCE")]
7260    Dvce,
7261    #[serde(rename = "ISWL")]
7262    Iswl,
7263    #[serde(rename = "ONFL")]
7264    Onfl,
7265    #[serde(rename = "OTHN")]
7266    Othn,
7267    #[serde(rename = "OTHP")]
7268    Othp,
7269    #[serde(rename = "TPWL")]
7270    Tpwl,
7271    #[default]
7272    Unknown,
7273}
7274#[derive(
7275    Debug,
7276    Default,
7277    Clone,
7278    PartialEq,
7279    ::serde::Serialize,
7280    ::serde::Deserialize,
7281    ::derive_builder::Builder,
7282    ::validator::Validate,
7283)]
7284pub struct RiskInputData1 {
7285    #[serde(rename = "Ntty", skip_serializing_if = "Option::is_none")]
7286    pub ntty: Option<RiskAssessmentDataEntityProvider1>,
7287    #[validate]
7288    #[serde(rename = "Tp")]
7289    pub tp: Max35Text,
7290    #[validate]
7291    #[serde(rename = "Val")]
7292    pub val: Max10KText,
7293}
7294#[derive(
7295    Debug,
7296    Default,
7297    Clone,
7298    PartialEq,
7299    ::serde::Serialize,
7300    ::serde::Deserialize,
7301    ::derive_builder::Builder,
7302    ::validator::Validate,
7303)]
7304pub struct Recipient6ChoiceEnum {
7305    #[serde(rename = "KeyTrnsprt", skip_serializing_if = "Option::is_none")]
7306    pub key_trnsprt: Option<KeyTransport5>,
7307    #[serde(rename = "KEK", skip_serializing_if = "Option::is_none")]
7308    pub kek: Option<Kek5>,
7309    #[serde(rename = "KeyIdr", skip_serializing_if = "Option::is_none")]
7310    pub key_idr: Option<KekIdentifier2>,
7311}
7312#[derive(
7313    Debug,
7314    Default,
7315    Clone,
7316    PartialEq,
7317    ::serde::Serialize,
7318    ::serde::Deserialize,
7319    ::derive_builder::Builder,
7320    ::validator::Validate,
7321)]
7322pub struct Recipient6Choice {
7323    #[serde(flatten)]
7324    pub value: Recipient6ChoiceEnum,
7325}
7326#[derive(
7327    Debug,
7328    Default,
7329    Clone,
7330    PartialEq,
7331    ::serde::Serialize,
7332    ::serde::Deserialize,
7333    ::derive_builder::Builder,
7334    ::validator::Validate,
7335)]
7336pub struct Max11NumericText {
7337    #[validate(regex = "MAX_11_NUMERIC_TEXT_REGEX")]
7338    #[serde(rename = "$text")]
7339    pub value: String,
7340}
7341#[derive(
7342    Debug,
7343    Default,
7344    Clone,
7345    PartialEq,
7346    ::serde::Serialize,
7347    ::serde::Deserialize,
7348    ::derive_builder::Builder,
7349    ::validator::Validate,
7350)]
7351pub struct BatchManagementInformation1 {
7352    #[serde(rename = "ColltnId", skip_serializing_if = "Option::is_none")]
7353    pub colltn_id: Option<Max35Text>,
7354    #[validate]
7355    #[serde(rename = "BtchId")]
7356    pub btch_id: Max35Text,
7357    #[serde(rename = "MsgSeqNb", skip_serializing_if = "Option::is_none")]
7358    pub msg_seq_nb: Option<Max15NumericText>,
7359    #[serde(rename = "MsgChcksmInptVal", skip_serializing_if = "Option::is_none")]
7360    pub msg_chcksm_inpt_val: Option<Max140Binary>,
7361}
7362#[derive(
7363    Debug,
7364    Default,
7365    Clone,
7366    PartialEq,
7367    ::serde::Serialize,
7368    ::serde::Deserialize,
7369    ::derive_builder::Builder,
7370    ::validator::Validate,
7371)]
7372pub struct IsoDate {
7373    #[serde(rename = "$text")]
7374    pub value: ::chrono::NaiveDate,
7375}
7376#[derive(
7377    Debug,
7378    Default,
7379    Clone,
7380    PartialEq,
7381    ::serde::Serialize,
7382    ::serde::Deserialize,
7383    ::derive_builder::Builder,
7384    ::validator::Validate,
7385)]
7386pub struct IsoMax3ALanguageCode {
7387    #[validate(regex = "ISO_MAX_3_A_LANGUAGE_CODE_REGEX")]
7388    #[serde(rename = "$text")]
7389    pub value: String,
7390}
7391#[derive(
7392    Debug,
7393    Default,
7394    Clone,
7395    PartialEq,
7396    ::serde::Serialize,
7397    ::serde::Deserialize,
7398    ::derive_builder::Builder,
7399    ::validator::Validate,
7400)]
7401#[serde(rename = "Document")]
7402pub struct Document<
7403    A: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
7404> {
7405    #[validate]
7406    #[serde(rename = "AdmstvRspn")]
7407    pub admstv_rspn: AdministrativeResponseV01<A>,
7408    #[serde(rename = "@xmlns", default = "namespace")]
7409    pub xmlns: String,
7410}
7411#[derive(
7412    Debug,
7413    Default,
7414    Clone,
7415    PartialEq,
7416    ::serde::Serialize,
7417    ::serde::Deserialize,
7418    ::derive_builder::Builder,
7419    ::validator::Validate,
7420)]
7421pub struct Max8NumericText {
7422    #[validate(regex = "MAX_8_NUMERIC_TEXT_REGEX")]
7423    #[serde(rename = "$text")]
7424    pub value: String,
7425}
7426#[derive(
7427    Debug,
7428    Default,
7429    Clone,
7430    PartialEq,
7431    ::serde::Serialize,
7432    ::serde::Deserialize,
7433    ::derive_builder::Builder,
7434    ::validator::Validate,
7435)]
7436pub struct Terminal4 {
7437    #[validate]
7438    #[serde(rename = "TermnlId")]
7439    pub termnl_id: TerminalIdentification3,
7440    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
7441    pub tp: Option<TerminalType1Code>,
7442    #[serde(rename = "OthrTp", skip_serializing_if = "Option::is_none")]
7443    pub othr_tp: Option<Max35Text>,
7444    #[serde(rename = "Cpblties", skip_serializing_if = "Option::is_none")]
7445    pub cpblties: Option<Capabilities2>,
7446    #[serde(rename = "TermnlIntgtn", skip_serializing_if = "Option::is_none")]
7447    pub termnl_intgtn: Option<TerminalIntegrationCategory1Code>,
7448    #[serde(rename = "GeogcLctn", skip_serializing_if = "Option::is_none")]
7449    pub geogc_lctn: Option<GeographicPointInDecimalDegrees>,
7450    #[serde(rename = "OutdrInd", skip_serializing_if = "Option::is_none")]
7451    pub outdr_ind: Option<TrueFalseIndicator>,
7452    #[serde(rename = "OffPrmissInd", skip_serializing_if = "Option::is_none")]
7453    pub off_prmiss_ind: Option<TrueFalseIndicator>,
7454    #[serde(rename = "OnBrdInd", skip_serializing_if = "Option::is_none")]
7455    pub on_brd_ind: Option<TrueFalseIndicator>,
7456    #[validate(length(min = 0,))]
7457    #[serde(rename = "POICmpnt", default)]
7458    pub poi_cmpnt: Vec<PointOfInteractionComponent13>,
7459}
7460#[derive(
7461    Debug,
7462    Default,
7463    Clone,
7464    PartialEq,
7465    ::serde::Serialize,
7466    ::serde::Deserialize,
7467    ::derive_builder::Builder,
7468    ::validator::Validate,
7469)]
7470pub struct AdditionalIdentification1 {
7471    #[serde(rename = "Tp")]
7472    pub tp: AdditionalIdentificationType1Code,
7473    #[serde(rename = "OthrTp", skip_serializing_if = "Option::is_none")]
7474    pub othr_tp: Option<Max35Text>,
7475    #[validate]
7476    #[serde(rename = "Val")]
7477    pub val: Max35Text,
7478}
7479#[derive(
7480    Debug,
7481    Default,
7482    Clone,
7483    PartialEq,
7484    ::serde::Serialize,
7485    ::serde::Deserialize,
7486    ::derive_builder::Builder,
7487    ::validator::Validate,
7488)]
7489pub struct AlgorithmIdentification27 {
7490    #[serde(rename = "Algo")]
7491    pub algo: Algorithm7Code,
7492    #[serde(rename = "Param", skip_serializing_if = "Option::is_none")]
7493    pub param: Option<Parameter13>,
7494}
7495#[derive(
7496    Debug,
7497    Default,
7498    Clone,
7499    PartialEq,
7500    ::serde::Serialize,
7501    ::serde::Deserialize,
7502    ::derive_builder::Builder,
7503    ::validator::Validate,
7504)]
7505pub struct Iso8583MessageReasonCode {
7506    #[validate(regex = "ISO_8583_MESSAGE_REASON_CODE_REGEX")]
7507    #[serde(rename = "$text")]
7508    pub value: String,
7509}
7510#[derive(
7511    Debug,
7512    Default,
7513    Clone,
7514    PartialEq,
7515    ::serde::Serialize,
7516    ::serde::Deserialize,
7517    ::derive_builder::Builder,
7518    ::validator::Validate,
7519)]
7520pub struct PartyIdentification263 {
7521    #[validate]
7522    #[serde(rename = "Id")]
7523    pub id: Max11NumericText,
7524    #[serde(rename = "Assgnr", skip_serializing_if = "Option::is_none")]
7525    pub assgnr: Option<Max35Text>,
7526    #[serde(rename = "Ctry", skip_serializing_if = "Option::is_none")]
7527    pub ctry: Option<Iso3NumericCountryCode>,
7528    #[serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none")]
7529    pub shrt_nm: Option<Max35Text>,
7530    #[serde(rename = "LglCorpNm", skip_serializing_if = "Option::is_none")]
7531    pub lgl_corp_nm: Option<Max99Text>,
7532    #[serde(rename = "AddtlId", skip_serializing_if = "Option::is_none")]
7533    pub addtl_id: Option<AdditionalData1>,
7534    #[serde(rename = "LclData", skip_serializing_if = "Option::is_none")]
7535    pub lcl_data: Option<LocalData1>,
7536}
7537#[derive(
7538    Debug,
7539    Default,
7540    Clone,
7541    PartialEq,
7542    ::serde::Serialize,
7543    ::serde::Deserialize,
7544    ::derive_builder::Builder,
7545    ::validator::Validate,
7546)]
7547pub struct Traceability9 {
7548    #[validate]
7549    #[serde(rename = "RlayId")]
7550    pub rlay_id: GenericIdentification183,
7551    #[serde(rename = "TracDtTmIn", skip_serializing_if = "Option::is_none")]
7552    pub trac_dt_tm_in: Option<IsoDateTime>,
7553    #[serde(rename = "TracDtTmOut", skip_serializing_if = "Option::is_none")]
7554    pub trac_dt_tm_out: Option<IsoDateTime>,
7555}
7556#[derive(
7557    Debug,
7558    Default,
7559    Clone,
7560    PartialEq,
7561    ::serde::Serialize,
7562    ::serde::Deserialize,
7563    ::derive_builder::Builder,
7564    ::validator::Validate,
7565)]
7566pub struct Capabilities2 {
7567    #[validate(length(min = 0,))]
7568    #[serde(rename = "CardRdngCpblty", default)]
7569    pub card_rdng_cpblty: Vec<CardReadingCapabilities1>,
7570    #[validate(length(min = 0,))]
7571    #[serde(rename = "CardWrtgCpblty", default)]
7572    pub card_wrtg_cpblty: Vec<CardWritingCapabilities1>,
7573    #[serde(rename = "PINLngthCpblty", skip_serializing_if = "Option::is_none")]
7574    pub pin_lngth_cpblty: Option<Number>,
7575    #[serde(rename = "PINNtrySctyChrtc", skip_serializing_if = "Option::is_none")]
7576    pub pin_ntry_scty_chrtc: Option<PinEntrySecurityCharacteristic1Code>,
7577    #[serde(
7578        rename = "OthrPINNtrySctyChrtc",
7579        skip_serializing_if = "Option::is_none"
7580    )]
7581    pub othr_pin_ntry_scty_chrtc: Option<Max35Text>,
7582    #[serde(rename = "ApprvlCdLngth", skip_serializing_if = "Option::is_none")]
7583    pub apprvl_cd_lngth: Option<Number>,
7584    #[serde(rename = "MxScrptLngth", skip_serializing_if = "Option::is_none")]
7585    pub mx_scrpt_lngth: Option<Number>,
7586    #[serde(rename = "CardCaptrCpbl", skip_serializing_if = "Option::is_none")]
7587    pub card_captr_cpbl: Option<TrueFalseIndicator>,
7588    #[serde(rename = "OnLineCpblty", skip_serializing_if = "Option::is_none")]
7589    pub on_line_cpblty: Option<OnLineCapability2Code>,
7590    #[validate(length(min = 0,))]
7591    #[serde(rename = "MsgCpblty", default)]
7592    pub msg_cpblty: Vec<DisplayCapabilities6>,
7593    #[validate(length(min = 0,))]
7594    #[serde(rename = "CrdhldrVrfctnCpblty", default)]
7595    pub crdhldr_vrfctn_cpblty: Vec<CardholderVerificationCapabilities1>,
7596    #[serde(
7597        rename = "TempScrCardDataStorg",
7598        skip_serializing_if = "Option::is_none"
7599    )]
7600    pub temp_scr_card_data_storg: Option<TrueFalseIndicator>,
7601}
7602#[derive(
7603    Debug,
7604    Default,
7605    Clone,
7606    PartialEq,
7607    ::serde::Serialize,
7608    ::serde::Deserialize,
7609    ::derive_builder::Builder,
7610    ::validator::Validate,
7611)]
7612pub struct Parameter7 {
7613    #[serde(rename = "InitlstnVctr", skip_serializing_if = "Option::is_none")]
7614    pub initlstn_vctr: Option<Max500Binary>,
7615    #[serde(rename = "BPddg", skip_serializing_if = "Option::is_none")]
7616    pub b_pddg: Option<BytePadding1Code>,
7617}
7618#[derive(
7619    Debug,
7620    Default,
7621    Clone,
7622    PartialEq,
7623    ::serde::Serialize,
7624    ::serde::Deserialize,
7625    ::derive_builder::Builder,
7626    ::validator::Validate,
7627)]
7628pub struct MacData1 {
7629    #[validate]
7630    #[serde(rename = "Ctrl")]
7631    pub ctrl: Exact1HexBinaryText,
7632    #[validate]
7633    #[serde(rename = "KeySetIdr")]
7634    pub key_set_idr: Max8NumericText,
7635    #[serde(rename = "DrvdInf", skip_serializing_if = "Option::is_none")]
7636    pub drvd_inf: Option<Max32HexBinaryText>,
7637    #[validate]
7638    #[serde(rename = "Algo")]
7639    pub algo: Max2NumericText,
7640    #[serde(rename = "KeyLngth", skip_serializing_if = "Option::is_none")]
7641    pub key_lngth: Option<Max4NumericText>,
7642    #[serde(rename = "KeyPrtcn", skip_serializing_if = "Option::is_none")]
7643    pub key_prtcn: Option<Max2NumericText>,
7644    #[serde(rename = "KeyIndx", skip_serializing_if = "Option::is_none")]
7645    pub key_indx: Option<Max5NumericText>,
7646    #[serde(rename = "PddgMtd", skip_serializing_if = "Option::is_none")]
7647    pub pddg_mtd: Option<Max2NumericText>,
7648    #[serde(rename = "InitlstnVctr", skip_serializing_if = "Option::is_none")]
7649    pub initlstn_vctr: Option<Max32HexBinaryText>,
7650}
7651#[derive(
7652    Debug,
7653    Default,
7654    Clone,
7655    PartialEq,
7656    ::serde::Serialize,
7657    ::serde::Deserialize,
7658    ::derive_builder::Builder,
7659    ::validator::Validate,
7660)]
7661pub struct ExternalAuthenticationMethod1Code {
7662    #[validate(length(min = 1, max = 4,))]
7663    #[serde(rename = "$text")]
7664    pub value: String,
7665}
7666#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
7667pub enum InstalmentAmountDetailsType2Code {
7668    #[serde(rename = "AFCO")]
7669    Afco,
7670    #[serde(rename = "EXPN")]
7671    Expn,
7672    #[serde(rename = "FEES")]
7673    Fees,
7674    #[serde(rename = "FUNA")]
7675    Funa,
7676    #[serde(rename = "INSU")]
7677    Insu,
7678    #[serde(rename = "INTR")]
7679    Intr,
7680    #[serde(rename = "OTHC")]
7681    Othc,
7682    #[serde(rename = "OTHN")]
7683    Othn,
7684    #[serde(rename = "OTHP")]
7685    Othp,
7686    #[serde(rename = "PRNC")]
7687    Prnc,
7688    #[serde(rename = "RQST")]
7689    Rqst,
7690    #[serde(rename = "TAXX")]
7691    Taxx,
7692    #[default]
7693    Unknown,
7694}
7695#[derive(
7696    Debug,
7697    Default,
7698    Clone,
7699    PartialEq,
7700    ::serde::Serialize,
7701    ::serde::Deserialize,
7702    ::derive_builder::Builder,
7703    ::validator::Validate,
7704)]
7705pub struct AlgorithmIdentification18 {
7706    #[serde(rename = "Algo")]
7707    pub algo: Algorithm8Code,
7708    #[serde(rename = "Param", skip_serializing_if = "Option::is_none")]
7709    pub param: Option<Parameter9>,
7710}
7711#[derive(
7712    Debug,
7713    Default,
7714    Clone,
7715    PartialEq,
7716    ::serde::Serialize,
7717    ::serde::Deserialize,
7718    ::derive_builder::Builder,
7719    ::validator::Validate,
7720)]
7721pub struct Max10NumericText {
7722    #[validate(regex = "MAX_10_NUMERIC_TEXT_REGEX")]
7723    #[serde(rename = "$text")]
7724    pub value: String,
7725}
7726#[derive(
7727    Debug,
7728    Default,
7729    Clone,
7730    PartialEq,
7731    ::serde::Serialize,
7732    ::serde::Deserialize,
7733    ::derive_builder::Builder,
7734    ::validator::Validate,
7735)]
7736pub struct CarrierIdentification1 {
7737    #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
7738    pub nm: Option<Max70Text>,
7739    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
7740    pub cd: Option<Max35Text>,
7741    #[serde(rename = "IATACd", skip_serializing_if = "Option::is_none")]
7742    pub iata_cd: Option<Max35Text>,
7743}
7744#[derive(
7745    Debug,
7746    Default,
7747    Clone,
7748    PartialEq,
7749    ::serde::Serialize,
7750    ::serde::Deserialize,
7751    ::derive_builder::Builder,
7752    ::validator::Validate,
7753)]
7754pub struct UnitOfMeasure2 {
7755    #[serde(rename = "UnitOfMeasr", skip_serializing_if = "Option::is_none")]
7756    pub unit_of_measr: Option<UnitOfMeasure1Code>,
7757    #[serde(rename = "OthrUnitOfMeasr", skip_serializing_if = "Option::is_none")]
7758    pub othr_unit_of_measr: Option<Max35Text>,
7759    #[serde(rename = "NbOfUnits", skip_serializing_if = "Option::is_none")]
7760    pub nb_of_units: Option<DecimalNumber>,
7761}
7762#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
7763pub enum EncryptionFormat3Code {
7764    #[serde(rename = "TR34")]
7765    Tr34,
7766    #[serde(rename = "TR31")]
7767    Tr31,
7768    #[serde(rename = "CTCE")]
7769    Ctce,
7770    #[serde(rename = "CBCE")]
7771    Cbce,
7772    #[default]
7773    Unknown,
7774}
7775#[derive(
7776    Debug,
7777    Default,
7778    Clone,
7779    PartialEq,
7780    ::serde::Serialize,
7781    ::serde::Deserialize,
7782    ::derive_builder::Builder,
7783    ::validator::Validate,
7784)]
7785pub struct Max10NumberFraction2 {
7786    #[serde(rename = "$text")]
7787    pub value: f64,
7788}
7789#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
7790pub enum AddendumTaxType2Code {
7791    #[serde(rename = "TOTL")]
7792    Totl,
7793    #[serde(rename = "ALMI")]
7794    Almi,
7795    #[serde(rename = "ASNT")]
7796    Asnt,
7797    #[serde(rename = "BPTX")]
7798    Bptx,
7799    #[serde(rename = "KAPA")]
7800    Kapa,
7801    #[serde(rename = "NKAP")]
7802    Nkap,
7803    #[serde(rename = "CRTX")]
7804    Crtx,
7805    #[serde(rename = "CSTX")]
7806    Cstx,
7807    #[serde(rename = "CITX")]
7808    Citx,
7809    #[serde(rename = "COAX")]
7810    Coax,
7811    #[serde(rename = "CPST")]
7812    Cpst,
7813    #[serde(rename = "CORT")]
7814    Cort,
7815    #[serde(rename = "COTX")]
7816    Cotx,
7817    #[serde(rename = "CUST")]
7818    Cust,
7819    #[serde(rename = "DLTX")]
7820    Dltx,
7821    #[serde(rename = "DUTY")]
7822    Duty,
7823    #[serde(rename = "EMIT")]
7824    Emit,
7825    #[serde(rename = "EMUT")]
7826    Emut,
7827    #[serde(rename = "EMET")]
7828    Emet,
7829    #[serde(rename = "EMST")]
7830    Emst,
7831    #[serde(rename = "EMRT")]
7832    Emrt,
7833    #[serde(rename = "ENTX")]
7834    Entx,
7835    #[serde(rename = "ESET")]
7836    Eset,
7837    #[serde(rename = "ENVT")]
7838    Envt,
7839    #[serde(rename = "EQUL")]
7840    Equl,
7841    #[serde(rename = "EQTX")]
7842    Eqtx,
7843    #[serde(rename = "EUTR")]
7844    Eutr,
7845    #[serde(rename = "EXEC")]
7846    Exec,
7847    #[serde(rename = "FEXT")]
7848    Fext,
7849    #[serde(rename = "FNST")]
7850    Fnst,
7851    #[serde(rename = "FETX")]
7852    Fetx,
7853    #[serde(rename = "FVAT")]
7854    Fvat,
7855    #[serde(rename = "FVTS")]
7856    Fvts,
7857    #[serde(rename = "FIMT")]
7858    Fimt,
7859    #[serde(rename = "FSST")]
7860    Fsst,
7861    #[serde(rename = "FICA")]
7862    Fica,
7863    #[serde(rename = "FRTX")]
7864    Frtx,
7865    #[serde(rename = "FSTX")]
7866    Fstx,
7867    #[serde(rename = "FSFT")]
7868    Fsft,
7869    #[serde(rename = "FUVT")]
7870    Fuvt,
7871    #[serde(rename = "GIFT")]
7872    Gift,
7873    #[serde(rename = "GCAT")]
7874    Gcat,
7875    #[serde(rename = "GRTX")]
7876    Grtx,
7877    #[serde(rename = "HVAT")]
7878    Hvat,
7879    #[serde(rename = "HATX")]
7880    Hatx,
7881    #[serde(rename = "HSTX")]
7882    Hstx,
7883    #[serde(rename = "HWTX")]
7884    Hwtx,
7885    #[serde(rename = "INHT")]
7886    Inht,
7887    #[serde(rename = "INPO")]
7888    Inpo,
7889    #[serde(rename = "LTTX")]
7890    Lttx,
7891    #[serde(rename = "FLST")]
7892    Flst,
7893    #[serde(rename = "LITX")]
7894    Litx,
7895    #[serde(rename = "LOCO")]
7896    Loco,
7897    #[serde(rename = "LSTX")]
7898    Lstx,
7899    #[serde(rename = "LOCL")]
7900    Locl,
7901    #[serde(rename = "LUTX")]
7902    Lutx,
7903    #[serde(rename = "MATX")]
7904    Matx,
7905    #[serde(rename = "METX")]
7906    Metx,
7907    #[serde(rename = "MITX")]
7908    Mitx,
7909    #[serde(rename = "MUTX")]
7910    Mutx,
7911    #[serde(rename = "MUDE")]
7912    Mude,
7913    #[serde(rename = "COUN")]
7914    Coun,
7915    #[serde(rename = "NATI")]
7916    Nati,
7917    #[serde(rename = "OCTX")]
7918    Octx,
7919    #[serde(rename = "OPTX")]
7920    Optx,
7921    #[serde(rename = "OTHR")]
7922    Othr,
7923    #[serde(rename = "OTHN")]
7924    Othn,
7925    #[serde(rename = "OTHP")]
7926    Othp,
7927    #[serde(rename = "OTTX")]
7928    Ottx,
7929    #[serde(rename = "LEVY")]
7930    Levy,
7931    #[serde(rename = "POTX")]
7932    Potx,
7933    #[serde(rename = "PRTX")]
7934    Prtx,
7935    #[serde(rename = "PSTX")]
7936    Pstx,
7937    #[serde(rename = "PPTX")]
7938    Pptx,
7939    #[serde(rename = "PROV")]
7940    Prov,
7941    #[serde(rename = "PHET")]
7942    Phet,
7943    #[serde(rename = "QUST")]
7944    Qust,
7945    #[serde(rename = "ROCI")]
7946    Roci,
7947    #[serde(rename = "RCSB")]
7948    Rcsb,
7949    #[serde(rename = "RCSD")]
7950    Rcsd,
7951    #[serde(rename = "ROTX")]
7952    Rotx,
7953    #[serde(rename = "RVAT")]
7954    Rvat,
7955    #[serde(rename = "ROVI")]
7956    Rovi,
7957    #[serde(rename = "SAUT")]
7958    Saut,
7959    #[serde(rename = "SCTX")]
7960    Sctx,
7961    #[serde(rename = "SPTX")]
7962    Sptx,
7963    #[serde(rename = "STTA")]
7964    Stta,
7965    #[serde(rename = "STAM")]
7966    Stam,
7967    #[serde(rename = "SLST")]
7968    Slst,
7969    #[serde(rename = "SLTX")]
7970    Sltx,
7971    #[serde(rename = "SETX")]
7972    Setx,
7973    #[serde(rename = "STPT")]
7974    Stpt,
7975    #[serde(rename = "SPTS")]
7976    Spts,
7977    #[serde(rename = "SPFT")]
7978    Spft,
7979    #[serde(rename = "SPTG")]
7980    Sptg,
7981    #[serde(rename = "SRTX")]
7982    Srtx,
7983    #[serde(rename = "SSTX")]
7984    Sstx,
7985    #[serde(rename = "STAT")]
7986    Stat,
7987    #[serde(rename = "STSL")]
7988    Stsl,
7989    #[serde(rename = "STEX")]
7990    Stex,
7991    #[serde(rename = "SUTX")]
7992    Sutx,
7993    #[serde(rename = "CTAX")]
7994    Ctax,
7995    #[serde(rename = "TDDT")]
7996    Tddt,
7997    #[serde(rename = "TELT")]
7998    Telt,
7999    #[serde(rename = "THTX")]
8000    Thtx,
8001    #[serde(rename = "TRAX")]
8002    Trax,
8003    #[serde(rename = "TRAN")]
8004    Tran,
8005    #[serde(rename = "UNSP")]
8006    Unsp,
8007    #[serde(rename = "UUTX")]
8008    Uutx,
8009    #[serde(rename = "VATA")]
8010    Vata,
8011    #[serde(rename = "VATB")]
8012    Vatb,
8013    #[serde(rename = "WTAX")]
8014    Wtax,
8015    #[serde(rename = "WESV")]
8016    Wesv,
8017    #[serde(rename = "WITF")]
8018    Witf,
8019    #[serde(rename = "WITL")]
8020    Witl,
8021    #[serde(rename = "WITH")]
8022    With,
8023    #[serde(rename = "TNRT")]
8024    Tnrt,
8025    #[default]
8026    Unknown,
8027}
8028#[derive(
8029    Debug,
8030    Default,
8031    Clone,
8032    PartialEq,
8033    ::serde::Serialize,
8034    ::serde::Deserialize,
8035    ::derive_builder::Builder,
8036    ::validator::Validate,
8037)]
8038pub struct Driver2 {
8039    #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
8040    pub nm: Option<Max70Text>,
8041    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
8042    pub id: Option<Max70Text>,
8043    #[serde(rename = "DrvgLic", skip_serializing_if = "Option::is_none")]
8044    pub drvg_lic: Option<DrivingLicense2>,
8045    #[serde(rename = "Mplyr", skip_serializing_if = "Option::is_none")]
8046    pub mplyr: Option<Max70Text>,
8047    #[serde(rename = "MplyeeId", skip_serializing_if = "Option::is_none")]
8048    pub mplyee_id: Option<Max70Text>,
8049    #[serde(rename = "DeptNb", skip_serializing_if = "Option::is_none")]
8050    pub dept_nb: Option<Max35Text>,
8051    #[validate(length(min = 0,))]
8052    #[serde(rename = "AddtlId", default)]
8053    pub addtl_id: Vec<TravelDocument2>,
8054    #[serde(rename = "DtOfBirth", skip_serializing_if = "Option::is_none")]
8055    pub dt_of_birth: Option<IsoDate>,
8056    #[serde(rename = "AddtlData", skip_serializing_if = "Option::is_none")]
8057    pub addtl_data: Option<AdditionalData1>,
8058}
8059#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
8060pub enum Algorithm20Code {
8061    #[serde(rename = "HS25")]
8062    Hs25,
8063    #[serde(rename = "HS38")]
8064    Hs38,
8065    #[serde(rename = "HS51")]
8066    Hs51,
8067    #[default]
8068    Unknown,
8069}
8070#[derive(
8071    Debug,
8072    Default,
8073    Clone,
8074    PartialEq,
8075    ::serde::Serialize,
8076    ::serde::Deserialize,
8077    ::derive_builder::Builder,
8078    ::validator::Validate,
8079)]
8080pub struct Exact15Text {
8081    #[serde(rename = "$text")]
8082    pub value: String,
8083}
8084#[derive(
8085    Debug,
8086    Default,
8087    Clone,
8088    PartialEq,
8089    ::serde::Serialize,
8090    ::serde::Deserialize,
8091    ::derive_builder::Builder,
8092    ::validator::Validate,
8093)]
8094pub struct Number {
8095    #[serde(rename = "$text")]
8096    pub value: f64,
8097}
8098#[derive(
8099    Debug,
8100    Default,
8101    Clone,
8102    PartialEq,
8103    ::serde::Serialize,
8104    ::serde::Deserialize,
8105    ::derive_builder::Builder,
8106    ::validator::Validate,
8107)]
8108pub struct OriginatorInformation1 {
8109    #[validate(length(min = 0,))]
8110    #[serde(rename = "Cert", default)]
8111    pub cert: Vec<Max5000Binary>,
8112}
8113#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
8114pub enum CarRentalActivity1Code {
8115    #[serde(rename = "CARS")]
8116    Cars,
8117    #[serde(rename = "GLBL")]
8118    Glbl,
8119    #[serde(rename = "INDV")]
8120    Indv,
8121    #[serde(rename = "PETP")]
8122    Petp,
8123    #[serde(rename = "OTHP")]
8124    Othp,
8125    #[serde(rename = "OTHN")]
8126    Othn,
8127    #[serde(rename = "OTHR")]
8128    Othr,
8129    #[default]
8130    Unknown,
8131}
8132#[derive(
8133    Debug,
8134    Default,
8135    Clone,
8136    PartialEq,
8137    ::serde::Serialize,
8138    ::serde::Deserialize,
8139    ::derive_builder::Builder,
8140    ::validator::Validate,
8141)]
8142pub struct Max500Binary {
8143    #[validate(length(min = 1, max = 500,), regex = "MAX_500_BINARY_REGEX")]
8144    pub value: String,
8145}
8146#[derive(
8147    Debug,
8148    Default,
8149    Clone,
8150    PartialEq,
8151    ::serde::Serialize,
8152    ::serde::Deserialize,
8153    ::derive_builder::Builder,
8154    ::validator::Validate,
8155)]
8156pub struct Max5NumericText {
8157    #[validate(regex = "MAX_5_NUMERIC_TEXT_REGEX")]
8158    #[serde(rename = "$text")]
8159    pub value: String,
8160}
8161#[derive(
8162    Debug,
8163    Default,
8164    Clone,
8165    PartialEq,
8166    ::serde::Serialize,
8167    ::serde::Deserialize,
8168    ::derive_builder::Builder,
8169    ::validator::Validate,
8170)]
8171pub struct OnBoardDiagnostics1 {
8172    #[serde(rename = "NgnIdleTm", skip_serializing_if = "Option::is_none")]
8173    pub ngn_idle_tm: Option<Max10NumberFraction2>,
8174    #[serde(rename = "NgnTtlIdleTm", skip_serializing_if = "Option::is_none")]
8175    pub ngn_ttl_idle_tm: Option<Max10NumberFraction2>,
8176    #[serde(rename = "NgnHrs", skip_serializing_if = "Option::is_none")]
8177    pub ngn_hrs: Option<Max10NumberFraction2>,
8178    #[serde(rename = "NgnTtlTm", skip_serializing_if = "Option::is_none")]
8179    pub ngn_ttl_tm: Option<Max6NumberFraction2>,
8180    #[serde(rename = "NgnLd", skip_serializing_if = "Option::is_none")]
8181    pub ngn_ld: Option<Max12NumericText>,
8182    #[serde(rename = "NgnRPM", skip_serializing_if = "Option::is_none")]
8183    pub ngn_rpm: Option<Max5NumericText>,
8184    #[serde(rename = "NgnOilTmprtr", skip_serializing_if = "Option::is_none")]
8185    pub ngn_oil_tmprtr: Option<Max6NumberFraction2>,
8186    #[serde(rename = "NgnOilPrssr", skip_serializing_if = "Option::is_none")]
8187    pub ngn_oil_prssr: Option<Max3NumericText>,
8188    #[serde(rename = "NgnOilLifeRmng", skip_serializing_if = "Option::is_none")]
8189    pub ngn_oil_life_rmng: Option<Max3NumericText>,
8190    #[serde(rename = "ChckNgnWrngSts", skip_serializing_if = "Option::is_none")]
8191    pub chck_ngn_wrng_sts: Option<Max35Text>,
8192    #[serde(rename = "FuelTankLvlStart", skip_serializing_if = "Option::is_none")]
8193    pub fuel_tank_lvl_start: Option<Max4NumericText>,
8194    #[serde(rename = "FuelGaugeLvl", skip_serializing_if = "Option::is_none")]
8195    pub fuel_gauge_lvl: Option<Max4NumericText>,
8196    #[serde(rename = "FuelEcnmy", skip_serializing_if = "Option::is_none")]
8197    pub fuel_ecnmy: Option<Max6NumberFraction2>,
8198    #[serde(rename = "RfrgrtnHrs", skip_serializing_if = "Option::is_none")]
8199    pub rfrgrtn_hrs: Option<Max10NumberFraction2>,
8200    #[serde(rename = "RfrgrtnTmprtr", skip_serializing_if = "Option::is_none")]
8201    pub rfrgrtn_tmprtr: Option<Max6NumberFraction2>,
8202    #[serde(rename = "CoolntTmprtr", skip_serializing_if = "Option::is_none")]
8203    pub coolnt_tmprtr: Option<Max6NumberFraction2>,
8204    #[serde(rename = "BttryVltg", skip_serializing_if = "Option::is_none")]
8205    pub bttry_vltg: Option<Max4NumericText>,
8206    #[serde(rename = "HardBrakg", skip_serializing_if = "Option::is_none")]
8207    pub hard_brakg: Option<Max4NumericText>,
8208    #[serde(rename = "HardAcclrtn", skip_serializing_if = "Option::is_none")]
8209    pub hard_acclrtn: Option<Max4NumericText>,
8210}
8211#[derive(
8212    Debug,
8213    Default,
8214    Clone,
8215    PartialEq,
8216    ::serde::Serialize,
8217    ::serde::Deserialize,
8218    ::derive_builder::Builder,
8219    ::validator::Validate,
8220)]
8221pub struct TransactionLifeCycleIdentification1 {
8222    #[validate]
8223    #[serde(rename = "Id")]
8224    pub id: Exact15Text,
8225    #[serde(rename = "AuthstnSeqNb", skip_serializing_if = "Option::is_none")]
8226    pub authstn_seq_nb: Option<Exact2NumericText>,
8227    #[serde(rename = "PresntmntSeqNb", skip_serializing_if = "Option::is_none")]
8228    pub presntmnt_seq_nb: Option<Exact2NumericText>,
8229    #[serde(rename = "PresntmntSeqCnt", skip_serializing_if = "Option::is_none")]
8230    pub presntmnt_seq_cnt: Option<Exact2NumericText>,
8231    #[serde(rename = "AuthntcnTkn", skip_serializing_if = "Option::is_none")]
8232    pub authntcn_tkn: Option<Max35Text>,
8233}
8234#[derive(
8235    Debug,
8236    Default,
8237    Clone,
8238    PartialEq,
8239    ::serde::Serialize,
8240    ::serde::Deserialize,
8241    ::derive_builder::Builder,
8242    ::validator::Validate,
8243)]
8244pub struct PartyIdentification257 {
8245    #[serde(rename = "FI", skip_serializing_if = "Option::is_none")]
8246    pub fi: Option<FinancialInstitution7>,
8247    #[serde(rename = "Cstmr", skip_serializing_if = "Option::is_none")]
8248    pub cstmr: Option<Customer7>,
8249}
8250#[derive(
8251    Debug,
8252    Default,
8253    Clone,
8254    PartialEq,
8255    ::serde::Serialize,
8256    ::serde::Deserialize,
8257    ::derive_builder::Builder,
8258    ::validator::Validate,
8259)]
8260pub struct LocalAmenity1 {
8261    #[serde(rename = "Tp")]
8262    pub tp: LocationAmenity1Code,
8263    #[serde(rename = "OthrTp", skip_serializing_if = "Option::is_none")]
8264    pub othr_tp: Option<Max35Text>,
8265    #[serde(rename = "AvlblInd", skip_serializing_if = "Option::is_none")]
8266    pub avlbl_ind: Option<TrueFalseIndicator>,
8267}
8268#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
8269pub enum GoodsAndServices1Code {
8270    #[serde(rename = "ELEC")]
8271    Elec,
8272    #[serde(rename = "PHYS")]
8273    Phys,
8274    #[serde(rename = "ELPH")]
8275    Elph,
8276    #[default]
8277    Unknown,
8278}
8279#[derive(
8280    Debug,
8281    Default,
8282    Clone,
8283    PartialEq,
8284    ::serde::Serialize,
8285    ::serde::Deserialize,
8286    ::derive_builder::Builder,
8287    ::validator::Validate,
8288)]
8289pub struct InstalmentAmountDetails2 {
8290    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
8291    pub tp: Option<InstalmentAmountDetailsType2Code>,
8292    #[serde(rename = "OthrTp", skip_serializing_if = "Option::is_none")]
8293    pub othr_tp: Option<Max35Text>,
8294    #[serde(rename = "SubTp", skip_serializing_if = "Option::is_none")]
8295    pub sub_tp: Option<Max35Text>,
8296    #[serde(rename = "Amt", skip_serializing_if = "Option::is_none")]
8297    pub amt: Option<Amount16>,
8298    #[serde(rename = "Pctg", skip_serializing_if = "Option::is_none")]
8299    pub pctg: Option<PercentageRate>,
8300}
8301#[derive(
8302    Debug,
8303    Default,
8304    Clone,
8305    PartialEq,
8306    ::serde::Serialize,
8307    ::serde::Deserialize,
8308    ::derive_builder::Builder,
8309    ::validator::Validate,
8310)]
8311pub struct AlgorithmIdentification21 {
8312    #[serde(rename = "Algo")]
8313    pub algo: Algorithm16Code,
8314}
8315#[derive(
8316    Debug,
8317    Default,
8318    Clone,
8319    PartialEq,
8320    ::serde::Serialize,
8321    ::serde::Deserialize,
8322    ::derive_builder::Builder,
8323    ::validator::Validate,
8324)]
8325pub struct Max70Text {
8326    #[validate(length(min = 1, max = 70,))]
8327    #[serde(rename = "$text")]
8328    pub value: String,
8329}
8330#[derive(
8331    Debug,
8332    Default,
8333    Clone,
8334    PartialEq,
8335    ::serde::Serialize,
8336    ::serde::Deserialize,
8337    ::derive_builder::Builder,
8338    ::validator::Validate,
8339)]
8340pub struct RentalRate1 {
8341    #[serde(rename = "Prd", skip_serializing_if = "Option::is_none")]
8342    pub prd: Option<PeriodUnit3Code>,
8343    #[serde(rename = "OthrPrd", skip_serializing_if = "Option::is_none")]
8344    pub othr_prd: Option<Max35Text>,
8345    #[serde(rename = "Rate", skip_serializing_if = "Option::is_none")]
8346    pub rate: Option<ImpliedCurrencyAndAmount>,
8347    #[serde(rename = "PrdCnt", skip_serializing_if = "Option::is_none")]
8348    pub prd_cnt: Option<Max4NumericText>,
8349}
8350#[derive(
8351    Debug,
8352    Default,
8353    Clone,
8354    PartialEq,
8355    ::serde::Serialize,
8356    ::serde::Deserialize,
8357    ::derive_builder::Builder,
8358    ::validator::Validate,
8359)]
8360pub struct Max9999HexBinaryText {
8361    #[validate(regex = "MAX_9999_HEX_BINARY_TEXT_REGEX")]
8362    #[serde(rename = "$text")]
8363    pub value: String,
8364}
8365#[derive(
8366    Debug,
8367    Default,
8368    Clone,
8369    PartialEq,
8370    ::serde::Serialize,
8371    ::serde::Deserialize,
8372    ::derive_builder::Builder,
8373    ::validator::Validate,
8374)]
8375pub struct EncapsulatedContent3 {
8376    #[serde(rename = "CnttTp")]
8377    pub cntt_tp: ContentType2Code,
8378    #[serde(rename = "Cntt", skip_serializing_if = "Option::is_none")]
8379    pub cntt: Option<Max100KBinary>,
8380}
8381#[derive(
8382    Debug,
8383    Default,
8384    Clone,
8385    PartialEq,
8386    ::serde::Serialize,
8387    ::serde::Deserialize,
8388    ::derive_builder::Builder,
8389    ::validator::Validate,
8390)]
8391pub struct DepartureOrArrival1 {
8392    #[serde(rename = "Lctn", skip_serializing_if = "Option::is_none")]
8393    pub lctn: Option<Max70Text>,
8394    #[serde(rename = "Desc", skip_serializing_if = "Option::is_none")]
8395    pub desc: Option<Max256Text>,
8396    #[serde(rename = "Dt", skip_serializing_if = "Option::is_none")]
8397    pub dt: Option<IsoDate>,
8398    #[serde(rename = "Tm", skip_serializing_if = "Option::is_none")]
8399    pub tm: Option<IsoTime>,
8400}
8401#[derive(
8402    Debug,
8403    Default,
8404    Clone,
8405    PartialEq,
8406    ::serde::Serialize,
8407    ::serde::Deserialize,
8408    ::derive_builder::Builder,
8409    ::validator::Validate,
8410)]
8411pub struct YesNoIndicator {
8412    #[serde(rename = "$text")]
8413    pub value: bool,
8414}
8415#[derive(
8416    Debug,
8417    Default,
8418    Clone,
8419    PartialEq,
8420    ::serde::Serialize,
8421    ::serde::Deserialize,
8422    ::derive_builder::Builder,
8423    ::validator::Validate,
8424)]
8425pub struct CryptographicKey13 {
8426    #[validate]
8427    #[serde(rename = "Id")]
8428    pub id: Max140Text,
8429    #[serde(rename = "AddtlId", skip_serializing_if = "Option::is_none")]
8430    pub addtl_id: Option<Max35Binary>,
8431    #[validate]
8432    #[serde(rename = "Vrsn")]
8433    pub vrsn: Max256Text,
8434    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
8435    pub tp: Option<CryptographicKeyType3Code>,
8436    #[validate(length(min = 0,))]
8437    #[serde(rename = "Fctn", default)]
8438    pub fctn: Vec<KeyUsage1Code>,
8439    #[serde(rename = "ActvtnDt", skip_serializing_if = "Option::is_none")]
8440    pub actvtn_dt: Option<IsoDateTime>,
8441    #[serde(rename = "DeactvtnDt", skip_serializing_if = "Option::is_none")]
8442    pub deactvtn_dt: Option<IsoDateTime>,
8443    #[serde(rename = "KeyVal", skip_serializing_if = "Option::is_none")]
8444    pub key_val: Option<ContentInformationType19>,
8445    #[serde(rename = "KeyChckVal", skip_serializing_if = "Option::is_none")]
8446    pub key_chck_val: Option<Max35Binary>,
8447    #[validate(length(min = 0,))]
8448    #[serde(rename = "AddtlMgmtInf", default)]
8449    pub addtl_mgmt_inf: Vec<GenericInformation1>,
8450}
8451#[derive(
8452    Debug,
8453    Default,
8454    Clone,
8455    PartialEq,
8456    ::serde::Serialize,
8457    ::serde::Deserialize,
8458    ::derive_builder::Builder,
8459    ::validator::Validate,
8460)]
8461pub struct DriverInParty2 {
8462    #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
8463    pub nm: Option<Max70Text>,
8464    #[serde(rename = "Adr", skip_serializing_if = "Option::is_none")]
8465    pub adr: Option<Address2>,
8466    #[serde(rename = "Ctct", skip_serializing_if = "Option::is_none")]
8467    pub ctct: Option<Contact6>,
8468    #[serde(rename = "DtOfBirth", skip_serializing_if = "Option::is_none")]
8469    pub dt_of_birth: Option<IsoDate>,
8470    #[serde(rename = "Age", skip_serializing_if = "Option::is_none")]
8471    pub age: Option<Max2NumericText>,
8472    #[validate(length(min = 0,))]
8473    #[serde(rename = "DrvrCrdntl", default)]
8474    pub drvr_crdntl: Vec<TravelDocument2>,
8475    #[serde(rename = "DrvgLic", skip_serializing_if = "Option::is_none")]
8476    pub drvg_lic: Option<DrivingLicense2>,
8477}
8478#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
8479pub enum CardholderVerificationCapability5Code {
8480    #[serde(rename = "APKI")]
8481    Apki,
8482    #[serde(rename = "NOVF")]
8483    Novf,
8484    #[serde(rename = "FBIG")]
8485    Fbig,
8486    #[serde(rename = "FBIO")]
8487    Fbio,
8488    #[serde(rename = "FDSG")]
8489    Fdsg,
8490    #[serde(rename = "FCPN")]
8491    Fcpn,
8492    #[serde(rename = "FEPN")]
8493    Fepn,
8494    #[serde(rename = "NBIO")]
8495    Nbio,
8496    #[serde(rename = "NPIN")]
8497    Npin,
8498    #[serde(rename = "OTHN")]
8499    Othn,
8500    #[serde(rename = "OTHP")]
8501    Othp,
8502    #[serde(rename = "SIGN")]
8503    Sign,
8504    #[serde(rename = "UNSP")]
8505    Unsp,
8506    #[serde(rename = "VORN")]
8507    Vorn,
8508    #[serde(rename = "PKIS")]
8509    Pkis,
8510    #[serde(rename = "NOPN")]
8511    Nopn,
8512    #[serde(rename = "NOOP")]
8513    Noop,
8514    #[default]
8515    Unknown,
8516}
8517#[derive(
8518    Debug,
8519    Default,
8520    Clone,
8521    PartialEq,
8522    ::serde::Serialize,
8523    ::serde::Deserialize,
8524    ::derive_builder::Builder,
8525    ::validator::Validate,
8526)]
8527pub struct Adjustment9 {
8528    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
8529    pub tp: Option<Max35Text>,
8530    #[serde(rename = "AddtlTp", skip_serializing_if = "Option::is_none")]
8531    pub addtl_tp: Option<Max35Text>,
8532    #[serde(rename = "Desc", skip_serializing_if = "Option::is_none")]
8533    pub desc: Option<Max70Text>,
8534    #[serde(rename = "Rsn", skip_serializing_if = "Option::is_none")]
8535    pub rsn: Option<Max35Text>,
8536    #[serde(rename = "PrmtnCd", skip_serializing_if = "Option::is_none")]
8537    pub prmtn_cd: Option<Max35Text>,
8538    #[serde(rename = "Pctg", skip_serializing_if = "Option::is_none")]
8539    pub pctg: Option<PercentageRate>,
8540    #[serde(rename = "AdjstmntAmt", skip_serializing_if = "Option::is_none")]
8541    pub adjstmnt_amt: Option<ImpliedCurrencyAndAmount>,
8542    #[serde(rename = "TaxClctdOnOrgnlAmt", skip_serializing_if = "Option::is_none")]
8543    pub tax_clctd_on_orgnl_amt: Option<TrueFalseIndicator>,
8544}
8545#[derive(
8546    Debug,
8547    Default,
8548    Clone,
8549    PartialEq,
8550    ::serde::Serialize,
8551    ::serde::Deserialize,
8552    ::derive_builder::Builder,
8553    ::validator::Validate,
8554)]
8555pub struct Max6NumericText {
8556    #[validate(regex = "MAX_6_NUMERIC_TEXT_REGEX")]
8557    #[serde(rename = "$text")]
8558    pub value: String,
8559}
8560#[derive(
8561    Debug,
8562    Default,
8563    Clone,
8564    PartialEq,
8565    ::serde::Serialize,
8566    ::serde::Deserialize,
8567    ::derive_builder::Builder,
8568    ::validator::Validate,
8569)]
8570pub struct ExchangeRateInformation2 {
8571    #[serde(rename = "Prvdr", skip_serializing_if = "Option::is_none")]
8572    pub prvdr: Option<Max70Text>,
8573    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
8574    pub id: Option<Max70Text>,
8575    #[serde(rename = "Dt", skip_serializing_if = "Option::is_none")]
8576    pub dt: Option<IsoDate>,
8577    #[serde(rename = "Tm", skip_serializing_if = "Option::is_none")]
8578    pub tm: Option<IsoTime>,
8579    #[serde(rename = "XchgRateDtl", skip_serializing_if = "Option::is_none")]
8580    pub xchg_rate_dtl: Option<ExchangeRateDetail1>,
8581    #[serde(rename = "RateLck", skip_serializing_if = "Option::is_none")]
8582    pub rate_lck: Option<RateLock1>,
8583}
8584#[derive(
8585    Debug,
8586    Default,
8587    Clone,
8588    PartialEq,
8589    ::serde::Serialize,
8590    ::serde::Deserialize,
8591    ::derive_builder::Builder,
8592    ::validator::Validate,
8593)]
8594pub struct DigestedData5 {
8595    #[serde(rename = "Vrsn", skip_serializing_if = "Option::is_none")]
8596    pub vrsn: Option<Number>,
8597    #[validate]
8598    #[serde(rename = "DgstAlgo")]
8599    pub dgst_algo: AlgorithmIdentification21,
8600    #[validate]
8601    #[serde(rename = "NcpsltdCntt")]
8602    pub ncpsltd_cntt: EncapsulatedContent3,
8603    #[validate]
8604    #[serde(rename = "Dgst")]
8605    pub dgst: Max140Binary,
8606}
8607#[derive(
8608    Debug,
8609    Default,
8610    Clone,
8611    PartialEq,
8612    ::serde::Serialize,
8613    ::serde::Deserialize,
8614    ::derive_builder::Builder,
8615    ::validator::Validate,
8616)]
8617pub struct Parameter11 {
8618    #[serde(rename = "DgstAlgo")]
8619    pub dgst_algo: Algorithm16Code,
8620    #[validate]
8621    #[serde(rename = "MskGnrtrAlgo")]
8622    pub msk_gnrtr_algo: AlgorithmIdentification12,
8623    #[validate]
8624    #[serde(rename = "SaltLngth")]
8625    pub salt_lngth: Number,
8626    #[serde(rename = "TrlrFld", skip_serializing_if = "Option::is_none")]
8627    pub trlr_fld: Option<Number>,
8628}
8629#[derive(
8630    Debug,
8631    Default,
8632    Clone,
8633    PartialEq,
8634    ::serde::Serialize,
8635    ::serde::Deserialize,
8636    ::derive_builder::Builder,
8637    ::validator::Validate,
8638)]
8639pub struct Product7 {
8640    #[serde(rename = "PdctCd", skip_serializing_if = "Option::is_none")]
8641    pub pdct_cd: Option<Max70Text>,
8642    #[serde(rename = "SummryCmmdtyId", skip_serializing_if = "Option::is_none")]
8643    pub summry_cmmdty_id: Option<Max35Text>,
8644}
8645#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
8646pub enum TerminalType1Code {
8647    #[serde(rename = "ATMT")]
8648    Atmt,
8649    #[serde(rename = "MPOS")]
8650    Mpos,
8651    #[serde(rename = "OTHN")]
8652    Othn,
8653    #[serde(rename = "OTHP")]
8654    Othp,
8655    #[serde(rename = "POST")]
8656    Post,
8657    #[default]
8658    Unknown,
8659}
8660#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
8661pub enum UserInterface6Code {
8662    #[serde(rename = "CDSP")]
8663    Cdsp,
8664    #[serde(rename = "CRCP")]
8665    Crcp,
8666    #[serde(rename = "MDSP")]
8667    Mdsp,
8668    #[serde(rename = "MRCP")]
8669    Mrcp,
8670    #[serde(rename = "CRDO")]
8671    Crdo,
8672    #[serde(rename = "FILE")]
8673    File,
8674    #[serde(rename = "CHAP")]
8675    Chap,
8676    #[serde(rename = "MRAP")]
8677    Mrap,
8678    #[serde(rename = "MRIN")]
8679    Mrin,
8680    #[default]
8681    Unknown,
8682}
8683#[derive(
8684    Debug,
8685    Default,
8686    Clone,
8687    PartialEq,
8688    ::serde::Serialize,
8689    ::serde::Deserialize,
8690    ::derive_builder::Builder,
8691    ::validator::Validate,
8692)]
8693pub struct Max256Text {
8694    #[validate(length(min = 1, max = 256,))]
8695    #[serde(rename = "$text")]
8696    pub value: String,
8697}
8698#[derive(
8699    Debug,
8700    Default,
8701    Clone,
8702    PartialEq,
8703    ::serde::Serialize,
8704    ::serde::Deserialize,
8705    ::derive_builder::Builder,
8706    ::validator::Validate,
8707)]
8708pub struct LodgingSummary2 {
8709    #[serde(rename = "FolioNb", skip_serializing_if = "Option::is_none")]
8710    pub folio_nb: Option<Max35Text>,
8711    #[serde(rename = "Prprty", skip_serializing_if = "Option::is_none")]
8712    pub prprty: Option<LodgingProperty2>,
8713    #[serde(rename = "Cstmr", skip_serializing_if = "Option::is_none")]
8714    pub cstmr: Option<Customer8>,
8715    #[serde(rename = "NbOfRooms", skip_serializing_if = "Option::is_none")]
8716    pub nb_of_rooms: Option<Max4NumericText>,
8717    #[validate(length(min = 0,))]
8718    #[serde(rename = "Room", default)]
8719    pub room: Vec<LodgingRoom1>,
8720    #[serde(rename = "Drtn", skip_serializing_if = "Option::is_none")]
8721    pub drtn: Option<Max4NumericText>,
8722    #[serde(rename = "Arrvl", skip_serializing_if = "Option::is_none")]
8723    pub arrvl: Option<DepartureOrArrival2>,
8724    #[serde(rename = "Dprture", skip_serializing_if = "Option::is_none")]
8725    pub dprture: Option<DepartureOrArrival1>,
8726    #[serde(rename = "NoShowInd", skip_serializing_if = "Option::is_none")]
8727    pub no_show_ind: Option<TrueFalseIndicator>,
8728    #[serde(rename = "InsrncInd", skip_serializing_if = "Option::is_none")]
8729    pub insrnc_ind: Option<TrueFalseIndicator>,
8730    #[serde(rename = "InsrncAmt", skip_serializing_if = "Option::is_none")]
8731    pub insrnc_amt: Option<ImpliedCurrencyAndAmount>,
8732    #[validate(length(min = 0,))]
8733    #[serde(rename = "TtlTax", default)]
8734    pub ttl_tax: Vec<Tax39>,
8735    #[serde(rename = "TtlAmt", skip_serializing_if = "Option::is_none")]
8736    pub ttl_amt: Option<ImpliedCurrencyAndAmount>,
8737    #[validate(length(min = 0,))]
8738    #[serde(rename = "AuthrsdAmt", default)]
8739    pub authrsd_amt: Vec<AuthorisedAmount1>,
8740    #[serde(rename = "SummryCmmdtyId", skip_serializing_if = "Option::is_none")]
8741    pub summry_cmmdty_id: Option<Max35Text>,
8742    #[validate(length(min = 0,))]
8743    #[serde(rename = "LltyPrgrmm", default)]
8744    pub llty_prgrmm: Vec<LoyaltyProgramme2>,
8745    #[serde(rename = "AddtlData", skip_serializing_if = "Option::is_none")]
8746    pub addtl_data: Option<Max350Text>,
8747}
8748#[derive(
8749    Debug,
8750    Default,
8751    Clone,
8752    PartialEq,
8753    ::serde::Serialize,
8754    ::serde::Deserialize,
8755    ::derive_builder::Builder,
8756    ::validator::Validate,
8757)]
8758pub struct AuthorisedAmount1 {
8759    #[serde(rename = "DtTm", skip_serializing_if = "Option::is_none")]
8760    pub dt_tm: Option<IsoDateTime>,
8761    #[validate]
8762    #[serde(rename = "Amt")]
8763    pub amt: ImpliedCurrencyAndAmount,
8764    #[serde(rename = "AddtlData", skip_serializing_if = "Option::is_none")]
8765    pub addtl_data: Option<Max350Text>,
8766}
8767#[derive(
8768    Debug,
8769    Default,
8770    Clone,
8771    PartialEq,
8772    ::serde::Serialize,
8773    ::serde::Deserialize,
8774    ::derive_builder::Builder,
8775    ::validator::Validate,
8776)]
8777pub struct EnvelopedData6 {
8778    #[serde(rename = "Vrsn", skip_serializing_if = "Option::is_none")]
8779    pub vrsn: Option<Number>,
8780    #[validate(length(min = 1,))]
8781    #[serde(rename = "Rcpt", default)]
8782    pub rcpt: Vec<Recipient7Choice>,
8783    #[serde(rename = "NcrptdCntt", skip_serializing_if = "Option::is_none")]
8784    pub ncrptd_cntt: Option<EncryptedContent5>,
8785}
8786#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
8787pub enum KeyUsage1Code {
8788    #[serde(rename = "ENCR")]
8789    Encr,
8790    #[serde(rename = "DCPT")]
8791    Dcpt,
8792    #[serde(rename = "DENC")]
8793    Denc,
8794    #[serde(rename = "DDEC")]
8795    Ddec,
8796    #[serde(rename = "TRNI")]
8797    Trni,
8798    #[serde(rename = "TRNX")]
8799    Trnx,
8800    #[serde(rename = "MACG")]
8801    Macg,
8802    #[serde(rename = "MACV")]
8803    Macv,
8804    #[serde(rename = "SIGG")]
8805    Sigg,
8806    #[serde(rename = "SUGV")]
8807    Sugv,
8808    #[serde(rename = "PINE")]
8809    Pine,
8810    #[serde(rename = "PIND")]
8811    Pind,
8812    #[serde(rename = "PINV")]
8813    Pinv,
8814    #[serde(rename = "KEYG")]
8815    Keyg,
8816    #[serde(rename = "KEYI")]
8817    Keyi,
8818    #[serde(rename = "KEYX")]
8819    Keyx,
8820    #[serde(rename = "KEYD")]
8821    Keyd,
8822    #[default]
8823    Unknown,
8824}
8825#[derive(
8826    Debug,
8827    Default,
8828    Clone,
8829    PartialEq,
8830    ::serde::Serialize,
8831    ::serde::Deserialize,
8832    ::derive_builder::Builder,
8833    ::validator::Validate,
8834)]
8835pub struct ClaimInformation1 {
8836    #[serde(rename = "ClmCrdntls", skip_serializing_if = "Option::is_none")]
8837    pub clm_crdntls: Option<Max500Text>,
8838    #[serde(rename = "Assgnr", skip_serializing_if = "Option::is_none")]
8839    pub assgnr: Option<Max35Text>,
8840}
8841#[derive(
8842    Debug,
8843    Default,
8844    Clone,
8845    PartialEq,
8846    ::serde::Serialize,
8847    ::serde::Deserialize,
8848    ::derive_builder::Builder,
8849    ::validator::Validate,
8850)]
8851pub struct Environment34 {
8852    #[serde(rename = "Acqrr", skip_serializing_if = "Option::is_none")]
8853    pub acqrr: Option<PartyIdentification263>,
8854    #[serde(rename = "Orgtr", skip_serializing_if = "Option::is_none")]
8855    pub orgtr: Option<PartyIdentification263>,
8856    #[serde(rename = "Sndr", skip_serializing_if = "Option::is_none")]
8857    pub sndr: Option<PartyIdentification263>,
8858    #[serde(rename = "Rcvr", skip_serializing_if = "Option::is_none")]
8859    pub rcvr: Option<PartyIdentification263>,
8860    #[serde(rename = "Accptr", skip_serializing_if = "Option::is_none")]
8861    pub accptr: Option<PartyIdentification255>,
8862    #[serde(rename = "Dstn", skip_serializing_if = "Option::is_none")]
8863    pub dstn: Option<PartyIdentification263>,
8864    #[serde(rename = "Pyer", skip_serializing_if = "Option::is_none")]
8865    pub pyer: Option<PartyIdentification257>,
8866    #[serde(rename = "Pyee", skip_serializing_if = "Option::is_none")]
8867    pub pyee: Option<PartyIdentification257>,
8868    #[serde(rename = "Termnl", skip_serializing_if = "Option::is_none")]
8869    pub termnl: Option<Terminal4>,
8870    #[serde(rename = "Issr", skip_serializing_if = "Option::is_none")]
8871    pub issr: Option<PartyIdentification263>,
8872    #[serde(rename = "Card", skip_serializing_if = "Option::is_none")]
8873    pub card: Option<CardData6>,
8874    #[serde(rename = "CstmrDvc", skip_serializing_if = "Option::is_none")]
8875    pub cstmr_dvc: Option<CustomerDevice4>,
8876    #[serde(rename = "Wllt", skip_serializing_if = "Option::is_none")]
8877    pub wllt: Option<Wallet2>,
8878    #[serde(rename = "Tkn", skip_serializing_if = "Option::is_none")]
8879    pub tkn: Option<Token2>,
8880    #[serde(rename = "Crdhldr", skip_serializing_if = "Option::is_none")]
8881    pub crdhldr: Option<Cardholder19>,
8882    #[validate(length(min = 0,))]
8883    #[serde(rename = "AddtlData", default)]
8884    pub addtl_data: Vec<AdditionalData2>,
8885}
8886#[derive(
8887    Debug,
8888    Default,
8889    Clone,
8890    PartialEq,
8891    ::serde::Serialize,
8892    ::serde::Deserialize,
8893    ::derive_builder::Builder,
8894    ::validator::Validate,
8895)]
8896pub struct HiredVehicle2 {
8897    #[serde(rename = "CpnyTp", skip_serializing_if = "Option::is_none")]
8898    pub cpny_tp: Option<Max35Text>,
8899    #[serde(rename = "CpnyNm", skip_serializing_if = "Option::is_none")]
8900    pub cpny_nm: Option<Max70Text>,
8901    #[serde(rename = "TpOfVhcl", skip_serializing_if = "Option::is_none")]
8902    pub tp_of_vhcl: Option<Max35Text>,
8903    #[serde(rename = "VhclId", skip_serializing_if = "Option::is_none")]
8904    pub vhcl_id: Option<Max35Text>,
8905    #[serde(rename = "DrvrId", skip_serializing_if = "Option::is_none")]
8906    pub drvr_id: Option<Max35Text>,
8907    #[serde(rename = "DrvrTaxId", skip_serializing_if = "Option::is_none")]
8908    pub drvr_tax_id: Option<Max35Text>,
8909    #[serde(rename = "Dstn", skip_serializing_if = "Option::is_none")]
8910    pub dstn: Option<Destination3>,
8911}
8912#[derive(
8913    Debug,
8914    Default,
8915    Clone,
8916    PartialEq,
8917    ::serde::Serialize,
8918    ::serde::Deserialize,
8919    ::derive_builder::Builder,
8920    ::validator::Validate,
8921)]
8922pub struct MemoryCharacteristics1 {
8923    #[validate]
8924    #[serde(rename = "Id")]
8925    pub id: Max35Text,
8926    #[validate]
8927    #[serde(rename = "TtlSz")]
8928    pub ttl_sz: DecimalNumber,
8929    #[validate]
8930    #[serde(rename = "FreeSz")]
8931    pub free_sz: DecimalNumber,
8932    #[serde(rename = "Unit")]
8933    pub unit: MemoryUnit1Code,
8934}
8935#[derive(
8936    Debug,
8937    Default,
8938    Clone,
8939    PartialEq,
8940    ::serde::Serialize,
8941    ::serde::Deserialize,
8942    ::derive_builder::Builder,
8943    ::validator::Validate,
8944)]
8945pub struct AuthenticatedData5 {
8946    #[serde(rename = "Vrsn", skip_serializing_if = "Option::is_none")]
8947    pub vrsn: Option<Number>,
8948    #[validate(length(min = 1,))]
8949    #[serde(rename = "Rcpt", default)]
8950    pub rcpt: Vec<Recipient6Choice>,
8951    #[validate]
8952    #[serde(rename = "MACAlgo")]
8953    pub mac_algo: AlgorithmIdentification22,
8954    #[validate]
8955    #[serde(rename = "NcpsltdCntt")]
8956    pub ncpsltd_cntt: EncapsulatedContent3,
8957    #[validate]
8958    #[serde(rename = "MAC")]
8959    pub mac: Max140Binary,
8960}
8961#[derive(
8962    Debug,
8963    Default,
8964    Clone,
8965    PartialEq,
8966    ::serde::Serialize,
8967    ::serde::Deserialize,
8968    ::derive_builder::Builder,
8969    ::validator::Validate,
8970)]
8971pub struct Track2Data1ChoiceEnum {
8972    #[serde(rename = "TxtVal", skip_serializing_if = "Option::is_none")]
8973    pub txt_val: Option<Max37Text>,
8974    #[serde(rename = "HexBinryVal", skip_serializing_if = "Option::is_none")]
8975    pub hex_binry_val: Option<Max19HexBinaryText>,
8976}
8977#[derive(
8978    Debug,
8979    Default,
8980    Clone,
8981    PartialEq,
8982    ::serde::Serialize,
8983    ::serde::Deserialize,
8984    ::derive_builder::Builder,
8985    ::validator::Validate,
8986)]
8987pub struct Track2Data1Choice {
8988    #[serde(flatten)]
8989    pub value: Track2Data1ChoiceEnum,
8990}
8991#[derive(
8992    Debug,
8993    Default,
8994    Clone,
8995    PartialEq,
8996    ::serde::Serialize,
8997    ::serde::Deserialize,
8998    ::derive_builder::Builder,
8999    ::validator::Validate,
9000)]
9001pub struct EncryptedDataElement1 {
9002    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
9003    pub id: Option<ExternalEncryptedElementIdentification1Code>,
9004    #[serde(rename = "OthrId", skip_serializing_if = "Option::is_none")]
9005    pub othr_id: Option<Max35Text>,
9006    #[serde(rename = "NcrptdData")]
9007    pub ncrptd_data: EncryptedData1Choice,
9008    #[serde(rename = "ClearTxtDataFrmt", skip_serializing_if = "Option::is_none")]
9009    pub clear_txt_data_frmt: Option<EncryptedDataFormat1Code>,
9010    #[serde(
9011        rename = "OthrClearTxtDataFrmt",
9012        skip_serializing_if = "Option::is_none"
9013    )]
9014    pub othr_clear_txt_data_frmt: Option<Max35Text>,
9015}
9016#[derive(
9017    Debug,
9018    Default,
9019    Clone,
9020    PartialEq,
9021    ::serde::Serialize,
9022    ::serde::Deserialize,
9023    ::derive_builder::Builder,
9024    ::validator::Validate,
9025)]
9026pub struct TripInformation1 {
9027    #[serde(rename = "TripNb", skip_serializing_if = "Option::is_none")]
9028    pub trip_nb: Option<Max35Text>,
9029    #[serde(rename = "JobNb", skip_serializing_if = "Option::is_none")]
9030    pub job_nb: Option<Max10Text>,
9031    #[serde(rename = "WorkOrdr", skip_serializing_if = "Option::is_none")]
9032    pub work_ordr: Option<Max70Text>,
9033    #[serde(rename = "InvcNb", skip_serializing_if = "Option::is_none")]
9034    pub invc_nb: Option<Max70Text>,
9035    #[serde(rename = "BllgId", skip_serializing_if = "Option::is_none")]
9036    pub bllg_id: Option<Max70Text>,
9037    #[serde(rename = "CtrlNb", skip_serializing_if = "Option::is_none")]
9038    pub ctrl_nb: Option<Max35Text>,
9039    #[serde(rename = "DlvryTcktNb", skip_serializing_if = "Option::is_none")]
9040    pub dlvry_tckt_nb: Option<Max35Text>,
9041}
9042#[derive(
9043    Debug,
9044    Default,
9045    Clone,
9046    PartialEq,
9047    ::serde::Serialize,
9048    ::serde::Deserialize,
9049    ::derive_builder::Builder,
9050    ::validator::Validate,
9051)]
9052pub struct LodgingLineItem2 {
9053    #[serde(rename = "Dt", skip_serializing_if = "Option::is_none")]
9054    pub dt: Option<IsoDate>,
9055    #[serde(rename = "Tm", skip_serializing_if = "Option::is_none")]
9056    pub tm: Option<IsoTime>,
9057    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
9058    pub tp: Option<LodgingService1Code>,
9059    #[serde(rename = "OthrTp", skip_serializing_if = "Option::is_none")]
9060    pub othr_tp: Option<Max35Text>,
9061    #[serde(rename = "PstChckOutInd", skip_serializing_if = "Option::is_none")]
9062    pub pst_chck_out_ind: Option<TrueFalseIndicator>,
9063    #[serde(rename = "CdtDbt", skip_serializing_if = "Option::is_none")]
9064    pub cdt_dbt: Option<CreditDebit3Code>,
9065    #[serde(rename = "UnitAmt", skip_serializing_if = "Option::is_none")]
9066    pub unit_amt: Option<ImpliedCurrencyAndAmount>,
9067    #[serde(rename = "Drtn", skip_serializing_if = "Option::is_none")]
9068    pub drtn: Option<Max4NumericText>,
9069    #[serde(rename = "SubTtlAmt", skip_serializing_if = "Option::is_none")]
9070    pub sub_ttl_amt: Option<ImpliedCurrencyAndAmount>,
9071    #[validate(length(min = 0,))]
9072    #[serde(rename = "Tax", default)]
9073    pub tax: Vec<Tax39>,
9074    #[serde(rename = "AddtlData", skip_serializing_if = "Option::is_none")]
9075    pub addtl_data: Option<Max350Text>,
9076}
9077#[derive(
9078    Debug,
9079    Default,
9080    Clone,
9081    PartialEq,
9082    ::serde::Serialize,
9083    ::serde::Deserialize,
9084    ::derive_builder::Builder,
9085    ::validator::Validate,
9086)]
9087pub struct Max3000Binary {
9088    #[validate(length(min = 1, max = 3000,), regex = "MAX_3000_BINARY_REGEX")]
9089    pub value: String,
9090}
9091#[derive(
9092    Debug,
9093    Default,
9094    Clone,
9095    PartialEq,
9096    ::serde::Serialize,
9097    ::serde::Deserialize,
9098    ::derive_builder::Builder,
9099    ::validator::Validate,
9100)]
9101pub struct Signer4 {
9102    #[serde(rename = "Vrsn", skip_serializing_if = "Option::is_none")]
9103    pub vrsn: Option<Number>,
9104    #[serde(rename = "SgnrId", skip_serializing_if = "Option::is_none")]
9105    pub sgnr_id: Option<Recipient5Choice>,
9106    #[validate]
9107    #[serde(rename = "DgstAlgo")]
9108    pub dgst_algo: AlgorithmIdentification21,
9109    #[validate(length(min = 0,))]
9110    #[serde(rename = "SgndAttrbts", default)]
9111    pub sgnd_attrbts: Vec<GenericInformation1>,
9112    #[validate]
9113    #[serde(rename = "SgntrAlgo")]
9114    pub sgntr_algo: AlgorithmIdentification20,
9115    #[validate]
9116    #[serde(rename = "Sgntr")]
9117    pub sgntr: Max3000Binary,
9118}
9119#[derive(
9120    Debug,
9121    Default,
9122    Clone,
9123    PartialEq,
9124    ::serde::Serialize,
9125    ::serde::Deserialize,
9126    ::derive_builder::Builder,
9127    ::validator::Validate,
9128)]
9129pub struct Distance1 {
9130    #[serde(rename = "UnitOfMeasr", skip_serializing_if = "Option::is_none")]
9131    pub unit_of_measr: Option<UnitOfMeasure10Code>,
9132    #[serde(rename = "OdmtrStart", skip_serializing_if = "Option::is_none")]
9133    pub odmtr_start: Option<Max10NumericText>,
9134    #[serde(rename = "OdmtrRtr", skip_serializing_if = "Option::is_none")]
9135    pub odmtr_rtr: Option<Max10NumericText>,
9136    #[serde(rename = "TtlDstnc", skip_serializing_if = "Option::is_none")]
9137    pub ttl_dstnc: Option<Max10NumericText>,
9138    #[serde(rename = "FreeDstnc", skip_serializing_if = "Option::is_none")]
9139    pub free_dstnc: Option<Max10NumericText>,
9140    #[serde(rename = "Rate", skip_serializing_if = "Option::is_none")]
9141    pub rate: Option<ImpliedCurrencyAndAmount>,
9142}
9143#[derive(
9144    Debug,
9145    Default,
9146    Clone,
9147    PartialEq,
9148    ::serde::Serialize,
9149    ::serde::Deserialize,
9150    ::derive_builder::Builder,
9151    ::validator::Validate,
9152)]
9153pub struct Recipient5ChoiceEnum {
9154    #[serde(rename = "KeyIdr", skip_serializing_if = "Option::is_none")]
9155    pub key_idr: Option<KekIdentifier2>,
9156    #[serde(rename = "IssrAndSrlNb", skip_serializing_if = "Option::is_none")]
9157    pub issr_and_srl_nb: Option<IssuerAndSerialNumber1>,
9158}
9159#[derive(
9160    Debug,
9161    Default,
9162    Clone,
9163    PartialEq,
9164    ::serde::Serialize,
9165    ::serde::Deserialize,
9166    ::derive_builder::Builder,
9167    ::validator::Validate,
9168)]
9169pub struct Recipient5Choice {
9170    #[serde(flatten)]
9171    pub value: Recipient5ChoiceEnum,
9172}
9173#[derive(
9174    Debug,
9175    Default,
9176    Clone,
9177    PartialEq,
9178    ::serde::Serialize,
9179    ::serde::Deserialize,
9180    ::derive_builder::Builder,
9181    ::validator::Validate,
9182)]
9183pub struct AdditionalInformation19 {
9184    #[serde(rename = "NtrdDataNmrc", skip_serializing_if = "Option::is_none")]
9185    pub ntrd_data_nmrc: Option<Max35NumericText>,
9186    #[serde(rename = "NtrdDataAlphaNmrc", skip_serializing_if = "Option::is_none")]
9187    pub ntrd_data_alpha_nmrc: Option<Max350Text>,
9188    #[serde(rename = "AddtlData", skip_serializing_if = "Option::is_none")]
9189    pub addtl_data: Option<Max350Text>,
9190}
9191#[derive(
9192    Debug,
9193    Default,
9194    Clone,
9195    PartialEq,
9196    ::serde::Serialize,
9197    ::serde::Deserialize,
9198    ::derive_builder::Builder,
9199    ::validator::Validate,
9200)]
9201pub struct AlgorithmIdentification28 {
9202    #[serde(rename = "Algo")]
9203    pub algo: Algorithm13Code,
9204    #[serde(rename = "Param", skip_serializing_if = "Option::is_none")]
9205    pub param: Option<Parameter14>,
9206}
9207#[derive(
9208    Debug,
9209    Default,
9210    Clone,
9211    PartialEq,
9212    ::serde::Serialize,
9213    ::serde::Deserialize,
9214    ::derive_builder::Builder,
9215    ::validator::Validate,
9216)]
9217pub struct PointOfInteractionComponent13 {
9218    #[serde(rename = "Tp")]
9219    pub tp: PoiComponentType5Code,
9220    #[validate]
9221    #[serde(rename = "Id")]
9222    pub id: PointOfInteractionComponentIdentification3,
9223    #[serde(rename = "Sts", skip_serializing_if = "Option::is_none")]
9224    pub sts: Option<PointOfInteractionComponentStatus3>,
9225    #[validate(length(min = 0,))]
9226    #[serde(rename = "StdCmplc", default)]
9227    pub std_cmplc: Vec<GenericIdentification48>,
9228    #[serde(rename = "Chrtcs", skip_serializing_if = "Option::is_none")]
9229    pub chrtcs: Option<PointOfInteractionComponentCharacteristics4>,
9230    #[validate(length(min = 0,))]
9231    #[serde(rename = "Assmnt", default)]
9232    pub assmnt: Vec<PointOfInteractionComponentIdentification3>,
9233}
9234#[derive(
9235    Debug,
9236    Default,
9237    Clone,
9238    PartialEq,
9239    ::serde::Serialize,
9240    ::serde::Deserialize,
9241    ::derive_builder::Builder,
9242    ::validator::Validate,
9243)]
9244pub struct ReservationDetails3 {
9245    #[serde(rename = "Sys", skip_serializing_if = "Option::is_none")]
9246    pub sys: Option<Max4Text>,
9247    #[serde(rename = "RsvatnNb", skip_serializing_if = "Option::is_none")]
9248    pub rsvatn_nb: Option<Max35Text>,
9249    #[serde(rename = "OrgnlSys", skip_serializing_if = "Option::is_none")]
9250    pub orgnl_sys: Option<Max4Text>,
9251    #[serde(rename = "OrgnlRsvatnNb", skip_serializing_if = "Option::is_none")]
9252    pub orgnl_rsvatn_nb: Option<Max35Text>,
9253}
9254#[derive(
9255    Debug,
9256    Default,
9257    Clone,
9258    PartialEq,
9259    ::serde::Serialize,
9260    ::serde::Deserialize,
9261    ::derive_builder::Builder,
9262    ::validator::Validate,
9263)]
9264pub struct SaleItem3 {
9265    #[serde(rename = "PdctTp", skip_serializing_if = "Option::is_none")]
9266    pub pdct_tp: Option<Max35Text>,
9267    #[serde(rename = "PdctCd", skip_serializing_if = "Option::is_none")]
9268    pub pdct_cd: Option<Max70Text>,
9269    #[serde(rename = "PdctCdTp", skip_serializing_if = "Option::is_none")]
9270    pub pdct_cd_tp: Option<ProductCodeType1Code>,
9271    #[serde(rename = "AddtlPdctCd", skip_serializing_if = "Option::is_none")]
9272    pub addtl_pdct_cd: Option<Max70Text>,
9273    #[serde(rename = "AddtlPdctCdTp", skip_serializing_if = "Option::is_none")]
9274    pub addtl_pdct_cd_tp: Option<Max35Text>,
9275    #[serde(rename = "PdctCdModfr", skip_serializing_if = "Option::is_none")]
9276    pub pdct_cd_modfr: Option<DecimalNumber>,
9277    #[serde(rename = "PdctDesc", skip_serializing_if = "Option::is_none")]
9278    pub pdct_desc: Option<Max140Text>,
9279    #[serde(rename = "UnitOfMeasr", skip_serializing_if = "Option::is_none")]
9280    pub unit_of_measr: Option<UnitOfMeasure1Code>,
9281    #[serde(rename = "OthrUnitOfMeasr", skip_serializing_if = "Option::is_none")]
9282    pub othr_unit_of_measr: Option<Max35Text>,
9283    #[serde(rename = "PdctQty", skip_serializing_if = "Option::is_none")]
9284    pub pdct_qty: Option<DecimalNumber>,
9285    #[serde(rename = "NonAdjstdUnitPric", skip_serializing_if = "Option::is_none")]
9286    pub non_adjstd_unit_pric: Option<ImpliedCurrencyAndAmount>,
9287    #[serde(rename = "NonAdjstdTtlAmt", skip_serializing_if = "Option::is_none")]
9288    pub non_adjstd_ttl_amt: Option<ImpliedCurrencyAndAmount>,
9289    #[validate(length(min = 0,))]
9290    #[serde(rename = "Adjstmnt", default)]
9291    pub adjstmnt: Vec<Adjustment10>,
9292    #[serde(rename = "AdjstdAmt", skip_serializing_if = "Option::is_none")]
9293    pub adjstd_amt: Option<ImpliedCurrencyAndAmount>,
9294    #[serde(rename = "InsrncInd", skip_serializing_if = "Option::is_none")]
9295    pub insrnc_ind: Option<TrueFalseIndicator>,
9296    #[serde(rename = "InsrncAmt", skip_serializing_if = "Option::is_none")]
9297    pub insrnc_amt: Option<ImpliedCurrencyAndAmount>,
9298    #[validate(length(min = 0,))]
9299    #[serde(rename = "Tax", default)]
9300    pub tax: Vec<Tax39>,
9301    #[serde(rename = "TtlAmt", skip_serializing_if = "Option::is_none")]
9302    pub ttl_amt: Option<ImpliedCurrencyAndAmount>,
9303}
9304#[derive(
9305    Debug,
9306    Default,
9307    Clone,
9308    PartialEq,
9309    ::serde::Serialize,
9310    ::serde::Deserialize,
9311    ::derive_builder::Builder,
9312    ::validator::Validate,
9313)]
9314pub struct TripLeg2 {
9315    #[serde(rename = "SeqNb", skip_serializing_if = "Option::is_none")]
9316    pub seq_nb: Option<Max35NumericText>,
9317    #[serde(rename = "Tckt", skip_serializing_if = "Option::is_none")]
9318    pub tckt: Option<Ticket2>,
9319    #[validate(length(min = 0,))]
9320    #[serde(rename = "Doc", default)]
9321    pub doc: Vec<DocumentReference1>,
9322    #[serde(rename = "PrcdrRef", skip_serializing_if = "Option::is_none")]
9323    pub prcdr_ref: Option<Max35Text>,
9324    #[serde(rename = "TrnsprtTp", skip_serializing_if = "Option::is_none")]
9325    pub trnsprt_tp: Option<TransportType1Code>,
9326    #[serde(rename = "OthrTrnsprtTp", skip_serializing_if = "Option::is_none")]
9327    pub othr_trnsprt_tp: Option<Max35Text>,
9328    #[serde(rename = "CmmdtyCd", skip_serializing_if = "Option::is_none")]
9329    pub cmmdty_cd: Option<Max4Text>,
9330    #[serde(rename = "Crrier", skip_serializing_if = "Option::is_none")]
9331    pub crrier: Option<CarrierIdentification1>,
9332    #[serde(rename = "RouteNb", skip_serializing_if = "Option::is_none")]
9333    pub route_nb: Option<Max35Text>,
9334    #[serde(rename = "SvcClss", skip_serializing_if = "Option::is_none")]
9335    pub svc_clss: Option<Max35Text>,
9336    #[serde(rename = "Dprture", skip_serializing_if = "Option::is_none")]
9337    pub dprture: Option<DepartureOrArrival1>,
9338    #[serde(rename = "Arrvl", skip_serializing_if = "Option::is_none")]
9339    pub arrvl: Option<DepartureOrArrival1>,
9340    #[serde(rename = "Drtn", skip_serializing_if = "Option::is_none")]
9341    pub drtn: Option<Max4NumericText>,
9342    #[serde(rename = "StopOverInd", skip_serializing_if = "Option::is_none")]
9343    pub stop_over_ind: Option<TrueFalseIndicator>,
9344    #[serde(rename = "NonDrctRouteCd", skip_serializing_if = "Option::is_none")]
9345    pub non_drct_route_cd: Option<Max35Text>,
9346    #[serde(rename = "FairBsisCd", skip_serializing_if = "Option::is_none")]
9347    pub fair_bsis_cd: Option<Max35Text>,
9348    #[serde(rename = "InsrncInd", skip_serializing_if = "Option::is_none")]
9349    pub insrnc_ind: Option<TrueFalseIndicator>,
9350    #[validate(length(min = 0,))]
9351    #[serde(rename = "TripLegAmt", default)]
9352    pub trip_leg_amt: Vec<AmountDetails2>,
9353    #[serde(rename = "CdtRsnCd", skip_serializing_if = "Option::is_none")]
9354    pub cdt_rsn_cd: Option<Max35Text>,
9355    #[serde(rename = "PrcdrId", skip_serializing_if = "Option::is_none")]
9356    pub prcdr_id: Option<Max35Text>,
9357    #[serde(rename = "LltyPrgrmm", skip_serializing_if = "Option::is_none")]
9358    pub llty_prgrmm: Option<LoyaltyProgramme2>,
9359    #[serde(rename = "AddtlData", skip_serializing_if = "Option::is_none")]
9360    pub addtl_data: Option<Max350Text>,
9361}
9362#[derive(
9363    Debug,
9364    Default,
9365    Clone,
9366    PartialEq,
9367    ::serde::Serialize,
9368    ::serde::Deserialize,
9369    ::derive_builder::Builder,
9370    ::validator::Validate,
9371)]
9372pub struct SignedData5 {
9373    #[serde(rename = "Vrsn", skip_serializing_if = "Option::is_none")]
9374    pub vrsn: Option<Number>,
9375    #[validate(length(min = 0,))]
9376    #[serde(rename = "DgstAlgo", default)]
9377    pub dgst_algo: Vec<AlgorithmIdentification21>,
9378    #[serde(rename = "NcpsltdCntt", skip_serializing_if = "Option::is_none")]
9379    pub ncpsltd_cntt: Option<EncapsulatedContent3>,
9380    #[validate(length(min = 0,))]
9381    #[serde(rename = "Cert", default)]
9382    pub cert: Vec<Max5000Binary>,
9383    #[validate(length(min = 0,))]
9384    #[serde(rename = "Sgnr", default)]
9385    pub sgnr: Vec<Signer4>,
9386}
9387#[derive(
9388    Debug,
9389    Default,
9390    Clone,
9391    PartialEq,
9392    ::serde::Serialize,
9393    ::serde::Deserialize,
9394    ::derive_builder::Builder,
9395    ::validator::Validate,
9396)]
9397pub struct CustomerDevice4 {
9398    #[serde(rename = "Dvc", skip_serializing_if = "Option::is_none")]
9399    pub dvc: Option<Device2>,
9400    #[serde(rename = "DvcId", skip_serializing_if = "Option::is_none")]
9401    pub dvc_id: Option<DeviceIdentification1>,
9402    #[serde(rename = "OprgSys", skip_serializing_if = "Option::is_none")]
9403    pub oprg_sys: Option<DeviceOperatingSystem1>,
9404    #[serde(rename = "Prvdr", skip_serializing_if = "Option::is_none")]
9405    pub prvdr: Option<Max35Text>,
9406    #[validate(length(min = 0,))]
9407    #[serde(rename = "AddtlData", default)]
9408    pub addtl_data: Vec<AdditionalData1>,
9409}
9410#[derive(
9411    Debug,
9412    Default,
9413    Clone,
9414    PartialEq,
9415    ::serde::Serialize,
9416    ::serde::Deserialize,
9417    ::derive_builder::Builder,
9418    ::validator::Validate,
9419)]
9420pub struct Max4000Text {
9421    #[validate(length(min = 1, max = 4000,))]
9422    #[serde(rename = "$text")]
9423    pub value: String,
9424}
9425#[derive(
9426    Debug,
9427    Default,
9428    Clone,
9429    PartialEq,
9430    ::serde::Serialize,
9431    ::serde::Deserialize,
9432    ::derive_builder::Builder,
9433    ::validator::Validate,
9434)]
9435pub struct AddendumData3 {
9436    #[serde(rename = "PurchsIdrTp", skip_serializing_if = "Option::is_none")]
9437    pub purchs_idr_tp: Option<PurchaseIdentifierType1Code>,
9438    #[serde(rename = "OthrPurchsIdrTp", skip_serializing_if = "Option::is_none")]
9439    pub othr_purchs_idr_tp: Option<Max35Text>,
9440    #[serde(rename = "PurchsIdr", skip_serializing_if = "Option::is_none")]
9441    pub purchs_idr: Option<Max99Text>,
9442    #[serde(rename = "AddtlAccptrData", skip_serializing_if = "Option::is_none")]
9443    pub addtl_accptr_data: Option<AdditionalAcceptorData1>,
9444    #[serde(rename = "Cstmr", skip_serializing_if = "Option::is_none")]
9445    pub cstmr: Option<Customer4>,
9446    #[serde(rename = "Sale", skip_serializing_if = "Option::is_none")]
9447    pub sale: Option<Sale2>,
9448    #[serde(rename = "Fleet", skip_serializing_if = "Option::is_none")]
9449    pub fleet: Option<FleetData4>,
9450    #[serde(rename = "Invc", skip_serializing_if = "Option::is_none")]
9451    pub invc: Option<Invoice2>,
9452    #[validate(length(min = 0,))]
9453    #[serde(rename = "TrvlAgcy", default)]
9454    pub trvl_agcy: Vec<TravelAgency3>,
9455    #[serde(rename = "PssngrTrnsprt", skip_serializing_if = "Option::is_none")]
9456    pub pssngr_trnsprt: Option<PassengerTransport2>,
9457    #[validate(length(min = 0,))]
9458    #[serde(rename = "VhclRntl", default)]
9459    pub vhcl_rntl: Vec<VehicleRentalService2>,
9460    #[validate(length(min = 0,))]
9461    #[serde(rename = "Ldgg", default)]
9462    pub ldgg: Vec<Lodging3>,
9463    #[serde(rename = "ShppgData", skip_serializing_if = "Option::is_none")]
9464    pub shppg_data: Option<ShippingData2>,
9465    #[serde(rename = "TelecomSvcs", skip_serializing_if = "Option::is_none")]
9466    pub telecom_svcs: Option<TelecomServices2>,
9467    #[validate(length(min = 0,))]
9468    #[serde(rename = "TempSvcs", default)]
9469    pub temp_svcs: Vec<TemporaryServices2>,
9470    #[serde(rename = "Instlmt", skip_serializing_if = "Option::is_none")]
9471    pub instlmt: Option<Instalment4>,
9472    #[validate(length(min = 0,))]
9473    #[serde(rename = "AddtlData", default)]
9474    pub addtl_data: Vec<AdditionalData1>,
9475}
9476#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
9477pub enum PartyType9Code {
9478    #[serde(rename = "ACQR")]
9479    Acqr,
9480    #[serde(rename = "ACQP")]
9481    Acqp,
9482    #[serde(rename = "CISS")]
9483    Ciss,
9484    #[serde(rename = "CISP")]
9485    Cisp,
9486    #[serde(rename = "CSCH")]
9487    Csch,
9488    #[serde(rename = "SCHP")]
9489    Schp,
9490    #[default]
9491    Unknown,
9492}
9493#[derive(
9494    Debug,
9495    Default,
9496    Clone,
9497    PartialEq,
9498    ::serde::Serialize,
9499    ::serde::Deserialize,
9500    ::derive_builder::Builder,
9501    ::validator::Validate,
9502)]
9503pub struct AdditionalCharacteristicDetails1 {
9504    #[validate]
9505    #[serde(rename = "Tp")]
9506    pub tp: Max35Text,
9507    #[serde(rename = "PrvddBy", skip_serializing_if = "Option::is_none")]
9508    pub prvdd_by: Option<Max35Text>,
9509}
9510#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
9511pub enum ActionDestination1Code {
9512    #[serde(rename = "FILE")]
9513    File,
9514    #[serde(rename = "MOBL")]
9515    Mobl,
9516    #[serde(rename = "OTHN")]
9517    Othn,
9518    #[serde(rename = "OTHP")]
9519    Othp,
9520    #[serde(rename = "PECR")]
9521    Pecr,
9522    #[serde(rename = "POFS")]
9523    Pofs,
9524    #[default]
9525    Unknown,
9526}
9527#[derive(
9528    Debug,
9529    Default,
9530    Clone,
9531    PartialEq,
9532    ::serde::Serialize,
9533    ::serde::Deserialize,
9534    ::derive_builder::Builder,
9535    ::validator::Validate,
9536)]
9537pub struct Iso8583ResponseCode {
9538    #[validate(regex = "ISO_8583_RESPONSE_CODE_REGEX")]
9539    #[serde(rename = "$text")]
9540    pub value: String,
9541}
9542#[derive(
9543    Debug,
9544    Default,
9545    Clone,
9546    PartialEq,
9547    ::serde::Serialize,
9548    ::serde::Deserialize,
9549    ::derive_builder::Builder,
9550    ::validator::Validate,
9551)]
9552pub struct Adjustment12 {
9553    #[validate]
9554    #[serde(rename = "Amt")]
9555    pub amt: ImpliedCurrencyAndAmount,
9556    #[serde(rename = "CdtDbt", skip_serializing_if = "Option::is_none")]
9557    pub cdt_dbt: Option<CreditDebit3Code>,
9558    #[serde(rename = "Rsn", skip_serializing_if = "Option::is_none")]
9559    pub rsn: Option<Max35Text>,
9560}
9561#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
9562pub enum AttributeType1Code {
9563    #[serde(rename = "CNAT")]
9564    Cnat,
9565    #[serde(rename = "LATT")]
9566    Latt,
9567    #[serde(rename = "OATT")]
9568    Oatt,
9569    #[serde(rename = "OUAT")]
9570    Ouat,
9571    #[serde(rename = "CATT")]
9572    Catt,
9573    #[default]
9574    Unknown,
9575}
9576#[derive(
9577    Debug,
9578    Default,
9579    Clone,
9580    PartialEq,
9581    ::serde::Serialize,
9582    ::serde::Deserialize,
9583    ::derive_builder::Builder,
9584    ::validator::Validate,
9585)]
9586pub struct VehicleRentalAgreement2 {
9587    #[serde(rename = "AgrmtNb", skip_serializing_if = "Option::is_none")]
9588    pub agrmt_nb: Option<Max35Text>,
9589    #[serde(rename = "AdjstdInd", skip_serializing_if = "Option::is_none")]
9590    pub adjstd_ind: Option<TrueFalseIndicator>,
9591    #[serde(rename = "RntlLctn", skip_serializing_if = "Option::is_none")]
9592    pub rntl_lctn: Option<Address2>,
9593    #[validate(length(min = 0,))]
9594    #[serde(rename = "PckpLctn", default)]
9595    pub pckp_lctn: Vec<Address2>,
9596    #[serde(rename = "ChckOutDt", skip_serializing_if = "Option::is_none")]
9597    pub chck_out_dt: Option<IsoDate>,
9598    #[serde(rename = "ChckOutTm", skip_serializing_if = "Option::is_none")]
9599    pub chck_out_tm: Option<IsoTime>,
9600    #[serde(rename = "RtrLctn", skip_serializing_if = "Option::is_none")]
9601    pub rtr_lctn: Option<Address2>,
9602    #[serde(rename = "ChckInDt", skip_serializing_if = "Option::is_none")]
9603    pub chck_in_dt: Option<IsoDate>,
9604    #[serde(rename = "ChckInTm", skip_serializing_if = "Option::is_none")]
9605    pub chck_in_tm: Option<IsoTime>,
9606    #[serde(rename = "Drtn", skip_serializing_if = "Option::is_none")]
9607    pub drtn: Option<Max4NumericText>,
9608    #[serde(rename = "VhclClssDtls", skip_serializing_if = "Option::is_none")]
9609    pub vhcl_clss_dtls: Option<Vehicle4>,
9610    #[serde(rename = "TrvlDstnc", skip_serializing_if = "Option::is_none")]
9611    pub trvl_dstnc: Option<Distance1>,
9612    #[validate(length(min = 0,))]
9613    #[serde(rename = "RntlRate", default)]
9614    pub rntl_rate: Vec<RentalRate1>,
9615    #[serde(rename = "RntlDtls", skip_serializing_if = "Option::is_none")]
9616    pub rntl_dtls: Option<RentalDetails2>,
9617    #[serde(rename = "VhclRegnNb", skip_serializing_if = "Option::is_none")]
9618    pub vhcl_regn_nb: Option<Max70Text>,
9619    #[serde(rename = "InsrncInd", skip_serializing_if = "Option::is_none")]
9620    pub insrnc_ind: Option<TrueFalseIndicator>,
9621    #[validate(length(min = 0,))]
9622    #[serde(rename = "AddtlAmt", default)]
9623    pub addtl_amt: Vec<Amount18>,
9624    #[validate(length(min = 0,))]
9625    #[serde(rename = "EstmtdTax", default)]
9626    pub estmtd_tax: Vec<Tax39>,
9627    #[validate(length(min = 0,))]
9628    #[serde(rename = "DscntPrgrmm", default)]
9629    pub dscnt_prgrmm: Vec<Discount3>,
9630    #[validate(length(min = 0,))]
9631    #[serde(rename = "LltyPrgrmm", default)]
9632    pub llty_prgrmm: Vec<LoyaltyProgramme3>,
9633}
9634#[derive(
9635    Debug,
9636    Default,
9637    Clone,
9638    PartialEq,
9639    ::serde::Serialize,
9640    ::serde::Deserialize,
9641    ::derive_builder::Builder,
9642    ::validator::Validate,
9643)]
9644pub struct SupplementaryData1<
9645    A: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
9646> {
9647    #[serde(rename = "PlcAndNm", skip_serializing_if = "Option::is_none")]
9648    pub plc_and_nm: Option<Max350Text>,
9649    #[validate]
9650    #[serde(rename = "Envlp")]
9651    pub envlp: SupplementaryDataEnvelope1<A>,
9652}
9653#[derive(
9654    Debug,
9655    Default,
9656    Clone,
9657    PartialEq,
9658    ::serde::Serialize,
9659    ::serde::Deserialize,
9660    ::derive_builder::Builder,
9661    ::validator::Validate,
9662)]
9663pub struct IsoCountrySubDivisionCode {
9664    #[validate(regex = "ISO_COUNTRY_SUB_DIVISION_CODE_REGEX")]
9665    #[serde(rename = "$text")]
9666    pub value: String,
9667}
9668#[derive(
9669    Debug,
9670    Default,
9671    Clone,
9672    PartialEq,
9673    ::serde::Serialize,
9674    ::serde::Deserialize,
9675    ::derive_builder::Builder,
9676    ::validator::Validate,
9677)]
9678pub struct Max500Text {
9679    #[validate(length(min = 1, max = 500,))]
9680    #[serde(rename = "$text")]
9681    pub value: String,
9682}
9683#[derive(
9684    Debug,
9685    Default,
9686    Clone,
9687    PartialEq,
9688    ::serde::Serialize,
9689    ::serde::Deserialize,
9690    ::derive_builder::Builder,
9691    ::validator::Validate,
9692)]
9693pub struct AncillaryPurchase2 {
9694    #[serde(rename = "AncllryDocNb", skip_serializing_if = "Option::is_none")]
9695    pub ancllry_doc_nb: Option<Max15Text>,
9696    #[serde(rename = "RltdDocNb", skip_serializing_if = "Option::is_none")]
9697    pub rltd_doc_nb: Option<Max15Text>,
9698    #[serde(rename = "SvcCtgyCd", skip_serializing_if = "Option::is_none")]
9699    pub svc_ctgy_cd: Option<Max4Text>,
9700    #[serde(rename = "SvcSubCtgyCd", skip_serializing_if = "Option::is_none")]
9701    pub svc_sub_ctgy_cd: Option<Max4Text>,
9702    #[serde(rename = "SvcPrvdrSvcTp", skip_serializing_if = "Option::is_none")]
9703    pub svc_prvdr_svc_tp: Option<Max35Text>,
9704    #[serde(rename = "CdtRsnCd", skip_serializing_if = "Option::is_none")]
9705    pub cdt_rsn_cd: Option<Max35Text>,
9706    #[serde(rename = "SummryCmmdtyId", skip_serializing_if = "Option::is_none")]
9707    pub summry_cmmdty_id: Option<Max35Text>,
9708    #[serde(rename = "Amt", skip_serializing_if = "Option::is_none")]
9709    pub amt: Option<Amount16>,
9710    #[serde(rename = "Fee", skip_serializing_if = "Option::is_none")]
9711    pub fee: Option<ImpliedCurrencyAndAmount>,
9712    #[validate(length(min = 0,))]
9713    #[serde(rename = "Tax", default)]
9714    pub tax: Vec<Tax39>,
9715    #[serde(rename = "AddtlData", skip_serializing_if = "Option::is_none")]
9716    pub addtl_data: Option<Max350Text>,
9717}
9718#[derive(
9719    Debug,
9720    Default,
9721    Clone,
9722    PartialEq,
9723    ::serde::Serialize,
9724    ::serde::Deserialize,
9725    ::derive_builder::Builder,
9726    ::validator::Validate,
9727)]
9728pub struct IsoTime {
9729    #[serde(rename = "$value")]
9730    pub value: ::chrono::naive::NaiveTime,
9731}
9732#[derive(
9733    Debug,
9734    Default,
9735    Clone,
9736    PartialEq,
9737    ::serde::Serialize,
9738    ::serde::Deserialize,
9739    ::derive_builder::Builder,
9740    ::validator::Validate,
9741)]
9742pub struct SpecialConditions1 {
9743    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
9744    pub id: Option<Max35Text>,
9745    #[serde(rename = "Val", skip_serializing_if = "Option::is_none")]
9746    pub val: Option<Max35Text>,
9747}
9748#[derive(
9749    Debug,
9750    Default,
9751    Clone,
9752    PartialEq,
9753    ::serde::Serialize,
9754    ::serde::Deserialize,
9755    ::derive_builder::Builder,
9756    ::validator::Validate,
9757)]
9758pub struct AdditionalFee2 {
9759    #[serde(rename = "Tp")]
9760    pub tp: TypeOfAmount21Code,
9761    #[serde(rename = "OthrTp", skip_serializing_if = "Option::is_none")]
9762    pub othr_tp: Option<Max35Text>,
9763    #[serde(rename = "FeePrgm", skip_serializing_if = "Option::is_none")]
9764    pub fee_prgm: Option<Max35Text>,
9765    #[serde(rename = "FeeDscrptr", skip_serializing_if = "Option::is_none")]
9766    pub fee_dscrptr: Option<Max35Text>,
9767    #[validate]
9768    #[serde(rename = "FeeAmt")]
9769    pub fee_amt: FeeAmount3,
9770    #[serde(rename = "FeeRcncltnAmt", skip_serializing_if = "Option::is_none")]
9771    pub fee_rcncltn_amt: Option<FeeAmount3>,
9772    #[serde(rename = "Desc", skip_serializing_if = "Option::is_none")]
9773    pub desc: Option<Max140Text>,
9774    #[validate(length(min = 0,))]
9775    #[serde(rename = "AddtlData", default)]
9776    pub addtl_data: Vec<AdditionalData1>,
9777}
9778#[derive(
9779    Debug,
9780    Default,
9781    Clone,
9782    PartialEq,
9783    ::serde::Serialize,
9784    ::serde::Deserialize,
9785    ::derive_builder::Builder,
9786    ::validator::Validate,
9787)]
9788pub struct FleetData4 {
9789    #[serde(rename = "Summry", skip_serializing_if = "Option::is_none")]
9790    pub summry: Option<FleetSummary2>,
9791    #[validate(length(min = 0,))]
9792    #[serde(rename = "LineItm", default)]
9793    pub line_itm: Vec<FleetLineItem4>,
9794}
9795#[derive(
9796    Debug,
9797    Default,
9798    Clone,
9799    PartialEq,
9800    ::serde::Serialize,
9801    ::serde::Deserialize,
9802    ::derive_builder::Builder,
9803    ::validator::Validate,
9804)]
9805pub struct Max104Text {
9806    #[validate(length(min = 1, max = 104,))]
9807    #[serde(rename = "$text")]
9808    pub value: String,
9809}
9810#[derive(
9811    Debug,
9812    Default,
9813    Clone,
9814    PartialEq,
9815    ::serde::Serialize,
9816    ::serde::Deserialize,
9817    ::derive_builder::Builder,
9818    ::validator::Validate,
9819)]
9820pub struct Max3NumericText {
9821    #[validate(regex = "MAX_3_NUMERIC_TEXT_REGEX")]
9822    #[serde(rename = "$text")]
9823    pub value: String,
9824}
9825#[derive(
9826    Debug,
9827    Default,
9828    Clone,
9829    PartialEq,
9830    ::serde::Serialize,
9831    ::serde::Deserialize,
9832    ::derive_builder::Builder,
9833    ::validator::Validate,
9834)]
9835pub struct Max50Text {
9836    #[validate(length(min = 1, max = 50,))]
9837    #[serde(rename = "$text")]
9838    pub value: String,
9839}
9840#[derive(
9841    Debug,
9842    Default,
9843    Clone,
9844    PartialEq,
9845    ::serde::Serialize,
9846    ::serde::Deserialize,
9847    ::derive_builder::Builder,
9848    ::validator::Validate,
9849)]
9850pub struct Parameter10 {
9851    #[serde(rename = "NcrptnFrmt", skip_serializing_if = "Option::is_none")]
9852    pub ncrptn_frmt: Option<EncryptionFormat2Code>,
9853    #[serde(rename = "DgstAlgo", skip_serializing_if = "Option::is_none")]
9854    pub dgst_algo: Option<Algorithm16Code>,
9855    #[serde(rename = "MskGnrtrAlgo", skip_serializing_if = "Option::is_none")]
9856    pub msk_gnrtr_algo: Option<AlgorithmIdentification18>,
9857}
9858#[derive(
9859    Debug,
9860    Default,
9861    Clone,
9862    PartialEq,
9863    ::serde::Serialize,
9864    ::serde::Deserialize,
9865    ::derive_builder::Builder,
9866    ::validator::Validate,
9867)]
9868pub struct PointOfServiceContext3 {
9869    #[serde(rename = "CardPres", skip_serializing_if = "Option::is_none")]
9870    pub card_pres: Option<TrueFalseIndicator>,
9871    #[serde(rename = "CrdhldrPres", skip_serializing_if = "Option::is_none")]
9872    pub crdhldr_pres: Option<TrueFalseIndicator>,
9873    #[serde(rename = "CrdhldrActvtd", skip_serializing_if = "Option::is_none")]
9874    pub crdhldr_actvtd: Option<TrueFalseIndicator>,
9875    #[serde(rename = "TrnspndrInittd", skip_serializing_if = "Option::is_none")]
9876    pub trnspndr_inittd: Option<TrueFalseIndicator>,
9877    #[serde(rename = "AttnddInd", skip_serializing_if = "Option::is_none")]
9878    pub attndd_ind: Option<TrueFalseIndicator>,
9879    #[serde(rename = "UattnddLvlCtgy", skip_serializing_if = "Option::is_none")]
9880    pub uattndd_lvl_ctgy: Option<Max35NumericText>,
9881    #[serde(rename = "EComrcInd", skip_serializing_if = "Option::is_none")]
9882    pub e_comrc_ind: Option<TrueFalseIndicator>,
9883    #[validate(length(min = 0,))]
9884    #[serde(rename = "EComrcData", default)]
9885    pub e_comrc_data: Vec<ECommerceData1>,
9886    #[serde(rename = "MOTOCd", skip_serializing_if = "Option::is_none")]
9887    pub moto_cd: Option<Moto1Code>,
9888    #[serde(rename = "TrnstInd", skip_serializing_if = "Option::is_none")]
9889    pub trnst_ind: Option<TrueFalseIndicator>,
9890    #[serde(rename = "PrtlApprvlSpprtd", skip_serializing_if = "Option::is_none")]
9891    pub prtl_apprvl_spprtd: Option<TrueFalseIndicator>,
9892    #[serde(rename = "DelydAuthstnInd", skip_serializing_if = "Option::is_none")]
9893    pub delyd_authstn_ind: Option<TrueFalseIndicator>,
9894    #[validate(length(min = 0,))]
9895    #[serde(rename = "SctyChrtcs", default)]
9896    pub scty_chrtcs: Vec<SecurityCharacteristics1Code>,
9897    #[serde(rename = "OthrSctyChrtcs", skip_serializing_if = "Option::is_none")]
9898    pub othr_scty_chrtcs: Option<Max35Text>,
9899    #[serde(rename = "CardDataNtryMd")]
9900    pub card_data_ntry_md: CardDataReading10Code,
9901    #[serde(rename = "OthrCardDataNtryMd", skip_serializing_if = "Option::is_none")]
9902    pub othr_card_data_ntry_md: Option<Max35Text>,
9903    #[serde(rename = "QRCdPresntmntMd", skip_serializing_if = "Option::is_none")]
9904    pub qr_cd_presntmnt_md: Option<QrCodePresentmentMode1Code>,
9905    #[serde(
9906        rename = "OthrQRCdPresntmntMd",
9907        skip_serializing_if = "Option::is_none"
9908    )]
9909    pub othr_qr_cd_presntmnt_md: Option<Max35Text>,
9910    #[serde(
9911        rename = "TempScrCardDataReusd",
9912        skip_serializing_if = "Option::is_none"
9913    )]
9914    pub temp_scr_card_data_reusd: Option<TrueFalseIndicator>,
9915    #[serde(rename = "StorgLctn", skip_serializing_if = "Option::is_none")]
9916    pub storg_lctn: Option<Max35Text>,
9917    #[validate(length(min = 0,))]
9918    #[serde(rename = "SpclConds", default)]
9919    pub spcl_conds: Vec<SpecialConditions1>,
9920    #[validate(length(min = 0,))]
9921    #[serde(rename = "AddtlData", default)]
9922    pub addtl_data: Vec<AdditionalData1>,
9923}
9924#[derive(
9925    Debug,
9926    Default,
9927    Clone,
9928    PartialEq,
9929    ::serde::Serialize,
9930    ::serde::Deserialize,
9931    ::derive_builder::Builder,
9932    ::validator::Validate,
9933)]
9934pub struct Max8HexBinaryText {
9935    #[validate(regex = "MAX_8_HEX_BINARY_TEXT_REGEX")]
9936    #[serde(rename = "$text")]
9937    pub value: String,
9938}
9939#[derive(
9940    Debug,
9941    Default,
9942    Clone,
9943    PartialEq,
9944    ::serde::Serialize,
9945    ::serde::Deserialize,
9946    ::derive_builder::Builder,
9947    ::validator::Validate,
9948)]
9949pub struct AdditionalAction1 {
9950    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
9951    pub tp: Option<ActionType10Code>,
9952    #[serde(rename = "Dstn", skip_serializing_if = "Option::is_none")]
9953    pub dstn: Option<PartyType21Code>,
9954    #[serde(rename = "OthrDstn", skip_serializing_if = "Option::is_none")]
9955    pub othr_dstn: Option<Max35Text>,
9956    #[serde(rename = "DstnTp", skip_serializing_if = "Option::is_none")]
9957    pub dstn_tp: Option<ActionDestination1Code>,
9958    #[serde(rename = "OthrDstnTp", skip_serializing_if = "Option::is_none")]
9959    pub othr_dstn_tp: Option<Max35Text>,
9960    #[serde(rename = "DstnAdr", skip_serializing_if = "Option::is_none")]
9961    pub dstn_adr: Option<Max70Text>,
9962    #[serde(rename = "Frmt", skip_serializing_if = "Option::is_none")]
9963    pub frmt: Option<OutputFormat4Code>,
9964    #[serde(rename = "OthrFrmt", skip_serializing_if = "Option::is_none")]
9965    pub othr_frmt: Option<Max35Text>,
9966    #[serde(rename = "Cntt", skip_serializing_if = "Option::is_none")]
9967    pub cntt: Option<Content1>,
9968}
9969#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
9970pub enum Endpoint1Code {
9971    #[serde(rename = "DEST")]
9972    Dest,
9973    #[serde(rename = "ORIG")]
9974    Orig,
9975    #[serde(rename = "OTHP")]
9976    Othp,
9977    #[serde(rename = "OTHN")]
9978    Othn,
9979    #[default]
9980    Unknown,
9981}
9982#[derive(
9983    Debug,
9984    Default,
9985    Clone,
9986    PartialEq,
9987    ::serde::Serialize,
9988    ::serde::Deserialize,
9989    ::derive_builder::Builder,
9990    ::validator::Validate,
9991)]
9992pub struct FundingService2 {
9993    #[serde(rename = "FndgSvc", skip_serializing_if = "Option::is_none")]
9994    pub fndg_svc: Option<TransferService2>,
9995    #[validate(length(min = 0,))]
9996    #[serde(rename = "FndgSrc", default)]
9997    pub fndg_src: Vec<FundingSource2>,
9998    #[serde(rename = "ClmInf", skip_serializing_if = "Option::is_none")]
9999    pub clm_inf: Option<ClaimInformation1>,
10000}
10001#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
10002pub enum CardDataReading10Code {
10003    #[serde(rename = "ICPY")]
10004    Icpy,
10005    #[serde(rename = "MGST")]
10006    Mgst,
10007    #[serde(rename = "ICCY")]
10008    Iccy,
10009    #[serde(rename = "MICR")]
10010    Micr,
10011    #[serde(rename = "MLEY")]
10012    Mley,
10013    #[serde(rename = "OCRR")]
10014    Ocrr,
10015    #[serde(rename = "MSIP")]
10016    Msip,
10017    #[serde(rename = "OPTC")]
10018    Optc,
10019    #[serde(rename = "OTHN")]
10020    Othn,
10021    #[serde(rename = "RFID")]
10022    Rfid,
10023    #[serde(rename = "UNSP")]
10024    Unsp,
10025    #[serde(rename = "OTHP")]
10026    Othp,
10027    #[serde(rename = "KEEN")]
10028    Keen,
10029    #[serde(rename = "DFLE")]
10030    Dfle,
10031    #[default]
10032    Unknown,
10033}
10034#[derive(
10035    Debug,
10036    Default,
10037    Clone,
10038    PartialEq,
10039    ::serde::Serialize,
10040    ::serde::Deserialize,
10041    ::derive_builder::Builder,
10042    ::validator::Validate,
10043)]
10044pub struct EncryptedContent4 {
10045    #[serde(rename = "CnttTp")]
10046    pub cntt_tp: ContentType2Code,
10047    #[serde(rename = "CnttNcrptnAlgo", skip_serializing_if = "Option::is_none")]
10048    pub cntt_ncrptn_algo: Option<AlgorithmIdentification24>,
10049    #[validate]
10050    #[serde(rename = "NcrptdData")]
10051    pub ncrptd_data: Max100KBinary,
10052}
10053#[derive(
10054    Debug,
10055    Default,
10056    Clone,
10057    PartialEq,
10058    ::serde::Serialize,
10059    ::serde::Deserialize,
10060    ::derive_builder::Builder,
10061    ::validator::Validate,
10062)]
10063pub struct Amount17 {
10064    #[validate]
10065    #[serde(rename = "Amt")]
10066    pub amt: ImpliedCurrencyAndAmount,
10067    #[serde(rename = "Ccy", skip_serializing_if = "Option::is_none")]
10068    pub ccy: Option<Iso3NumericCurrencyCode>,
10069    #[serde(rename = "CdtDbt", skip_serializing_if = "Option::is_none")]
10070    pub cdt_dbt: Option<CreditDebit3Code>,
10071}
10072#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
10073pub enum PartyType17Code {
10074    #[serde(rename = "OTHN")]
10075    Othn,
10076    #[serde(rename = "OTHP")]
10077    Othp,
10078    #[serde(rename = "ACQR")]
10079    Acqr,
10080    #[serde(rename = "ACQP")]
10081    Acqp,
10082    #[serde(rename = "CISS")]
10083    Ciss,
10084    #[serde(rename = "CISP")]
10085    Cisp,
10086    #[serde(rename = "AGNT")]
10087    Agnt,
10088    #[default]
10089    Unknown,
10090}
10091#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
10092pub enum AdministrativeType1Code {
10093    #[serde(rename = "OTHN")]
10094    Othn,
10095    #[serde(rename = "OTHP")]
10096    Othp,
10097    #[serde(rename = "TEXT")]
10098    Text,
10099    #[default]
10100    Unknown,
10101}
10102#[derive(
10103    Debug,
10104    Default,
10105    Clone,
10106    PartialEq,
10107    ::serde::Serialize,
10108    ::serde::Deserialize,
10109    ::derive_builder::Builder,
10110    ::validator::Validate,
10111)]
10112pub struct PointOfInteractionComponentIdentification3 {
10113    #[serde(rename = "ItmNb", skip_serializing_if = "Option::is_none")]
10114    pub itm_nb: Option<Max35Text>,
10115    #[serde(rename = "PrvdrId", skip_serializing_if = "Option::is_none")]
10116    pub prvdr_id: Option<Max35Text>,
10117    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
10118    pub id: Option<Max35Text>,
10119    #[serde(rename = "SrlNb", skip_serializing_if = "Option::is_none")]
10120    pub srl_nb: Option<Max70Text>,
10121}
10122#[derive(
10123    Debug,
10124    Default,
10125    Clone,
10126    PartialEq,
10127    ::serde::Serialize,
10128    ::serde::Deserialize,
10129    ::derive_builder::Builder,
10130    ::validator::Validate,
10131)]
10132pub struct Context18 {
10133    #[serde(rename = "PtOfSvcCntxt", skip_serializing_if = "Option::is_none")]
10134    pub pt_of_svc_cntxt: Option<PointOfServiceContext3>,
10135    #[serde(rename = "TxCntxt", skip_serializing_if = "Option::is_none")]
10136    pub tx_cntxt: Option<TransactionContext7>,
10137    #[validate(length(min = 0,))]
10138    #[serde(rename = "Vrfctn", default)]
10139    pub vrfctn: Vec<Verification5>,
10140    #[validate(length(min = 0,))]
10141    #[serde(rename = "RskCntxt", default)]
10142    pub rsk_cntxt: Vec<RiskContext2>,
10143    #[serde(rename = "SaleCntxt", skip_serializing_if = "Option::is_none")]
10144    pub sale_cntxt: Option<SaleContext8>,
10145    #[validate(length(min = 0,))]
10146    #[serde(rename = "AddtlData", default)]
10147    pub addtl_data: Vec<AdditionalData2>,
10148}
10149#[derive(
10150    Debug,
10151    Default,
10152    Clone,
10153    PartialEq,
10154    ::serde::Serialize,
10155    ::serde::Deserialize,
10156    ::derive_builder::Builder,
10157    ::validator::Validate,
10158)]
10159pub struct InterestRateDetails2 {
10160    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
10161    pub tp: Option<InterestRate1Code>,
10162    #[serde(rename = "OthrTp", skip_serializing_if = "Option::is_none")]
10163    pub othr_tp: Option<Max35Text>,
10164    #[serde(rename = "Prd", skip_serializing_if = "Option::is_none")]
10165    pub prd: Option<InstalmentPeriod1Code>,
10166    #[validate]
10167    #[serde(rename = "Rate")]
10168    pub rate: BaseOneRate,
10169}
10170#[derive(
10171    Debug,
10172    Default,
10173    Clone,
10174    PartialEq,
10175    ::serde::Serialize,
10176    ::serde::Deserialize,
10177    ::derive_builder::Builder,
10178    ::validator::Validate,
10179)]
10180pub struct VehicleRentalCustomer2 {
10181    #[validate]
10182    #[serde(rename = "RntrNm")]
10183    pub rntr_nm: Max70Text,
10184    #[serde(rename = "CorpNm", skip_serializing_if = "Option::is_none")]
10185    pub corp_nm: Option<Max70Text>,
10186    #[validate]
10187    #[serde(rename = "CorpIdr")]
10188    pub corp_idr: Max35Text,
10189    #[serde(rename = "Assgnr", skip_serializing_if = "Option::is_none")]
10190    pub assgnr: Option<CustomerAssigner1Code>,
10191    #[validate(length(min = 0,))]
10192    #[serde(rename = "PmryDrvr", default)]
10193    pub pmry_drvr: Vec<DriverInParty2>,
10194    #[validate(length(min = 0,))]
10195    #[serde(rename = "AddtlDrvr", default)]
10196    pub addtl_drvr: Vec<DriverInParty2>,
10197    #[serde(rename = "LltyPrgrmm", skip_serializing_if = "Option::is_none")]
10198    pub llty_prgrmm: Option<LoyaltyProgramme2>,
10199}
10200#[derive(
10201    Debug,
10202    Default,
10203    Clone,
10204    PartialEq,
10205    ::serde::Serialize,
10206    ::serde::Deserialize,
10207    ::derive_builder::Builder,
10208    ::validator::Validate,
10209)]
10210pub struct AdministrativeResponse1<
10211    A: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
10212> {
10213    #[validate]
10214    #[serde(rename = "Envt")]
10215    pub envt: Environment34,
10216    #[serde(rename = "Cntxt", skip_serializing_if = "Option::is_none")]
10217    pub cntxt: Option<Context18>,
10218    #[validate]
10219    #[serde(rename = "Tx")]
10220    pub tx: Transaction144,
10221    #[validate(length(min = 0,))]
10222    #[serde(rename = "OrgnlTx", default)]
10223    pub orgnl_tx: Vec<OriginalTransaction2>,
10224    #[serde(rename = "AdddmData", skip_serializing_if = "Option::is_none")]
10225    pub adddm_data: Option<AddendumData3>,
10226    #[validate(length(min = 0,))]
10227    #[serde(rename = "AddtlData", default)]
10228    pub addtl_data: Vec<AdditionalData2>,
10229    #[validate]
10230    #[serde(rename = "PrcgRslt")]
10231    pub prcg_rslt: ProcessingResult17,
10232    #[serde(rename = "ICCRltdData", skip_serializing_if = "Option::is_none")]
10233    pub icc_rltd_data: Option<Max10KHexBinaryText>,
10234    #[validate(length(min = 0,))]
10235    #[serde(rename = "PrtctdData", default)]
10236    pub prtctd_data: Vec<ProtectedData1>,
10237    #[validate(length(min = 0,))]
10238    #[serde(rename = "SplmtryData", default)]
10239    pub splmtry_data: Vec<SupplementaryData1<A>>,
10240}
10241#[derive(
10242    Debug,
10243    Default,
10244    Clone,
10245    PartialEq,
10246    ::serde::Serialize,
10247    ::serde::Deserialize,
10248    ::derive_builder::Builder,
10249    ::validator::Validate,
10250)]
10251pub struct Authority1 {
10252    #[serde(rename = "Ctry", skip_serializing_if = "Option::is_none")]
10253    pub ctry: Option<Iso3NumericCountryCode>,
10254    #[serde(rename = "CtrySubDvsnMjr", skip_serializing_if = "Option::is_none")]
10255    pub ctry_sub_dvsn_mjr: Option<IsoCountrySubDivisionCode>,
10256    #[serde(rename = "CtrySubDvsnMnr", skip_serializing_if = "Option::is_none")]
10257    pub ctry_sub_dvsn_mnr: Option<IsoCountrySubDivisionCode>,
10258    #[serde(rename = "CtrySubDvsnMjrNm", skip_serializing_if = "Option::is_none")]
10259    pub ctry_sub_dvsn_mjr_nm: Option<Max50Text>,
10260    #[serde(rename = "CtrySubDvsnMnrNm", skip_serializing_if = "Option::is_none")]
10261    pub ctry_sub_dvsn_mnr_nm: Option<Max50Text>,
10262    #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
10263    pub nm: Option<Max50Text>,
10264}
10265#[derive(
10266    Debug,
10267    Default,
10268    Clone,
10269    PartialEq,
10270    ::serde::Serialize,
10271    ::serde::Deserialize,
10272    ::derive_builder::Builder,
10273    ::validator::Validate,
10274)]
10275pub struct FleetSummary2 {
10276    #[serde(rename = "Drvr", skip_serializing_if = "Option::is_none")]
10277    pub drvr: Option<Driver2>,
10278    #[serde(rename = "Vhcl", skip_serializing_if = "Option::is_none")]
10279    pub vhcl: Option<Vehicle5>,
10280    #[serde(rename = "DrvrOrVhclCard", skip_serializing_if = "Option::is_none")]
10281    pub drvr_or_vhcl_card: Option<PlainCardData21>,
10282    #[serde(rename = "CardFuelPrmptCd", skip_serializing_if = "Option::is_none")]
10283    pub card_fuel_prmpt_cd: Option<Max1Number>,
10284    #[serde(rename = "AgtFuelPrmptCd", skip_serializing_if = "Option::is_none")]
10285    pub agt_fuel_prmpt_cd: Option<Max35Text>,
10286    #[serde(rename = "TripInf", skip_serializing_if = "Option::is_none")]
10287    pub trip_inf: Option<TripInformation1>,
10288    #[validate(length(min = 0,))]
10289    #[serde(rename = "LclAmnty", default)]
10290    pub lcl_amnty: Vec<LocalAmenity1>,
10291    #[validate(length(min = 0,))]
10292    #[serde(rename = "TxRltdData", default)]
10293    pub tx_rltd_data: Vec<PaymentTransaction141>,
10294    #[serde(rename = "AddtlData", skip_serializing_if = "Option::is_none")]
10295    pub addtl_data: Option<AdditionalInformation19>,
10296}
10297#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
10298pub enum Algorithm17Code {
10299    #[serde(rename = "MACC")]
10300    Macc,
10301    #[serde(rename = "MCCS")]
10302    Mccs,
10303    #[serde(rename = "CMA1")]
10304    Cma1,
10305    #[serde(rename = "MCC1")]
10306    Mcc1,
10307    #[serde(rename = "CMA9")]
10308    Cma9,
10309    #[serde(rename = "CMA5")]
10310    Cma5,
10311    #[serde(rename = "CMA2")]
10312    Cma2,
10313    #[serde(rename = "CM31")]
10314    Cm31,
10315    #[serde(rename = "CM32")]
10316    Cm32,
10317    #[serde(rename = "CM33")]
10318    Cm33,
10319    #[serde(rename = "MCS3")]
10320    Mcs3,
10321    #[serde(rename = "CCA1")]
10322    Cca1,
10323    #[serde(rename = "CCA2")]
10324    Cca2,
10325    #[serde(rename = "CCA3")]
10326    Cca3,
10327    #[default]
10328    Unknown,
10329}
10330#[derive(
10331    Debug,
10332    Default,
10333    Clone,
10334    PartialEq,
10335    ::serde::Serialize,
10336    ::serde::Deserialize,
10337    ::derive_builder::Builder,
10338    ::validator::Validate,
10339)]
10340pub struct SpecialProgrammeDetails1 {
10341    #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
10342    pub nm: Option<Max35Text>,
10343    #[serde(rename = "Val", skip_serializing_if = "Option::is_none")]
10344    pub val: Option<Max35Text>,
10345}
10346#[derive(
10347    Debug,
10348    Default,
10349    Clone,
10350    PartialEq,
10351    ::serde::Serialize,
10352    ::serde::Deserialize,
10353    ::derive_builder::Builder,
10354    ::validator::Validate,
10355)]
10356pub struct Max140Text {
10357    #[validate(length(min = 1, max = 140,))]
10358    #[serde(rename = "$text")]
10359    pub value: String,
10360}
10361#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
10362pub enum CardDataReading9Code {
10363    #[serde(rename = "UNKW")]
10364    Unkw,
10365    #[serde(rename = "OTHN")]
10366    Othn,
10367    #[serde(rename = "OTHP")]
10368    Othp,
10369    #[serde(rename = "CAMR")]
10370    Camr,
10371    #[serde(rename = "KEEN")]
10372    Keen,
10373    #[serde(rename = "ICPY")]
10374    Icpy,
10375    #[serde(rename = "OPTC")]
10376    Optc,
10377    #[serde(rename = "CDFL")]
10378    Cdfl,
10379    #[serde(rename = "MBNK")]
10380    Mbnk,
10381    #[serde(rename = "TOKN")]
10382    Tokn,
10383    #[serde(rename = "ICCY")]
10384    Iccy,
10385    #[default]
10386    Unknown,
10387}
10388#[derive(
10389    Debug,
10390    Default,
10391    Clone,
10392    PartialEq,
10393    ::serde::Serialize,
10394    ::serde::Deserialize,
10395    ::derive_builder::Builder,
10396    ::validator::Validate,
10397)]
10398pub struct CardReadingCapabilities1 {
10399    #[serde(rename = "Cpblty")]
10400    pub cpblty: CardDataReading10Code,
10401    #[serde(rename = "OthrCpblty", skip_serializing_if = "Option::is_none")]
10402    pub othr_cpblty: Option<Max35Text>,
10403}
10404#[derive(
10405    Debug,
10406    Default,
10407    Clone,
10408    PartialEq,
10409    ::serde::Serialize,
10410    ::serde::Deserialize,
10411    ::derive_builder::Builder,
10412    ::validator::Validate,
10413)]
10414pub struct Max4Text {
10415    #[validate(length(min = 1, max = 4,))]
10416    #[serde(rename = "$text")]
10417    pub value: String,
10418}
10419#[derive(
10420    Debug,
10421    Default,
10422    Clone,
10423    PartialEq,
10424    ::serde::Serialize,
10425    ::serde::Deserialize,
10426    ::derive_builder::Builder,
10427    ::validator::Validate,
10428)]
10429pub struct DisputeData3 {
10430    #[serde(rename = "PresntmntCycl", skip_serializing_if = "Option::is_none")]
10431    pub presntmnt_cycl: Option<Exact1NumericText>,
10432    #[serde(rename = "DsptCond", skip_serializing_if = "Option::is_none")]
10433    pub dspt_cond: Option<Max35Text>,
10434    #[serde(rename = "DsptSts", skip_serializing_if = "Option::is_none")]
10435    pub dspt_sts: Option<Max35Text>,
10436    #[serde(rename = "PrtlDspt", skip_serializing_if = "Option::is_none")]
10437    pub prtl_dspt: Option<YesNoIndicator>,
10438    #[validate(length(min = 0,))]
10439    #[serde(rename = "DsptRef", default)]
10440    pub dspt_ref: Vec<DisputeReference1>,
10441    #[serde(rename = "DcmnttnSts", skip_serializing_if = "Option::is_none")]
10442    pub dcmnttn_sts: Option<Max35Text>,
10443    #[serde(rename = "AddtlDsptData", skip_serializing_if = "Option::is_none")]
10444    pub addtl_dspt_data: Option<AdditionalData1>,
10445    #[validate(length(min = 0,))]
10446    #[serde(rename = "DsptRjctRsn", default)]
10447    pub dspt_rjct_rsn: Vec<Max35Text>,
10448    #[serde(rename = "ChrgbckElgblty", skip_serializing_if = "Option::is_none")]
10449    pub chrgbck_elgblty: Option<Max35Text>,
10450}
10451#[derive(
10452    Debug,
10453    Default,
10454    Clone,
10455    PartialEq,
10456    ::serde::Serialize,
10457    ::serde::Deserialize,
10458    ::derive_builder::Builder,
10459    ::validator::Validate,
10460)]
10461pub struct LocalData7 {
10462    #[serde(rename = "Lang")]
10463    pub lang: IsoMax3ALanguageCode,
10464    #[serde(rename = "CrdhldrNm", skip_serializing_if = "Option::is_none")]
10465    pub crdhldr_nm: Option<CardholderName2>,
10466    #[serde(rename = "Adr", skip_serializing_if = "Option::is_none")]
10467    pub adr: Option<Address3>,
10468    #[validate(length(min = 0,))]
10469    #[serde(rename = "AddtlData", default)]
10470    pub addtl_data: Vec<AdditionalData1>,
10471}
10472#[derive(
10473    Debug,
10474    Default,
10475    Clone,
10476    PartialEq,
10477    ::serde::Serialize,
10478    ::serde::Deserialize,
10479    ::derive_builder::Builder,
10480    ::validator::Validate,
10481)]
10482pub struct Max10KText {
10483    #[validate(length(min = 1, max = 10000,))]
10484    #[serde(rename = "$text")]
10485    pub value: String,
10486}
10487#[derive(
10488    Debug,
10489    Default,
10490    Clone,
10491    PartialEq,
10492    ::serde::Serialize,
10493    ::serde::Deserialize,
10494    ::derive_builder::Builder,
10495    ::validator::Validate,
10496)]
10497pub struct Max2NumericText {
10498    #[validate(regex = "MAX_2_NUMERIC_TEXT_REGEX")]
10499    #[serde(rename = "$text")]
10500    pub value: String,
10501}
10502#[derive(
10503    Debug,
10504    Default,
10505    Clone,
10506    PartialEq,
10507    ::serde::Serialize,
10508    ::serde::Deserialize,
10509    ::derive_builder::Builder,
10510    ::validator::Validate,
10511)]
10512pub struct FinancialInstitution7 {
10513    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
10514    pub id: Option<Max35Text>,
10515    #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
10516    pub nm: Option<Max70Text>,
10517    #[serde(rename = "Adr", skip_serializing_if = "Option::is_none")]
10518    pub adr: Option<Address2>,
10519    #[serde(rename = "Email", skip_serializing_if = "Option::is_none")]
10520    pub email: Option<Max256Text>,
10521    #[serde(rename = "URLAdr", skip_serializing_if = "Option::is_none")]
10522    pub url_adr: Option<Max256Text>,
10523    #[serde(rename = "PhneNb", skip_serializing_if = "Option::is_none")]
10524    pub phne_nb: Option<Max35Text>,
10525    #[serde(rename = "CstmrSvc", skip_serializing_if = "Option::is_none")]
10526    pub cstmr_svc: Option<Max35Text>,
10527    #[serde(rename = "AddtlCtctInf", skip_serializing_if = "Option::is_none")]
10528    pub addtl_ctct_inf: Option<Max256Text>,
10529    #[serde(rename = "LclData", skip_serializing_if = "Option::is_none")]
10530    pub lcl_data: Option<LocalData2>,
10531}
10532#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
10533pub enum PoiComponentStatus1Code {
10534    #[serde(rename = "WAIT")]
10535    Wait,
10536    #[serde(rename = "OUTD")]
10537    Outd,
10538    #[serde(rename = "OPER")]
10539    Oper,
10540    #[serde(rename = "DACT")]
10541    Dact,
10542    #[default]
10543    Unknown,
10544}
10545#[derive(
10546    Debug,
10547    Default,
10548    Clone,
10549    PartialEq,
10550    ::serde::Serialize,
10551    ::serde::Deserialize,
10552    ::derive_builder::Builder,
10553    ::validator::Validate,
10554)]
10555pub struct PartyIdentification262 {
10556    #[validate]
10557    #[serde(rename = "Id")]
10558    pub id: Max35Text,
10559    #[serde(rename = "Assgnr", skip_serializing_if = "Option::is_none")]
10560    pub assgnr: Option<Max35Text>,
10561    #[serde(rename = "Ctry", skip_serializing_if = "Option::is_none")]
10562    pub ctry: Option<Iso3NumericCountryCode>,
10563    #[serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none")]
10564    pub shrt_nm: Option<Max35Text>,
10565    #[serde(rename = "AddtlId", skip_serializing_if = "Option::is_none")]
10566    pub addtl_id: Option<Max35Text>,
10567    #[serde(rename = "FrgnMrchnt", skip_serializing_if = "Option::is_none")]
10568    pub frgn_mrchnt: Option<TrueFalseIndicator>,
10569    #[serde(rename = "LclData", skip_serializing_if = "Option::is_none")]
10570    pub lcl_data: Option<LocalData1>,
10571}
10572#[derive(
10573    Debug,
10574    Default,
10575    Clone,
10576    PartialEq,
10577    ::serde::Serialize,
10578    ::serde::Deserialize,
10579    ::derive_builder::Builder,
10580    ::validator::Validate,
10581)]
10582pub struct AlgorithmIdentification12 {
10583    #[serde(rename = "Algo")]
10584    pub algo: Algorithm8Code,
10585    #[serde(rename = "Param", skip_serializing_if = "Option::is_none")]
10586    pub param: Option<Parameter5>,
10587}
10588#[derive(
10589    Debug,
10590    Default,
10591    Clone,
10592    PartialEq,
10593    ::serde::Serialize,
10594    ::serde::Deserialize,
10595    ::derive_builder::Builder,
10596    ::validator::Validate,
10597)]
10598pub struct TelecomServicesSummary2 {
10599    #[serde(rename = "Cstmr", skip_serializing_if = "Option::is_none")]
10600    pub cstmr: Option<Customer6>,
10601    #[serde(rename = "BllgStmtPrdStart", skip_serializing_if = "Option::is_none")]
10602    pub bllg_stmt_prd_start: Option<IsoDate>,
10603    #[serde(rename = "BllgStmtPrdEnd", skip_serializing_if = "Option::is_none")]
10604    pub bllg_stmt_prd_end: Option<IsoDate>,
10605    #[validate(length(min = 0,))]
10606    #[serde(rename = "BllgEvt", default)]
10607    pub bllg_evt: Vec<Amount19>,
10608    #[validate(length(min = 0,))]
10609    #[serde(rename = "TtlTax", default)]
10610    pub ttl_tax: Vec<Tax39>,
10611    #[serde(rename = "AddtlData", skip_serializing_if = "Option::is_none")]
10612    pub addtl_data: Option<Max350Text>,
10613}
10614#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
10615pub enum ExchangeRateType2Code {
10616    #[serde(rename = "SELL")]
10617    Sell,
10618    #[serde(rename = "OTHP")]
10619    Othp,
10620    #[serde(rename = "OTHN")]
10621    Othn,
10622    #[serde(rename = "MIDL")]
10623    Midl,
10624    #[serde(rename = "BUYR")]
10625    Buyr,
10626    #[serde(rename = "AGRD")]
10627    Agrd,
10628    #[default]
10629    Unknown,
10630}
10631#[derive(
10632    Debug,
10633    Default,
10634    Clone,
10635    PartialEq,
10636    ::serde::Serialize,
10637    ::serde::Deserialize,
10638    ::derive_builder::Builder,
10639    ::validator::Validate,
10640)]
10641pub struct ResultData7 {
10642    #[serde(rename = "Rslt", skip_serializing_if = "Option::is_none")]
10643    pub rslt: Option<Response8Code>,
10644    #[serde(rename = "OthrRslt", skip_serializing_if = "Option::is_none")]
10645    pub othr_rslt: Option<Max35Text>,
10646    #[serde(rename = "RsltDtls")]
10647    pub rslt_dtls: Iso8583ResponseCode,
10648    #[serde(rename = "OthrRsltDtls", skip_serializing_if = "Option::is_none")]
10649    pub othr_rslt_dtls: Option<Max35Text>,
10650    #[serde(
10651        rename = "TempScrCardDataReusePrtd",
10652        skip_serializing_if = "Option::is_none"
10653    )]
10654    pub temp_scr_card_data_reuse_prtd: Option<TrueFalseIndicator>,
10655    #[validate(length(min = 0,))]
10656    #[serde(rename = "AddtlRsltInf", default)]
10657    pub addtl_rslt_inf: Vec<AdditionalData1>,
10658}
10659#[derive(
10660    Debug,
10661    Default,
10662    Clone,
10663    PartialEq,
10664    ::serde::Serialize,
10665    ::serde::Deserialize,
10666    ::derive_builder::Builder,
10667    ::validator::Validate,
10668)]
10669pub struct Iso8583AccountTypeCode {
10670    #[validate(regex = "ISO_8583_ACCOUNT_TYPE_CODE_REGEX")]
10671    #[serde(rename = "$text")]
10672    pub value: String,
10673}
10674#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
10675pub enum TerminalIntegrationCategory1Code {
10676    #[serde(rename = "MPOI")]
10677    Mpoi,
10678    #[serde(rename = "MSLE")]
10679    Msle,
10680    #[serde(rename = "SSLE")]
10681    Ssle,
10682    #[default]
10683    Unknown,
10684}
10685#[derive(
10686    Debug,
10687    Default,
10688    Clone,
10689    PartialEq,
10690    ::serde::Serialize,
10691    ::serde::Deserialize,
10692    ::derive_builder::Builder,
10693    ::validator::Validate,
10694)]
10695pub struct ProcessingResult10 {
10696    #[serde(rename = "RspnSrc", skip_serializing_if = "Option::is_none")]
10697    pub rspn_src: Option<ApprovalEntity2>,
10698    #[validate]
10699    #[serde(rename = "RsltData")]
10700    pub rslt_data: ResultData7,
10701    #[serde(rename = "ApprvlCd", skip_serializing_if = "Option::is_none")]
10702    pub apprvl_cd: Option<Exact6AlphaNumericText>,
10703    #[serde(rename = "ErrDtl", skip_serializing_if = "Option::is_none")]
10704    pub err_dtl: Option<ErrorDetails2>,
10705    #[serde(rename = "OrgnlRsltData", skip_serializing_if = "Option::is_none")]
10706    pub orgnl_rslt_data: Option<ResultData7>,
10707    #[serde(rename = "ActnReqrd", skip_serializing_if = "Option::is_none")]
10708    pub actn_reqrd: Option<YesNoIndicator>,
10709    #[validate(length(min = 0,))]
10710    #[serde(rename = "Actn", default)]
10711    pub actn: Vec<Action13>,
10712    #[validate(length(min = 0,))]
10713    #[serde(rename = "AddtlActn", default)]
10714    pub addtl_actn: Vec<AdditionalAction1>,
10715    #[validate(length(min = 0,))]
10716    #[serde(rename = "AddtlInf", default)]
10717    pub addtl_inf: Vec<AdditionalInformation29>,
10718}
10719#[derive(
10720    Debug,
10721    Default,
10722    Clone,
10723    PartialEq,
10724    ::serde::Serialize,
10725    ::serde::Deserialize,
10726    ::derive_builder::Builder,
10727    ::validator::Validate,
10728)]
10729pub struct Credentials2 {
10730    #[serde(rename = "IdCd")]
10731    pub id_cd: Identification3Code,
10732    #[serde(rename = "OthrIdCd", skip_serializing_if = "Option::is_none")]
10733    pub othr_id_cd: Option<Max35Text>,
10734    #[validate]
10735    #[serde(rename = "IdVal")]
10736    pub id_val: Max70Text,
10737    #[serde(rename = "IdXpryDt", skip_serializing_if = "Option::is_none")]
10738    pub id_xpry_dt: Option<IsoYearMonth>,
10739    #[serde(rename = "AssgnrAuthrty", skip_serializing_if = "Option::is_none")]
10740    pub assgnr_authrty: Option<Authority1>,
10741}
10742#[derive(
10743    Debug,
10744    Default,
10745    Clone,
10746    PartialEq,
10747    ::serde::Serialize,
10748    ::serde::Deserialize,
10749    ::derive_builder::Builder,
10750    ::validator::Validate,
10751)]
10752pub struct DisputeIdentification1 {
10753    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
10754    pub tp: Option<Max35Text>,
10755    #[validate]
10756    #[serde(rename = "Id")]
10757    pub id: Max70Text,
10758}
10759#[derive(
10760    Debug,
10761    Default,
10762    Clone,
10763    PartialEq,
10764    ::serde::Serialize,
10765    ::serde::Deserialize,
10766    ::derive_builder::Builder,
10767    ::validator::Validate,
10768)]
10769pub struct Max100Text {
10770    #[validate(length(min = 1, max = 100,))]
10771    #[serde(rename = "$text")]
10772    pub value: String,
10773}
10774#[derive(
10775    Debug,
10776    Default,
10777    Clone,
10778    PartialEq,
10779    ::serde::Serialize,
10780    ::serde::Deserialize,
10781    ::derive_builder::Builder,
10782    ::validator::Validate,
10783)]
10784pub struct Location4 {
10785    #[serde(rename = "LctnCd", skip_serializing_if = "Option::is_none")]
10786    pub lctn_cd: Option<Max35Text>,
10787    #[serde(rename = "LctnNm", skip_serializing_if = "Option::is_none")]
10788    pub lctn_nm: Option<Max35Text>,
10789    #[serde(rename = "Desc", skip_serializing_if = "Option::is_none")]
10790    pub desc: Option<Max256Text>,
10791    #[serde(rename = "Adr", skip_serializing_if = "Option::is_none")]
10792    pub adr: Option<Address2>,
10793    #[serde(rename = "LclTmZone", skip_serializing_if = "Option::is_none")]
10794    pub lcl_tm_zone: Option<Max70Text>,
10795    #[serde(rename = "LclCcy", skip_serializing_if = "Option::is_none")]
10796    pub lcl_ccy: Option<Iso3NumericCurrencyCode>,
10797}
10798#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
10799pub enum FundingSourceType2Code {
10800    #[serde(rename = "LOYL")]
10801    Loyl,
10802    #[serde(rename = "OTHN")]
10803    Othn,
10804    #[serde(rename = "OTHP")]
10805    Othp,
10806    #[serde(rename = "SVNG")]
10807    Svng,
10808    #[serde(rename = "UVRL")]
10809    Uvrl,
10810    #[serde(rename = "CASH")]
10811    Cash,
10812    #[serde(rename = "CRDT")]
10813    Crdt,
10814    #[serde(rename = "CDBT")]
10815    Cdbt,
10816    #[serde(rename = "EPRS")]
10817    Eprs,
10818    #[serde(rename = "DBAC")]
10819    Dbac,
10820    #[serde(rename = "CURR")]
10821    Curr,
10822    #[serde(rename = "CHQE")]
10823    Chqe,
10824    #[serde(rename = "PRPD")]
10825    Prpd,
10826    #[serde(rename = "LCDT")]
10827    Lcdt,
10828    #[default]
10829    Unknown,
10830}
10831#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
10832pub enum EncryptionFormat2Code {
10833    #[serde(rename = "TR31")]
10834    Tr31,
10835    #[serde(rename = "TR34")]
10836    Tr34,
10837    #[serde(rename = "I238")]
10838    I238,
10839    #[default]
10840    Unknown,
10841}
10842#[derive(
10843    Debug,
10844    Default,
10845    Clone,
10846    PartialEq,
10847    ::serde::Serialize,
10848    ::serde::Deserialize,
10849    ::derive_builder::Builder,
10850    ::validator::Validate,
10851)]
10852pub struct Vehicle5 {
10853    #[serde(rename = "VhclNb", skip_serializing_if = "Option::is_none")]
10854    pub vhcl_nb: Option<Max35NumericText>,
10855    #[serde(rename = "VhclIdNb", skip_serializing_if = "Option::is_none")]
10856    pub vhcl_id_nb: Option<Max35NumericText>,
10857    #[serde(rename = "FleetNb", skip_serializing_if = "Option::is_none")]
10858    pub fleet_nb: Option<Max10Text>,
10859    #[serde(rename = "SubFleetNb", skip_serializing_if = "Option::is_none")]
10860    pub sub_fleet_nb: Option<Max35Text>,
10861    #[serde(rename = "UnitNb", skip_serializing_if = "Option::is_none")]
10862    pub unit_nb: Option<Max35NumericText>,
10863    #[serde(rename = "TrlrNb", skip_serializing_if = "Option::is_none")]
10864    pub trlr_nb: Option<Max35NumericText>,
10865    #[serde(rename = "VhclTag", skip_serializing_if = "Option::is_none")]
10866    pub vhcl_tag: Option<Max35Text>,
10867    #[serde(rename = "VhclTagNtryMd", skip_serializing_if = "Option::is_none")]
10868    pub vhcl_tag_ntry_md: Option<CardDataReading5Code>,
10869    #[serde(rename = "RplcmntVhclInd", skip_serializing_if = "Option::is_none")]
10870    pub rplcmnt_vhcl_ind: Option<TrueFalseIndicator>,
10871    #[serde(rename = "Odmtr", skip_serializing_if = "Option::is_none")]
10872    pub odmtr: Option<DecimalNumber>,
10873    #[serde(rename = "Hbmtr", skip_serializing_if = "Option::is_none")]
10874    pub hbmtr: Option<DecimalNumber>,
10875    #[serde(rename = "MntncId", skip_serializing_if = "Option::is_none")]
10876    pub mntnc_id: Option<Max35Text>,
10877    #[serde(rename = "OnBrdDgnstcs", skip_serializing_if = "Option::is_none")]
10878    pub on_brd_dgnstcs: Option<OnBoardDiagnostics1>,
10879    #[validate(length(min = 0,))]
10880    #[serde(rename = "AddtlVhclData", default)]
10881    pub addtl_vhcl_data: Vec<Vehicle2>,
10882}
10883#[derive(
10884    Debug,
10885    Default,
10886    Clone,
10887    PartialEq,
10888    ::serde::Serialize,
10889    ::serde::Deserialize,
10890    ::derive_builder::Builder,
10891    ::validator::Validate,
10892)]
10893pub struct Lodging3 {
10894    #[serde(rename = "Summry", skip_serializing_if = "Option::is_none")]
10895    pub summry: Option<LodgingSummary2>,
10896    #[validate(length(min = 0,))]
10897    #[serde(rename = "LineItm", default)]
10898    pub line_itm: Vec<LodgingLineItem2>,
10899}
10900#[derive(
10901    Debug,
10902    Default,
10903    Clone,
10904    PartialEq,
10905    ::serde::Serialize,
10906    ::serde::Deserialize,
10907    ::derive_builder::Builder,
10908    ::validator::Validate,
10909)]
10910pub struct Max512Text {
10911    #[validate(length(min = 1, max = 512,))]
10912    #[serde(rename = "$text")]
10913    pub value: String,
10914}
10915#[derive(
10916    Debug,
10917    Default,
10918    Clone,
10919    PartialEq,
10920    ::serde::Serialize,
10921    ::serde::Deserialize,
10922    ::derive_builder::Builder,
10923    ::validator::Validate,
10924)]
10925pub struct IssuerAndSerialNumber1 {
10926    #[validate]
10927    #[serde(rename = "Issr")]
10928    pub issr: CertificateIssuer1,
10929    #[validate]
10930    #[serde(rename = "SrlNb")]
10931    pub srl_nb: Max35Binary,
10932}
10933#[derive(
10934    Debug,
10935    Default,
10936    Clone,
10937    PartialEq,
10938    ::serde::Serialize,
10939    ::serde::Deserialize,
10940    ::derive_builder::Builder,
10941    ::validator::Validate,
10942)]
10943pub struct Max35Text {
10944    #[validate(length(min = 1, max = 35,))]
10945    #[serde(rename = "$text")]
10946    pub value: String,
10947}
10948#[derive(
10949    Debug,
10950    Default,
10951    Clone,
10952    PartialEq,
10953    ::serde::Serialize,
10954    ::serde::Deserialize,
10955    ::derive_builder::Builder,
10956    ::validator::Validate,
10957)]
10958pub struct InvoiceSummary2 {
10959    #[serde(rename = "InvcNb", skip_serializing_if = "Option::is_none")]
10960    pub invc_nb: Option<Max70Text>,
10961    #[serde(rename = "Sellr", skip_serializing_if = "Option::is_none")]
10962    pub sellr: Option<PartyIdentification259>,
10963    #[serde(rename = "Buyr", skip_serializing_if = "Option::is_none")]
10964    pub buyr: Option<PartyIdentification259>,
10965    #[serde(rename = "InvcDt", skip_serializing_if = "Option::is_none")]
10966    pub invc_dt: Option<IsoDate>,
10967    #[serde(rename = "InvcCreDtTm", skip_serializing_if = "Option::is_none")]
10968    pub invc_cre_dt_tm: Option<IsoDateTime>,
10969    #[serde(rename = "SummryCmmdtyId", skip_serializing_if = "Option::is_none")]
10970    pub summry_cmmdty_id: Option<Max35Text>,
10971    #[serde(rename = "FrghtAmt", skip_serializing_if = "Option::is_none")]
10972    pub frght_amt: Option<ImpliedCurrencyAndAmount>,
10973    #[validate(length(min = 0,))]
10974    #[serde(rename = "TaxTtl", default)]
10975    pub tax_ttl: Vec<Tax39>,
10976    #[serde(rename = "TaxRclmMtd", skip_serializing_if = "Option::is_none")]
10977    pub tax_rclm_mtd: Option<TaxReclaimMethod1Code>,
10978    #[serde(rename = "AddtlData", skip_serializing_if = "Option::is_none")]
10979    pub addtl_data: Option<Max350Text>,
10980}
10981#[derive(
10982    Debug,
10983    Default,
10984    Clone,
10985    PartialEq,
10986    ::serde::Serialize,
10987    ::serde::Deserialize,
10988    ::derive_builder::Builder,
10989    ::validator::Validate,
10990)]
10991pub struct AdditionalData1 {
10992    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
10993    pub tp: Option<Max35Text>,
10994    #[serde(rename = "Val", skip_serializing_if = "Option::is_none")]
10995    pub val: Option<Max2048Text>,
10996}
10997#[derive(
10998    Debug,
10999    Default,
11000    Clone,
11001    PartialEq,
11002    ::serde::Serialize,
11003    ::serde::Deserialize,
11004    ::derive_builder::Builder,
11005    ::validator::Validate,
11006)]
11007pub struct TransactionLifeCycleIdentification2 {
11008    #[validate]
11009    #[serde(rename = "Id")]
11010    pub id: Exact15Text,
11011}
11012#[derive(
11013    Debug,
11014    Default,
11015    Clone,
11016    PartialEq,
11017    ::serde::Serialize,
11018    ::serde::Deserialize,
11019    ::derive_builder::Builder,
11020    ::validator::Validate,
11021)]
11022pub struct Adjustment10 {
11023    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
11024    pub tp: Option<Max35Text>,
11025    #[serde(rename = "AddtlTp", skip_serializing_if = "Option::is_none")]
11026    pub addtl_tp: Option<Max35Text>,
11027    #[serde(rename = "Desc", skip_serializing_if = "Option::is_none")]
11028    pub desc: Option<Max70Text>,
11029    #[serde(rename = "Rsn", skip_serializing_if = "Option::is_none")]
11030    pub rsn: Option<Max35Text>,
11031    #[serde(rename = "PrmtnElgblty", skip_serializing_if = "Option::is_none")]
11032    pub prmtn_elgblty: Option<TrueFalseIndicator>,
11033    #[serde(rename = "PrmtnCd", skip_serializing_if = "Option::is_none")]
11034    pub prmtn_cd: Option<Max35Text>,
11035    #[serde(rename = "PrmtnCpnNb", skip_serializing_if = "Option::is_none")]
11036    pub prmtn_cpn_nb: Option<Max35Text>,
11037    #[serde(rename = "Qty", skip_serializing_if = "Option::is_none")]
11038    pub qty: Option<DecimalNumber>,
11039    #[serde(rename = "UnitPric", skip_serializing_if = "Option::is_none")]
11040    pub unit_pric: Option<ImpliedCurrencyAndAmount>,
11041    #[serde(rename = "Pctg", skip_serializing_if = "Option::is_none")]
11042    pub pctg: Option<PercentageRate>,
11043    #[serde(rename = "AdjstmntAmt", skip_serializing_if = "Option::is_none")]
11044    pub adjstmnt_amt: Option<ImpliedCurrencyAndAmount>,
11045    #[serde(rename = "TaxClctdOnOrgnlAmt", skip_serializing_if = "Option::is_none")]
11046    pub tax_clctd_on_orgnl_amt: Option<TrueFalseIndicator>,
11047}
11048#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
11049pub enum CustomerType2Code {
11050    #[serde(rename = "CSMR")]
11051    Csmr,
11052    #[serde(rename = "CPNY")]
11053    Cpny,
11054    #[default]
11055    Unknown,
11056}
11057#[derive(
11058    Debug,
11059    Default,
11060    Clone,
11061    PartialEq,
11062    ::serde::Serialize,
11063    ::serde::Deserialize,
11064    ::derive_builder::Builder,
11065    ::validator::Validate,
11066)]
11067pub struct PlainCardData21 {
11068    #[serde(rename = "DrvrOrVhclId", skip_serializing_if = "Option::is_none")]
11069    pub drvr_or_vhcl_id: Option<Max20Text>,
11070    #[validate(length(min = 0,))]
11071    #[serde(rename = "AddtlCardData", default)]
11072    pub addtl_card_data: Vec<AdditionalData1>,
11073}
11074#[derive(
11075    Debug,
11076    Default,
11077    Clone,
11078    PartialEq,
11079    ::serde::Serialize,
11080    ::serde::Deserialize,
11081    ::derive_builder::Builder,
11082    ::validator::Validate,
11083)]
11084pub struct SettlementReportingEntity1 {
11085    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
11086    pub tp: Option<Max35Text>,
11087    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
11088    pub id: Option<Max35Text>,
11089}
11090#[derive(
11091    Debug,
11092    Default,
11093    Clone,
11094    PartialEq,
11095    ::serde::Serialize,
11096    ::serde::Deserialize,
11097    ::derive_builder::Builder,
11098    ::validator::Validate,
11099)]
11100pub struct AccountDetails3 {
11101    #[serde(rename = "AcctNm", skip_serializing_if = "Option::is_none")]
11102    pub acct_nm: Option<Max70Text>,
11103    #[serde(rename = "AcctTp", skip_serializing_if = "Option::is_none")]
11104    pub acct_tp: Option<Iso8583AccountTypeCode>,
11105    #[serde(rename = "AcctId", skip_serializing_if = "Option::is_none")]
11106    pub acct_id: Option<Max70Text>,
11107}
11108#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
11109pub enum MessageError1Code {
11110    #[serde(rename = "IDEF")]
11111    Idef,
11112    #[serde(rename = "IDEL")]
11113    Idel,
11114    #[serde(rename = "IDEV")]
11115    Idev,
11116    #[serde(rename = "INME")]
11117    Inme,
11118    #[serde(rename = "INMF")]
11119    Inmf,
11120    #[serde(rename = "MEPE")]
11121    Mepe,
11122    #[serde(rename = "OTHP")]
11123    Othp,
11124    #[serde(rename = "PRVE")]
11125    Prve,
11126    #[serde(rename = "RDEM")]
11127    Rdem,
11128    #[serde(rename = "SECU")]
11129    Secu,
11130    #[serde(rename = "UDFD")]
11131    Udfd,
11132    #[serde(rename = "OTHN")]
11133    Othn,
11134    #[serde(rename = "ITDE")]
11135    Itde,
11136    #[serde(rename = "DUME")]
11137    Dume,
11138    #[serde(rename = "IDWM")]
11139    Idwm,
11140    #[serde(rename = "IDRM")]
11141    Idrm,
11142    #[serde(rename = "IBAT")]
11143    Ibat,
11144    #[serde(rename = "ICOL")]
11145    Icol,
11146    #[default]
11147    Unknown,
11148}
11149#[derive(
11150    Debug,
11151    Default,
11152    Clone,
11153    PartialEq,
11154    ::serde::Serialize,
11155    ::serde::Deserialize,
11156    ::derive_builder::Builder,
11157    ::validator::Validate,
11158)]
11159pub struct Contact1 {
11160    #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
11161    pub nm: Option<Max70Text>,
11162    #[serde(rename = "HomePhneNb", skip_serializing_if = "Option::is_none")]
11163    pub home_phne_nb: Option<PhoneNumber>,
11164    #[serde(rename = "BizPhneNb", skip_serializing_if = "Option::is_none")]
11165    pub biz_phne_nb: Option<PhoneNumber>,
11166    #[serde(rename = "MobPhneNb", skip_serializing_if = "Option::is_none")]
11167    pub mob_phne_nb: Option<PhoneNumber>,
11168    #[serde(rename = "OthrPhneNb", skip_serializing_if = "Option::is_none")]
11169    pub othr_phne_nb: Option<PhoneNumber>,
11170    #[serde(rename = "PrsnlEmailAdr", skip_serializing_if = "Option::is_none")]
11171    pub prsnl_email_adr: Option<Max256Text>,
11172    #[serde(rename = "BizEmailAdr", skip_serializing_if = "Option::is_none")]
11173    pub biz_email_adr: Option<Max256Text>,
11174    #[serde(rename = "OthrEmailAdr", skip_serializing_if = "Option::is_none")]
11175    pub othr_email_adr: Option<Max256Text>,
11176    #[serde(rename = "Lang", skip_serializing_if = "Option::is_none")]
11177    pub lang: Option<Iso2ALanguageCode>,
11178}
11179#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
11180pub enum IccFallbackReason1Code {
11181    #[serde(rename = "CIIA")]
11182    Ciia,
11183    #[serde(rename = "EDIP")]
11184    Edip,
11185    #[serde(rename = "OTHN")]
11186    Othn,
11187    #[serde(rename = "OTHP")]
11188    Othp,
11189    #[serde(rename = "TERI")]
11190    Teri,
11191    #[default]
11192    Unknown,
11193}
11194#[derive(
11195    Debug,
11196    Default,
11197    Clone,
11198    PartialEq,
11199    ::serde::Serialize,
11200    ::serde::Deserialize,
11201    ::derive_builder::Builder,
11202    ::validator::Validate,
11203)]
11204pub struct AlgorithmIdentification25 {
11205    #[serde(rename = "Algo")]
11206    pub algo: Algorithm23Code,
11207    #[serde(rename = "Param", skip_serializing_if = "Option::is_none")]
11208    pub param: Option<Parameter7>,
11209}
11210#[derive(
11211    Debug,
11212    Default,
11213    Clone,
11214    PartialEq,
11215    ::serde::Serialize,
11216    ::serde::Deserialize,
11217    ::derive_builder::Builder,
11218    ::validator::Validate,
11219)]
11220pub struct Exact1HexBinaryText {
11221    #[validate(regex = "EXACT_1_HEX_BINARY_TEXT_REGEX")]
11222    #[serde(rename = "$text")]
11223    pub value: String,
11224}
11225#[derive(
11226    Debug,
11227    Default,
11228    Clone,
11229    PartialEq,
11230    ::serde::Serialize,
11231    ::serde::Deserialize,
11232    ::derive_builder::Builder,
11233    ::validator::Validate,
11234)]
11235pub struct LodgingRoom1 {
11236    #[serde(rename = "RoomTp", skip_serializing_if = "Option::is_none")]
11237    pub room_tp: Option<Max35Text>,
11238    #[serde(rename = "RoomLctn", skip_serializing_if = "Option::is_none")]
11239    pub room_lctn: Option<Max35Text>,
11240    #[serde(rename = "BedTp", skip_serializing_if = "Option::is_none")]
11241    pub bed_tp: Option<Max70Text>,
11242    #[serde(rename = "GstsPerRoom", skip_serializing_if = "Option::is_none")]
11243    pub gsts_per_room: Option<Max3NumericText>,
11244    #[serde(rename = "AdltsInRoom", skip_serializing_if = "Option::is_none")]
11245    pub adlts_in_room: Option<Max3NumericText>,
11246    #[serde(rename = "ChldrnInRoom", skip_serializing_if = "Option::is_none")]
11247    pub chldrn_in_room: Option<Max3NumericText>,
11248    #[serde(rename = "DalyRoomRate", skip_serializing_if = "Option::is_none")]
11249    pub daly_room_rate: Option<ImpliedCurrencyAndAmount>,
11250}
11251#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
11252pub enum Moto1Code {
11253    #[serde(rename = "MAOR")]
11254    Maor,
11255    #[serde(rename = "MOTO")]
11256    Moto,
11257    #[serde(rename = "TPOR")]
11258    Tpor,
11259    #[default]
11260    Unknown,
11261}
11262#[derive(
11263    Debug,
11264    Default,
11265    Clone,
11266    PartialEq,
11267    ::serde::Serialize,
11268    ::serde::Deserialize,
11269    ::derive_builder::Builder,
11270    ::validator::Validate,
11271)]
11272pub struct Amount15 {
11273    #[validate]
11274    #[serde(rename = "Amt")]
11275    pub amt: ImpliedCurrencyAndAmount,
11276    #[serde(rename = "Ccy", skip_serializing_if = "Option::is_none")]
11277    pub ccy: Option<Iso3NumericCurrencyCode>,
11278    #[serde(rename = "FctvXchgRate", skip_serializing_if = "Option::is_none")]
11279    pub fctv_xchg_rate: Option<BaseOne25Rate>,
11280    #[serde(rename = "ConvsDt", skip_serializing_if = "Option::is_none")]
11281    pub convs_dt: Option<IsoDate>,
11282    #[serde(rename = "ConvsTm", skip_serializing_if = "Option::is_none")]
11283    pub convs_tm: Option<IsoTime>,
11284}
11285#[derive(
11286    Debug,
11287    Default,
11288    Clone,
11289    PartialEq,
11290    ::serde::Serialize,
11291    ::serde::Deserialize,
11292    ::derive_builder::Builder,
11293    ::validator::Validate,
11294)]
11295pub struct GenericInformation1 {
11296    #[validate]
11297    #[serde(rename = "Nm")]
11298    pub nm: Max70Text,
11299    #[serde(rename = "Val", skip_serializing_if = "Option::is_none")]
11300    pub val: Option<Max140Text>,
11301}
11302#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
11303pub enum PurchaseIdentifierType1Code {
11304    #[serde(rename = "CONU")]
11305    Conu,
11306    #[serde(rename = "CUOR")]
11307    Cuor,
11308    #[serde(rename = "CUPO")]
11309    Cupo,
11310    #[serde(rename = "FONU")]
11311    Fonu,
11312    #[serde(rename = "INNU")]
11313    Innu,
11314    #[serde(rename = "ORNU")]
11315    Ornu,
11316    #[serde(rename = "OTHN")]
11317    Othn,
11318    #[serde(rename = "OTHP")]
11319    Othp,
11320    #[serde(rename = "PRNU")]
11321    Prnu,
11322    #[serde(rename = "PUID")]
11323    Puid,
11324    #[serde(rename = "RELO")]
11325    Relo,
11326    #[serde(rename = "REAG")]
11327    Reag,
11328    #[serde(rename = "RENU")]
11329    Renu,
11330    #[serde(rename = "RSNU")]
11331    Rsnu,
11332    #[serde(rename = "SUOR")]
11333    Suor,
11334    #[serde(rename = "TINU")]
11335    Tinu,
11336    #[serde(rename = "TRNU")]
11337    Trnu,
11338    #[serde(rename = "SUIN")]
11339    Suin,
11340    #[serde(rename = "TNID")]
11341    Tnid,
11342    #[default]
11343    Unknown,
11344}
11345#[derive(
11346    Debug,
11347    Default,
11348    Clone,
11349    PartialEq,
11350    ::serde::Serialize,
11351    ::serde::Deserialize,
11352    ::derive_builder::Builder,
11353    ::validator::Validate,
11354)]
11355pub struct Header66 {
11356    #[serde(rename = "MsgFctn")]
11357    pub msg_fctn: MessageFunction29Code,
11358    #[validate]
11359    #[serde(rename = "PrtcolVrsn")]
11360    pub prtcol_vrsn: Max2048Text,
11361    #[serde(rename = "XchgId", skip_serializing_if = "Option::is_none")]
11362    pub xchg_id: Option<Max35Text>,
11363    #[serde(rename = "ReTrnsmssnCntr", skip_serializing_if = "Option::is_none")]
11364    pub re_trnsmssn_cntr: Option<Max3NumericText>,
11365    #[validate]
11366    #[serde(rename = "CreDtTm")]
11367    pub cre_dt_tm: IsoDateTime,
11368    #[serde(rename = "BtchMgmtInf", skip_serializing_if = "Option::is_none")]
11369    pub btch_mgmt_inf: Option<BatchManagementInformation1>,
11370    #[validate]
11371    #[serde(rename = "InitgPty")]
11372    pub initg_pty: GenericIdentification183,
11373    #[serde(rename = "RcptPty", skip_serializing_if = "Option::is_none")]
11374    pub rcpt_pty: Option<GenericIdentification183>,
11375    #[validate(length(min = 0,))]
11376    #[serde(rename = "TracData", default)]
11377    pub trac_data: Vec<AdditionalData1>,
11378    #[validate(length(min = 0,))]
11379    #[serde(rename = "Tracblt", default)]
11380    pub tracblt: Vec<Traceability9>,
11381}
11382#[derive(
11383    Debug,
11384    Default,
11385    Clone,
11386    PartialEq,
11387    ::serde::Serialize,
11388    ::serde::Deserialize,
11389    ::derive_builder::Builder,
11390    ::validator::Validate,
11391)]
11392pub struct Max10PositiveNumber {
11393    #[validate(range(min = 1,))]
11394    #[serde(rename = "$text")]
11395    pub value: f64,
11396}
11397#[derive(
11398    Debug,
11399    Default,
11400    Clone,
11401    PartialEq,
11402    ::serde::Serialize,
11403    ::serde::Deserialize,
11404    ::derive_builder::Builder,
11405    ::validator::Validate,
11406)]
11407pub struct Parameter13 {
11408    #[serde(rename = "DgstAlgo", skip_serializing_if = "Option::is_none")]
11409    pub dgst_algo: Option<Algorithm20Code>,
11410    #[serde(rename = "MskGnrtrAlgo", skip_serializing_if = "Option::is_none")]
11411    pub msk_gnrtr_algo: Option<AlgorithmIdentification26>,
11412}
11413#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
11414pub enum TimeSegment1Code {
11415    #[serde(rename = "AMBN")]
11416    Ambn,
11417    #[serde(rename = "PMAN")]
11418    Pman,
11419    #[default]
11420    Unknown,
11421}
11422#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
11423pub enum PartyType7Code {
11424    #[serde(rename = "ACQR")]
11425    Acqr,
11426    #[serde(rename = "ITAG")]
11427    Itag,
11428    #[serde(rename = "PCPT")]
11429    Pcpt,
11430    #[serde(rename = "TMGT")]
11431    Tmgt,
11432    #[serde(rename = "SALE")]
11433    Sale,
11434    #[default]
11435    Unknown,
11436}
11437#[derive(
11438    Debug,
11439    Default,
11440    Clone,
11441    PartialEq,
11442    ::serde::Serialize,
11443    ::serde::Deserialize,
11444    ::derive_builder::Builder,
11445    ::validator::Validate,
11446)]
11447pub struct Max19NumericText {
11448    #[validate(regex = "MAX_19_NUMERIC_TEXT_REGEX")]
11449    #[serde(rename = "$text")]
11450    pub value: String,
11451}
11452#[derive(
11453    Debug,
11454    Default,
11455    Clone,
11456    PartialEq,
11457    ::serde::Serialize,
11458    ::serde::Deserialize,
11459    ::derive_builder::Builder,
11460    ::validator::Validate,
11461)]
11462pub struct IsoMax3ACountryCode {
11463    #[validate(regex = "ISO_MAX_3_A_COUNTRY_CODE_REGEX")]
11464    #[serde(rename = "$text")]
11465    pub value: String,
11466}
11467#[derive(
11468    Debug,
11469    Default,
11470    Clone,
11471    PartialEq,
11472    ::serde::Serialize,
11473    ::serde::Deserialize,
11474    ::derive_builder::Builder,
11475    ::validator::Validate,
11476)]
11477pub struct ProtectedData1 {
11478    #[serde(rename = "CnttTp")]
11479    pub cntt_tp: ContentType3Code,
11480    #[serde(rename = "EnvlpdData", skip_serializing_if = "Option::is_none")]
11481    pub envlpd_data: Option<EnvelopedData6>,
11482    #[serde(rename = "NcrptdData", skip_serializing_if = "Option::is_none")]
11483    pub ncrptd_data: Option<EncryptedData1>,
11484}
11485#[derive(
11486    Debug,
11487    Default,
11488    Clone,
11489    PartialEq,
11490    ::serde::Serialize,
11491    ::serde::Deserialize,
11492    ::derive_builder::Builder,
11493    ::validator::Validate,
11494)]
11495pub struct Max99Text {
11496    #[validate(length(min = 1, max = 99,))]
11497    #[serde(rename = "$text")]
11498    pub value: String,
11499}
11500#[derive(
11501    Debug,
11502    Default,
11503    Clone,
11504    PartialEq,
11505    ::serde::Serialize,
11506    ::serde::Deserialize,
11507    ::derive_builder::Builder,
11508    ::validator::Validate,
11509)]
11510pub struct AdditionalRiskData1 {
11511    #[validate]
11512    #[serde(rename = "Tp")]
11513    pub tp: Max35Text,
11514    #[validate]
11515    #[serde(rename = "Val")]
11516    pub val: Max10KText,
11517}
11518#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
11519pub enum ProtectionMethod1Code {
11520    #[serde(rename = "OTHN")]
11521    Othn,
11522    #[serde(rename = "OTHP")]
11523    Othp,
11524    #[serde(rename = "SELM")]
11525    Selm,
11526    #[serde(rename = "SNCL")]
11527    Sncl,
11528    #[serde(rename = "SOFT")]
11529    Soft,
11530    #[serde(rename = "TEEN")]
11531    Teen,
11532    #[default]
11533    Unknown,
11534}
11535#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
11536pub enum PartyType28Code {
11537    #[serde(rename = "ACCP")]
11538    Accp,
11539    #[serde(rename = "ACQR")]
11540    Acqr,
11541    #[serde(rename = "AGNT")]
11542    Agnt,
11543    #[serde(rename = "OTHN")]
11544    Othn,
11545    #[serde(rename = "OTHP")]
11546    Othp,
11547    #[serde(rename = "WLPR")]
11548    Wlpr,
11549    #[serde(rename = "ISUR")]
11550    Isur,
11551    #[default]
11552    Unknown,
11553}
11554#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
11555pub enum PoiCommunicationType2Code {
11556    #[serde(rename = "BLTH")]
11557    Blth,
11558    #[serde(rename = "ETHR")]
11559    Ethr,
11560    #[serde(rename = "GPRS")]
11561    Gprs,
11562    #[serde(rename = "GSMF")]
11563    Gsmf,
11564    #[serde(rename = "PSTN")]
11565    Pstn,
11566    #[serde(rename = "RS23")]
11567    Rs23,
11568    #[serde(rename = "USBD")]
11569    Usbd,
11570    #[serde(rename = "USBH")]
11571    Usbh,
11572    #[serde(rename = "WIFI")]
11573    Wifi,
11574    #[serde(rename = "WT2G")]
11575    Wt2G,
11576    #[serde(rename = "WT3G")]
11577    Wt3G,
11578    #[serde(rename = "WT4G")]
11579    Wt4G,
11580    #[serde(rename = "WT5G")]
11581    Wt5G,
11582    #[default]
11583    Unknown,
11584}
11585#[derive(
11586    Debug,
11587    Default,
11588    Clone,
11589    PartialEq,
11590    ::serde::Serialize,
11591    ::serde::Deserialize,
11592    ::derive_builder::Builder,
11593    ::validator::Validate,
11594)]
11595pub struct AlgorithmIdentification19 {
11596    #[serde(rename = "Algo")]
11597    pub algo: Algorithm7Code,
11598    #[serde(rename = "Param", skip_serializing_if = "Option::is_none")]
11599    pub param: Option<Parameter10>,
11600}
11601#[derive(
11602    Debug,
11603    Default,
11604    Clone,
11605    PartialEq,
11606    ::serde::Serialize,
11607    ::serde::Deserialize,
11608    ::derive_builder::Builder,
11609    ::validator::Validate,
11610)]
11611pub struct Discount3 {
11612    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
11613    pub tp: Option<Max35Text>,
11614    #[validate]
11615    #[serde(rename = "Val")]
11616    pub val: Max35Text,
11617}
11618#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
11619pub enum LodgingService1Code {
11620    #[serde(rename = "ACCO")]
11621    Acco,
11622    #[serde(rename = "AUDI")]
11623    Audi,
11624    #[serde(rename = "BANQ")]
11625    Banq,
11626    #[serde(rename = "BREK")]
11627    Brek,
11628    #[serde(rename = "BUSS")]
11629    Buss,
11630    #[serde(rename = "CONC")]
11631    Conc,
11632    #[serde(rename = "EARA")]
11633    Eara,
11634    #[serde(rename = "EARD")]
11635    Eard,
11636    #[serde(rename = "ENTR")]
11637    Entr,
11638    #[serde(rename = "FCAA")]
11639    Fcaa,
11640    #[serde(rename = "GAME")]
11641    Game,
11642    #[serde(rename = "GARA")]
11643    Gara,
11644    #[serde(rename = "GIFT")]
11645    Gift,
11646    #[serde(rename = "HEAL")]
11647    Heal,
11648    #[serde(rename = "INTE")]
11649    Inte,
11650    #[serde(rename = "LAUN")]
11651    Laun,
11652    #[serde(rename = "LONG")]
11653    Long,
11654    #[serde(rename = "MINI")]
11655    Mini,
11656    #[serde(rename = "NOSH")]
11657    Nosh,
11658    #[serde(rename = "OTHR")]
11659    Othr,
11660    #[serde(rename = "PARK")]
11661    Park,
11662    #[serde(rename = "PHON")]
11663    Phon,
11664    #[serde(rename = "REST")]
11665    Rest,
11666    #[serde(rename = "RMSE")]
11667    Rmse,
11668    #[serde(rename = "SPAS")]
11669    Spas,
11670    #[serde(rename = "THRD")]
11671    Thrd,
11672    #[serde(rename = "TRAN")]
11673    Tran,
11674    #[serde(rename = "VODS")]
11675    Vods,
11676    #[default]
11677    Unknown,
11678}
11679#[derive(
11680    Debug,
11681    Default,
11682    Clone,
11683    PartialEq,
11684    ::serde::Serialize,
11685    ::serde::Deserialize,
11686    ::derive_builder::Builder,
11687    ::validator::Validate,
11688)]
11689pub struct Max15Text {
11690    #[validate(length(min = 1, max = 15,))]
11691    #[serde(rename = "$text")]
11692    pub value: String,
11693}
iso_20022_caad/caad_009_001_01.rs

iso_20022_caad/
caad_009_001_01.rs
