1use validator::Validate;
22
23::lazy_static::lazy_static! {
24 static ref LEI_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Z0-9]{18,18}[0-9]{2,2}"#).unwrap();
25}
26
27::lazy_static::lazy_static! {
28 static ref BLOOMBERG_2_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"(BBG)[BCDFGHJKLMNPQRSTVWXYZ\d]{8}\d"#).unwrap();
29}
30
31::lazy_static::lazy_static! {
32 static ref PORTUGUESE_NCC_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"PT[0-9]{8,8}"#).unwrap();
33}
34
35::lazy_static::lazy_static! {
36 static ref SMALL_NETWORK_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"AU[0-9]{6,6}"#).unwrap();
37}
38
39::lazy_static::lazy_static! {
40 static ref BICFI_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Z]{6,6}[A-Z2-9][A-NP-Z0-9]([A-Z0-9]{3,3}){0,1}"#).unwrap();
41}
42
43::lazy_static::lazy_static! {
44 static ref NEW_ZEALAND_NCC_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"NZ[0-9]{6,6}"#).unwrap();
45}
46
47::lazy_static::lazy_static! {
48 static ref ACTIVE_CURRENCY_CODE_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Z]{3,3}"#).unwrap();
49}
50
51::lazy_static::lazy_static! {
52 static ref CANADIAN_PAYMENTS_ARN_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"CA[0-9]{9,9}"#).unwrap();
53}
54
55::lazy_static::lazy_static! {
56 static ref ANY_BIC_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Z]{6,6}[A-Z2-9][A-NP-Z0-9]([A-Z0-9]{3,3}){0,1}"#).unwrap();
57}
58
59::lazy_static::lazy_static! {
60 static ref ACTIVE_OR_HISTORIC_CURRENCY_CODE_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Z]{3,3}"#).unwrap();
61}
62
63::lazy_static::lazy_static! {
64 static ref EXTENSIVE_BRANCH_NETWORK_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"AU[0-9]{6,6}"#).unwrap();
65}
66
67::lazy_static::lazy_static! {
68 static ref MIC_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Z0-9]{4,4}"#).unwrap();
69}
70
71::lazy_static::lazy_static! {
72 static ref UK_DOMESTIC_SORT_CODE_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"SC[0-9]{6,6}"#).unwrap();
73}
74
75::lazy_static::lazy_static! {
76 static ref ITALIAN_DOMESTIC_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"IT[0-9]{10,10}"#).unwrap();
77}
78
79::lazy_static::lazy_static! {
80 static ref IRISH_NSC_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"IE[0-9]{6,6}"#).unwrap();
81}
82
83::lazy_static::lazy_static! {
84 static ref CHIPS_PARTICIPANT_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"CP[0-9]{4,4}"#).unwrap();
85}
86
87::lazy_static::lazy_static! {
88 static ref ISIN_OCT_2015_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}"#).unwrap();
89}
90
91::lazy_static::lazy_static! {
92 static ref HONG_KONG_BANK_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"HK[0-9]{3,3}"#).unwrap();
93}
94
95::lazy_static::lazy_static! {
96 static ref FEDWIRE_ROUTING_NUMBER_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"FW[0-9]{9,9}"#).unwrap();
97}
98
99::lazy_static::lazy_static! {
100 static ref SWISS_SIC_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"SW[0-9]{6,6}"#).unwrap();
101}
102
103::lazy_static::lazy_static! {
104 static ref EXACT_4_ALPHA_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[a-zA-Z0-9]{4}"#).unwrap();
105}
106
107::lazy_static::lazy_static! {
108 static ref GERMAN_BANKLEITZAHL_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"BL[0-9]{8,8}"#).unwrap();
109}
110
111::lazy_static::lazy_static! {
112 static ref SWISS_BC_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"SW[0-9]{3,5}"#).unwrap();
113}
114
115::lazy_static::lazy_static! {
116 static ref AUSTRIAN_BANKLEITZAHL_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"AT[0-9]{5,5}"#).unwrap();
117}
118
119::lazy_static::lazy_static! {
120 static ref SOUTH_AFRICAN_NCC_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"ZA[0-9]{6,6}"#).unwrap();
121}
122
123::lazy_static::lazy_static! {
124 static ref MAX_4_ALPHA_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[a-zA-Z0-9]{1,4}"#).unwrap();
125}
126
127::lazy_static::lazy_static! {
128 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();
129}
130
131::lazy_static::lazy_static! {
132 static ref COUNTRY_CODE_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Z]{2,2}"#).unwrap();
133}
134
135::lazy_static::lazy_static! {
136 static ref RUSSIAN_CENTRAL_BANK_IDENTIFICATION_CODE_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"RU[0-9]{9,9}"#).unwrap();
137}
138
139::lazy_static::lazy_static! {
140 static ref SPANISH_DOMESTIC_INTERBANKING_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"ES[0-9]{8,9}"#).unwrap();
141}
142
143::lazy_static::lazy_static! {
144 static ref IBAN_2007_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Z]{2,2}[0-9]{2,2}[a-zA-Z0-9]{1,30}"#).unwrap();
145}
146
147::lazy_static::lazy_static! {
148 static ref CHIPS_UNIVERSAL_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"CH[0-9]{6,6}"#).unwrap();
149}
150
151pub fn namespace() -> String {
153 "urn:iso:std:iso:20022:tech:xsd:setr.012.001.04".to_string()
154}
155
156#[derive(
157 Debug,
158 Default,
159 Clone,
160 PartialEq,
161 ::serde::Serialize,
162 ::serde::Deserialize,
163 ::derive_builder::Builder,
164 ::validator::Validate,
165)]
166pub struct Max35Text {
167 #[validate(length(min = 1, max = 35,))]
168 #[serde(rename = "$text")]
169 pub value: String,
170}
171#[derive(
172 Debug,
173 Default,
174 Clone,
175 PartialEq,
176 ::serde::Serialize,
177 ::serde::Deserialize,
178 ::derive_builder::Builder,
179 ::validator::Validate,
180)]
181pub struct LeiIdentifier {
182 #[validate(regex = "LEI_IDENTIFIER_REGEX")]
183 #[serde(rename = "$text")]
184 pub value: String,
185}
186#[derive(
187 Debug,
188 Default,
189 Clone,
190 PartialEq,
191 ::serde::Serialize,
192 ::serde::Deserialize,
193 ::derive_builder::Builder,
194 ::validator::Validate,
195)]
196pub struct SedolIdentifier {
197 #[serde(rename = "$text")]
198 pub value: String,
199}
200#[derive(
201 Debug,
202 Default,
203 Clone,
204 PartialEq,
205 ::serde::Serialize,
206 ::serde::Deserialize,
207 ::derive_builder::Builder,
208 ::validator::Validate,
209)]
210pub struct SicovamIdentifier {
211 #[serde(rename = "$text")]
212 pub value: String,
213}
214#[derive(
215 Debug,
216 Default,
217 Clone,
218 PartialEq,
219 ::serde::Serialize,
220 ::serde::Deserialize,
221 ::derive_builder::Builder,
222 ::validator::Validate,
223)]
224pub struct Bloomberg2Identifier {
225 #[validate(regex = "BLOOMBERG_2_IDENTIFIER_REGEX")]
226 #[serde(rename = "$text")]
227 pub value: String,
228}
229#[derive(
230 Debug,
231 Default,
232 Clone,
233 PartialEq,
234 ::serde::Serialize,
235 ::serde::Deserialize,
236 ::derive_builder::Builder,
237 ::validator::Validate,
238)]
239pub struct DateAndDateTimeChoiceEnum {
240 #[serde(rename = "Dt", skip_serializing_if = "Option::is_none")]
241 pub dt: Option<IsoDate>,
242 #[serde(rename = "DtTm", skip_serializing_if = "Option::is_none")]
243 pub dt_tm: Option<IsoDateTime>,
244}
245#[derive(
246 Debug,
247 Default,
248 Clone,
249 PartialEq,
250 ::serde::Serialize,
251 ::serde::Deserialize,
252 ::derive_builder::Builder,
253 ::validator::Validate,
254)]
255pub struct DateAndDateTimeChoice {
256 #[serde(flatten)]
257 pub value: DateAndDateTimeChoiceEnum,
258}
259#[derive(
260 Debug,
261 Default,
262 Clone,
263 PartialEq,
264 ::serde::Serialize,
265 ::serde::Deserialize,
266 ::derive_builder::Builder,
267 ::validator::Validate,
268)]
269pub struct PortugueseNccIdentifier {
270 #[validate(regex = "PORTUGUESE_NCC_IDENTIFIER_REGEX")]
271 #[serde(rename = "$text")]
272 pub value: String,
273}
274#[derive(
275 Debug,
276 Default,
277 Clone,
278 PartialEq,
279 ::serde::Serialize,
280 ::serde::Deserialize,
281 ::derive_builder::Builder,
282 ::validator::Validate,
283)]
284pub struct SourceOfCash1ChoiceEnum {
285 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
286 pub cd: Option<SourceOfCash1Code>,
287 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
288 pub prtry: Option<GenericIdentification47>,
289}
290#[derive(
291 Debug,
292 Default,
293 Clone,
294 PartialEq,
295 ::serde::Serialize,
296 ::serde::Deserialize,
297 ::derive_builder::Builder,
298 ::validator::Validate,
299)]
300pub struct SourceOfCash1Choice {
301 #[serde(flatten)]
302 pub value: SourceOfCash1ChoiceEnum,
303}
304#[derive(
305 Debug,
306 Default,
307 Clone,
308 PartialEq,
309 ::serde::Serialize,
310 ::serde::Deserialize,
311 ::derive_builder::Builder,
312 ::validator::Validate,
313)]
314pub struct PaymentInstrument20ChoiceEnum {
315 #[serde(rename = "PmtCardDtls", skip_serializing_if = "Option::is_none")]
316 pub pmt_card_dtls: Option<PaymentCard25>,
317 #[serde(rename = "ChqDtls", skip_serializing_if = "Option::is_none")]
318 pub chq_dtls: Option<Cheque9>,
319 #[serde(rename = "BkrsDrftDtls", skip_serializing_if = "Option::is_none")]
320 pub bkrs_drft_dtls: Option<Cheque9>,
321 #[serde(rename = "CshAcctDtls", skip_serializing_if = "Option::is_none")]
322 pub csh_acct_dtls: Option<InvestmentAccount60>,
323 #[serde(rename = "DrctDbtDtls", skip_serializing_if = "Option::is_none")]
324 pub drct_dbt_dtls: Option<DirectDebitMandate6>,
325 #[serde(rename = "CdtTrfDtls", skip_serializing_if = "Option::is_none")]
326 pub cdt_trf_dtls: Option<CreditTransfer8>,
327}
328#[derive(
329 Debug,
330 Default,
331 Clone,
332 PartialEq,
333 ::serde::Serialize,
334 ::serde::Deserialize,
335 ::derive_builder::Builder,
336 ::validator::Validate,
337)]
338pub struct PaymentInstrument20Choice {
339 #[serde(flatten)]
340 pub value: PaymentInstrument20ChoiceEnum,
341}
342#[derive(
343 Debug,
344 Default,
345 Clone,
346 PartialEq,
347 ::serde::Serialize,
348 ::serde::Deserialize,
349 ::derive_builder::Builder,
350 ::validator::Validate,
351)]
352pub struct AccountSchemeName1ChoiceEnum {
353 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
354 pub cd: Option<ExternalAccountIdentification1Code>,
355 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
356 pub prtry: Option<Max35Text>,
357}
358#[derive(
359 Debug,
360 Default,
361 Clone,
362 PartialEq,
363 ::serde::Serialize,
364 ::serde::Deserialize,
365 ::derive_builder::Builder,
366 ::validator::Validate,
367)]
368pub struct AccountSchemeName1Choice {
369 #[serde(flatten)]
370 pub value: AccountSchemeName1ChoiceEnum,
371}
372#[derive(
373 Debug,
374 Default,
375 Clone,
376 PartialEq,
377 ::serde::Serialize,
378 ::serde::Deserialize,
379 ::derive_builder::Builder,
380 ::validator::Validate,
381)]
382pub struct PaymentTransaction70 {
383 #[serde(rename = "PmtInstrm")]
384 pub pmt_instrm: PaymentInstrument20Choice,
385}
386#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
387pub enum AddressType2Code {
388 #[serde(rename = "ADDR")]
389 Addr,
390 #[serde(rename = "PBOX")]
391 Pbox,
392 #[serde(rename = "HOME")]
393 Home,
394 #[serde(rename = "BIZZ")]
395 Bizz,
396 #[serde(rename = "MLTO")]
397 Mlto,
398 #[serde(rename = "DLVY")]
399 Dlvy,
400 #[default]
401 Unknown,
402}
403#[derive(
404 Debug,
405 Default,
406 Clone,
407 PartialEq,
408 ::serde::Serialize,
409 ::serde::Deserialize,
410 ::derive_builder::Builder,
411 ::validator::Validate,
412)]
413pub struct SmallNetworkIdentifier {
414 #[validate(regex = "SMALL_NETWORK_IDENTIFIER_REGEX")]
415 #[serde(rename = "$text")]
416 pub value: String,
417}
418#[derive(
419 Debug,
420 Default,
421 Clone,
422 PartialEq,
423 ::serde::Serialize,
424 ::serde::Deserialize,
425 ::derive_builder::Builder,
426 ::validator::Validate,
427)]
428pub struct BicfiIdentifier {
429 #[validate(regex = "BICFI_IDENTIFIER_REGEX")]
430 #[serde(rename = "$text")]
431 pub value: String,
432}
433#[derive(
434 Debug,
435 Default,
436 Clone,
437 PartialEq,
438 ::serde::Serialize,
439 ::serde::Deserialize,
440 ::derive_builder::Builder,
441 ::validator::Validate,
442)]
443pub struct NewZealandNccIdentifier {
444 #[validate(regex = "NEW_ZEALAND_NCC_IDENTIFIER_REGEX")]
445 #[serde(rename = "$text")]
446 pub value: String,
447}
448#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
449pub enum TaxType17Code {
450 #[serde(rename = "PROV")]
451 Prov,
452 #[serde(rename = "NATI")]
453 Nati,
454 #[serde(rename = "STAT")]
455 Stat,
456 #[serde(rename = "WITH")]
457 With,
458 #[serde(rename = "KAPA")]
459 Kapa,
460 #[serde(rename = "NKAP")]
461 Nkap,
462 #[serde(rename = "INPO")]
463 Inpo,
464 #[serde(rename = "STAM")]
465 Stam,
466 #[serde(rename = "WTAX")]
467 Wtax,
468 #[serde(rename = "INHT")]
469 Inht,
470 #[serde(rename = "SOSU")]
471 Sosu,
472 #[serde(rename = "CTAX")]
473 Ctax,
474 #[serde(rename = "GIFT")]
475 Gift,
476 #[serde(rename = "COAX")]
477 Coax,
478 #[serde(rename = "EUTR")]
479 Eutr,
480 #[serde(rename = "AKT1")]
481 Akt1,
482 #[serde(rename = "AKT2")]
483 Akt2,
484 #[serde(rename = "ZWIS")]
485 Zwis,
486 #[default]
487 Unknown,
488}
489#[derive(
490 Debug,
491 Default,
492 Clone,
493 PartialEq,
494 ::serde::Serialize,
495 ::serde::Deserialize,
496 ::derive_builder::Builder,
497 ::validator::Validate,
498)]
499pub struct SettlementTransactionCondition30ChoiceEnum {
500 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
501 pub cd: Option<SettlementTransactionCondition11Code>,
502 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
503 pub prtry: Option<GenericIdentification30>,
504}
505#[derive(
506 Debug,
507 Default,
508 Clone,
509 PartialEq,
510 ::serde::Serialize,
511 ::serde::Deserialize,
512 ::derive_builder::Builder,
513 ::validator::Validate,
514)]
515pub struct SettlementTransactionCondition30Choice {
516 #[serde(flatten)]
517 pub value: SettlementTransactionCondition30ChoiceEnum,
518}
519#[derive(
520 Debug,
521 Default,
522 Clone,
523 PartialEq,
524 ::serde::Serialize,
525 ::serde::Deserialize,
526 ::derive_builder::Builder,
527 ::validator::Validate,
528)]
529pub struct AlternateSecurityIdentification7 {
530 #[validate]
531 #[serde(rename = "Id")]
532 pub id: Max35Text,
533 #[serde(rename = "IdSrc")]
534 pub id_src: IdentificationSource1Choice,
535}
536#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
537pub enum TaxationBasis2Code {
538 #[serde(rename = "FLAT")]
539 Flat,
540 #[serde(rename = "PERU")]
541 Peru,
542 #[default]
543 Unknown,
544}
545#[derive(
546 Debug,
547 Default,
548 Clone,
549 PartialEq,
550 ::serde::Serialize,
551 ::serde::Deserialize,
552 ::derive_builder::Builder,
553 ::validator::Validate,
554)]
555pub struct Account22 {
556 #[validate]
557 #[serde(rename = "Id")]
558 pub id: Max35Text,
559 #[serde(rename = "AcctSvcr", skip_serializing_if = "Option::is_none")]
560 pub acct_svcr: Option<PartyIdentification113>,
561}
562#[derive(
563 Debug,
564 Default,
565 Clone,
566 PartialEq,
567 ::serde::Serialize,
568 ::serde::Deserialize,
569 ::derive_builder::Builder,
570 ::validator::Validate,
571)]
572pub struct IdentificationSource1ChoiceEnum {
573 #[serde(rename = "Dmst", skip_serializing_if = "Option::is_none")]
574 pub dmst: Option<CountryCode>,
575 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
576 pub prtry: Option<Max35Text>,
577}
578#[derive(
579 Debug,
580 Default,
581 Clone,
582 PartialEq,
583 ::serde::Serialize,
584 ::serde::Deserialize,
585 ::derive_builder::Builder,
586 ::validator::Validate,
587)]
588pub struct IdentificationSource1Choice {
589 #[serde(flatten)]
590 pub value: IdentificationSource1ChoiceEnum,
591}
592#[derive(
593 Debug,
594 Default,
595 Clone,
596 PartialEq,
597 ::serde::Serialize,
598 ::serde::Deserialize,
599 ::derive_builder::Builder,
600 ::validator::Validate,
601)]
602pub struct DecimalNumber {
603 #[serde(rename = "$text")]
604 pub value: f64,
605}
606#[derive(
607 Debug,
608 Default,
609 Clone,
610 PartialEq,
611 ::serde::Serialize,
612 ::serde::Deserialize,
613 ::derive_builder::Builder,
614 ::validator::Validate,
615)]
616pub struct ExternalAccountIdentification1Code {
617 #[validate(length(min = 1, max = 4,))]
618 #[serde(rename = "$text")]
619 pub value: String,
620}
621#[derive(
622 Debug,
623 Default,
624 Clone,
625 PartialEq,
626 ::serde::Serialize,
627 ::serde::Deserialize,
628 ::derive_builder::Builder,
629 ::validator::Validate,
630)]
631pub struct InformativeTax1 {
632 #[serde(rename = "TaxblIncmPerDvdd", skip_serializing_if = "Option::is_none")]
633 pub taxbl_incm_per_dvdd: Option<ActiveCurrencyAndAmount>,
634 #[serde(rename = "EUCptlGn", skip_serializing_if = "Option::is_none")]
635 pub eu_cptl_gn: Option<EuCapitalGain3Choice>,
636 #[serde(rename = "EUDvddSts", skip_serializing_if = "Option::is_none")]
637 pub eu_dvdd_sts: Option<EuDividendStatusType2Choice>,
638 #[serde(rename = "PctgOfDebtClm", skip_serializing_if = "Option::is_none")]
639 pub pctg_of_debt_clm: Option<PercentageRate>,
640 #[validate(length(min = 0,))]
641 #[serde(rename = "IndvTax", default)]
642 pub indv_tax: Vec<Tax32>,
643}
644#[derive(
645 Debug,
646 Default,
647 Clone,
648 PartialEq,
649 ::serde::Serialize,
650 ::serde::Deserialize,
651 ::derive_builder::Builder,
652 ::validator::Validate,
653)]
654pub struct GenericAccountIdentification1 {
655 #[validate]
656 #[serde(rename = "Id")]
657 pub id: Max34Text,
658 #[serde(rename = "SchmeNm", skip_serializing_if = "Option::is_none")]
659 pub schme_nm: Option<AccountSchemeName1Choice>,
660 #[serde(rename = "Issr", skip_serializing_if = "Option::is_none")]
661 pub issr: Option<Max35Text>,
662}
663#[derive(
664 Debug,
665 Default,
666 Clone,
667 PartialEq,
668 ::serde::Serialize,
669 ::serde::Deserialize,
670 ::derive_builder::Builder,
671 ::validator::Validate,
672)]
673pub struct ActiveCurrencyCode {
674 #[validate(regex = "ACTIVE_CURRENCY_CODE_REGEX")]
675 #[serde(rename = "$text")]
676 pub value: String,
677}
678#[derive(
679 Debug,
680 Default,
681 Clone,
682 PartialEq,
683 ::serde::Serialize,
684 ::serde::Deserialize,
685 ::derive_builder::Builder,
686 ::validator::Validate,
687)]
688pub struct FundOrderType4ChoiceEnum {
689 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
690 pub cd: Option<FundOrderType8Code>,
691 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
692 pub prtry: Option<GenericIdentification47>,
693}
694#[derive(
695 Debug,
696 Default,
697 Clone,
698 PartialEq,
699 ::serde::Serialize,
700 ::serde::Deserialize,
701 ::derive_builder::Builder,
702 ::validator::Validate,
703)]
704pub struct FundOrderType4Choice {
705 #[serde(flatten)]
706 pub value: FundOrderType4ChoiceEnum,
707}
708#[derive(
709 Debug,
710 Default,
711 Clone,
712 PartialEq,
713 ::serde::Serialize,
714 ::serde::Deserialize,
715 ::derive_builder::Builder,
716 ::validator::Validate,
717)]
718pub struct Cheque9 {
719 #[serde(rename = "Nb", skip_serializing_if = "Option::is_none")]
720 pub nb: Option<Max35Text>,
721 #[validate]
722 #[serde(rename = "PyeeId")]
723 pub pyee_id: PartyIdentification113,
724 #[serde(rename = "DrweeId", skip_serializing_if = "Option::is_none")]
725 pub drwee_id: Option<FinancialInstitutionIdentification10>,
726 #[serde(rename = "DrwrId", skip_serializing_if = "Option::is_none")]
727 pub drwr_id: Option<PartyIdentification113>,
728}
729#[derive(
730 Debug,
731 Default,
732 Clone,
733 PartialEq,
734 ::serde::Serialize,
735 ::serde::Deserialize,
736 ::derive_builder::Builder,
737 ::validator::Validate,
738)]
739pub struct PartyIdentification90ChoiceEnum {
740 #[serde(rename = "NmAndAdr", skip_serializing_if = "Option::is_none")]
741 pub nm_and_adr: Option<NameAndAddress5>,
742 #[serde(rename = "AnyBIC", skip_serializing_if = "Option::is_none")]
743 pub any_bic: Option<AnyBicIdentifier>,
744 #[serde(rename = "PrtryId", skip_serializing_if = "Option::is_none")]
745 pub prtry_id: Option<GenericIdentification1>,
746}
747#[derive(
748 Debug,
749 Default,
750 Clone,
751 PartialEq,
752 ::serde::Serialize,
753 ::serde::Deserialize,
754 ::derive_builder::Builder,
755 ::validator::Validate,
756)]
757pub struct PartyIdentification90Choice {
758 #[serde(flatten)]
759 pub value: PartyIdentification90ChoiceEnum,
760}
761#[derive(
762 Debug,
763 Default,
764 Clone,
765 PartialEq,
766 ::serde::Serialize,
767 ::serde::Deserialize,
768 ::derive_builder::Builder,
769 ::validator::Validate,
770)]
771pub struct CanadianPaymentsArnIdentifier {
772 #[validate(regex = "CANADIAN_PAYMENTS_ARN_IDENTIFIER_REGEX")]
773 #[serde(rename = "$text")]
774 pub value: String,
775}
776#[derive(
777 Debug,
778 Default,
779 Clone,
780 PartialEq,
781 ::serde::Serialize,
782 ::serde::Deserialize,
783 ::derive_builder::Builder,
784 ::validator::Validate,
785)]
786pub struct ProfitAndLoss2ChoiceEnum {
787 #[serde(rename = "Loss", skip_serializing_if = "Option::is_none")]
788 pub loss: Option<ActiveCurrencyAndAmount>,
789 #[serde(rename = "Prft", skip_serializing_if = "Option::is_none")]
790 pub prft: Option<ActiveCurrencyAndAmount>,
791}
792#[derive(
793 Debug,
794 Default,
795 Clone,
796 PartialEq,
797 ::serde::Serialize,
798 ::serde::Deserialize,
799 ::derive_builder::Builder,
800 ::validator::Validate,
801)]
802pub struct ProfitAndLoss2Choice {
803 #[serde(flatten)]
804 pub value: ProfitAndLoss2ChoiceEnum,
805}
806#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
807pub enum SafekeepingPlace2Code {
808 #[serde(rename = "SHHE")]
809 Shhe,
810 #[serde(rename = "ALLP")]
811 Allp,
812 #[default]
813 Unknown,
814}
815#[derive(
816 Debug,
817 Default,
818 Clone,
819 PartialEq,
820 ::serde::Serialize,
821 ::serde::Deserialize,
822 ::derive_builder::Builder,
823 ::validator::Validate,
824)]
825pub struct Series1 {
826 #[serde(rename = "SrsDt", skip_serializing_if = "Option::is_none")]
827 pub srs_dt: Option<DateFormat42Choice>,
828 #[serde(rename = "SrsNm", skip_serializing_if = "Option::is_none")]
829 pub srs_nm: Option<Max35Text>,
830}
831#[derive(
832 Debug,
833 Default,
834 Clone,
835 PartialEq,
836 ::serde::Serialize,
837 ::serde::Deserialize,
838 ::derive_builder::Builder,
839 ::validator::Validate,
840)]
841pub struct ActiveCurrencyAndAmountSimpleType {
842 #[validate(range(min = 0,))]
843 #[serde(rename = "$text")]
844 pub value: f64,
845}
846#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
847pub enum BestExecution1Code {
848 #[serde(rename = "BTEX")]
849 Btex,
850 #[default]
851 Unknown,
852}
853#[derive(
854 Debug,
855 Default,
856 Clone,
857 PartialEq,
858 ::serde::Serialize,
859 ::serde::Deserialize,
860 ::derive_builder::Builder,
861 ::validator::Validate,
862)]
863pub struct TaxType3ChoiceEnum {
864 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
865 pub prtry: Option<GenericIdentification47>,
866 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
867 pub cd: Option<TaxType17Code>,
868}
869#[derive(
870 Debug,
871 Default,
872 Clone,
873 PartialEq,
874 ::serde::Serialize,
875 ::serde::Deserialize,
876 ::derive_builder::Builder,
877 ::validator::Validate,
878)]
879pub struct TaxType3Choice {
880 #[serde(flatten)]
881 pub value: TaxType3ChoiceEnum,
882}
883#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
884pub enum EuCapitalGain2Code {
885 #[serde(rename = "EUSI")]
886 Eusi,
887 #[serde(rename = "EUSO")]
888 Euso,
889 #[serde(rename = "UKWN")]
890 Ukwn,
891 #[default]
892 Unknown,
893}
894#[derive(
895 Debug,
896 Default,
897 Clone,
898 PartialEq,
899 ::serde::Serialize,
900 ::serde::Deserialize,
901 ::derive_builder::Builder,
902 ::validator::Validate,
903)]
904pub struct DateFormat42ChoiceEnum {
905 #[serde(rename = "YrMnth", skip_serializing_if = "Option::is_none")]
906 pub yr_mnth: Option<IsoYearMonth>,
907 #[serde(rename = "YrMnthDay", skip_serializing_if = "Option::is_none")]
908 pub yr_mnth_day: Option<IsoDate>,
909}
910#[derive(
911 Debug,
912 Default,
913 Clone,
914 PartialEq,
915 ::serde::Serialize,
916 ::serde::Deserialize,
917 ::derive_builder::Builder,
918 ::validator::Validate,
919)]
920pub struct DateFormat42Choice {
921 #[serde(flatten)]
922 pub value: DateFormat42ChoiceEnum,
923}
924#[derive(
925 Debug,
926 Default,
927 Clone,
928 PartialEq,
929 ::serde::Serialize,
930 ::serde::Deserialize,
931 ::derive_builder::Builder,
932 ::validator::Validate,
933)]
934pub struct EuroclearClearstreamIdentifier {
935 #[validate(length(min = 1, max = 12,))]
936 #[serde(rename = "$text")]
937 pub value: String,
938}
939#[derive(
940 Debug,
941 Default,
942 Clone,
943 PartialEq,
944 ::serde::Serialize,
945 ::serde::Deserialize,
946 ::derive_builder::Builder,
947 ::validator::Validate,
948)]
949#[serde(rename = "Document")]
950pub struct Document {
951 #[validate]
952 #[serde(rename = "SbcptOrdrConf")]
953 pub sbcpt_ordr_conf: SubscriptionOrderConfirmationV04,
954 #[serde(rename = "@xmlns", default = "namespace")]
955 pub xmlns: String,
956}
957#[derive(
958 Debug,
959 Default,
960 Clone,
961 PartialEq,
962 ::serde::Serialize,
963 ::serde::Deserialize,
964 ::derive_builder::Builder,
965 ::validator::Validate,
966)]
967pub struct AnyBicIdentifier {
968 #[validate(regex = "ANY_BIC_IDENTIFIER_REGEX")]
969 #[serde(rename = "$text")]
970 pub value: String,
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 ActiveOrHistoricCurrencyCode {
983 #[validate(regex = "ACTIVE_OR_HISTORIC_CURRENCY_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 Extension1 {
998 #[validate]
999 #[serde(rename = "PlcAndNm")]
1000 pub plc_and_nm: Max350Text,
1001 #[validate]
1002 #[serde(rename = "Txt")]
1003 pub txt: Max350Text,
1004}
1005#[derive(
1006 Debug,
1007 Default,
1008 Clone,
1009 PartialEq,
1010 ::serde::Serialize,
1011 ::serde::Deserialize,
1012 ::derive_builder::Builder,
1013 ::validator::Validate,
1014)]
1015pub struct GenericIdentification1 {
1016 #[validate]
1017 #[serde(rename = "Id")]
1018 pub id: Max35Text,
1019 #[serde(rename = "SchmeNm", skip_serializing_if = "Option::is_none")]
1020 pub schme_nm: Option<Max35Text>,
1021 #[serde(rename = "Issr", skip_serializing_if = "Option::is_none")]
1022 pub issr: Option<Max35Text>,
1023}
1024#[derive(
1025 Debug,
1026 Default,
1027 Clone,
1028 PartialEq,
1029 ::serde::Serialize,
1030 ::serde::Deserialize,
1031 ::derive_builder::Builder,
1032 ::validator::Validate,
1033)]
1034pub struct CusipIdentifier {
1035 #[serde(rename = "$text")]
1036 pub value: String,
1037}
1038#[derive(
1039 Debug,
1040 Default,
1041 Clone,
1042 PartialEq,
1043 ::serde::Serialize,
1044 ::serde::Deserialize,
1045 ::derive_builder::Builder,
1046 ::validator::Validate,
1047)]
1048pub struct ExtensiveBranchNetworkIdentifier {
1049 #[validate(regex = "EXTENSIVE_BRANCH_NETWORK_IDENTIFIER_REGEX")]
1050 #[serde(rename = "$text")]
1051 pub value: String,
1052}
1053#[derive(
1054 Debug,
1055 Default,
1056 Clone,
1057 PartialEq,
1058 ::serde::Serialize,
1059 ::serde::Deserialize,
1060 ::derive_builder::Builder,
1061 ::validator::Validate,
1062)]
1063pub struct Max16Text {
1064 #[validate(length(min = 1, max = 16,))]
1065 #[serde(rename = "$text")]
1066 pub value: String,
1067}
1068#[derive(
1069 Debug,
1070 Default,
1071 Clone,
1072 PartialEq,
1073 ::serde::Serialize,
1074 ::serde::Deserialize,
1075 ::derive_builder::Builder,
1076 ::validator::Validate,
1077)]
1078pub struct MicIdentifier {
1079 #[validate(regex = "MIC_IDENTIFIER_REGEX")]
1080 #[serde(rename = "$text")]
1081 pub value: String,
1082}
1083#[derive(
1084 Debug,
1085 Default,
1086 Clone,
1087 PartialEq,
1088 ::serde::Serialize,
1089 ::serde::Deserialize,
1090 ::derive_builder::Builder,
1091 ::validator::Validate,
1092)]
1093pub struct UkDomesticSortCodeIdentifier {
1094 #[validate(regex = "UK_DOMESTIC_SORT_CODE_IDENTIFIER_REGEX")]
1095 #[serde(rename = "$text")]
1096 pub value: String,
1097}
1098#[derive(
1099 Debug,
1100 Default,
1101 Clone,
1102 PartialEq,
1103 ::serde::Serialize,
1104 ::serde::Deserialize,
1105 ::derive_builder::Builder,
1106 ::validator::Validate,
1107)]
1108pub struct ActiveCurrencyAnd13DecimalAmount {
1109 #[serde(rename = "ActiveCurrencyAnd13DecimalAmount")]
1110 pub value: ActiveCurrencyAnd13DecimalAmountSimpleType,
1111 #[serde(rename = "@Ccy")]
1112 pub ccy: ActiveCurrencyCode,
1113}
1114#[derive(
1115 Debug,
1116 Default,
1117 Clone,
1118 PartialEq,
1119 ::serde::Serialize,
1120 ::serde::Deserialize,
1121 ::derive_builder::Builder,
1122 ::validator::Validate,
1123)]
1124pub struct ActiveCurrencyAnd13DecimalAmountSimpleType {
1125 #[validate(range(min = 0,))]
1126 #[serde(rename = "$text")]
1127 pub value: f64,
1128}
1129#[derive(
1130 Debug,
1131 Default,
1132 Clone,
1133 PartialEq,
1134 ::serde::Serialize,
1135 ::serde::Deserialize,
1136 ::derive_builder::Builder,
1137 ::validator::Validate,
1138)]
1139pub struct SignatureType1ChoiceEnum {
1140 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
1141 pub cd: Option<SignatureType2Code>,
1142 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
1143 pub prtry: Option<GenericIdentification47>,
1144}
1145#[derive(
1146 Debug,
1147 Default,
1148 Clone,
1149 PartialEq,
1150 ::serde::Serialize,
1151 ::serde::Deserialize,
1152 ::derive_builder::Builder,
1153 ::validator::Validate,
1154)]
1155pub struct SignatureType1Choice {
1156 #[serde(flatten)]
1157 pub value: SignatureType1ChoiceEnum,
1158}
1159#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1160pub enum InvestmentFundRole2Code {
1161 #[serde(rename = "FMCO")]
1162 Fmco,
1163 #[serde(rename = "REGI")]
1164 Regi,
1165 #[serde(rename = "TRAG")]
1166 Trag,
1167 #[serde(rename = "INTR")]
1168 Intr,
1169 #[serde(rename = "DIST")]
1170 Dist,
1171 #[serde(rename = "CONC")]
1172 Conc,
1173 #[serde(rename = "UCL1")]
1174 Ucl1,
1175 #[serde(rename = "UCL2")]
1176 Ucl2,
1177 #[serde(rename = "TRAN")]
1178 Tran,
1179 #[default]
1180 Unknown,
1181}
1182#[derive(
1183 Debug,
1184 Default,
1185 Clone,
1186 PartialEq,
1187 ::serde::Serialize,
1188 ::serde::Deserialize,
1189 ::derive_builder::Builder,
1190 ::validator::Validate,
1191)]
1192pub struct DeliveringPartiesAndAccount16 {
1193 #[serde(rename = "DlvrrsCtdnDtls", skip_serializing_if = "Option::is_none")]
1194 pub dlvrrs_ctdn_dtls: Option<PartyIdentificationAndAccount147>,
1195 #[serde(rename = "DlvrrsIntrmy1Dtls", skip_serializing_if = "Option::is_none")]
1196 pub dlvrrs_intrmy_1_dtls: Option<PartyIdentificationAndAccount147>,
1197 #[serde(rename = "DlvrrsIntrmy2Dtls", skip_serializing_if = "Option::is_none")]
1198 pub dlvrrs_intrmy_2_dtls: Option<PartyIdentificationAndAccount147>,
1199 #[validate]
1200 #[serde(rename = "DlvrgAgtDtls")]
1201 pub dlvrg_agt_dtls: PartyIdentificationAndAccount147,
1202}
1203#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1204pub enum SignatureType2Code {
1205 #[serde(rename = "DIGI")]
1206 Digi,
1207 #[serde(rename = "ELEC")]
1208 Elec,
1209 #[serde(rename = "NONE")]
1210 None,
1211 #[serde(rename = "ORIG")]
1212 Orig,
1213 #[default]
1214 Unknown,
1215}
1216#[derive(
1217 Debug,
1218 Default,
1219 Clone,
1220 PartialEq,
1221 ::serde::Serialize,
1222 ::serde::Deserialize,
1223 ::derive_builder::Builder,
1224 ::validator::Validate,
1225)]
1226pub struct SubscriptionExecution13 {
1227 #[validate]
1228 #[serde(rename = "OrdrRef")]
1229 pub ordr_ref: Max35Text,
1230 #[serde(rename = "ClntRef", skip_serializing_if = "Option::is_none")]
1231 pub clnt_ref: Option<Max35Text>,
1232 #[validate]
1233 #[serde(rename = "DealRef")]
1234 pub deal_ref: Max35Text,
1235 #[validate(length(min = 0, max = 10,))]
1236 #[serde(rename = "OrdrTp", default)]
1237 pub ordr_tp: Vec<FundOrderType4Choice>,
1238 #[validate]
1239 #[serde(rename = "FinInstrmDtls")]
1240 pub fin_instrm_dtls: FinancialInstrument57,
1241 #[serde(rename = "SubAcctForHldg", skip_serializing_if = "Option::is_none")]
1242 pub sub_acct_for_hldg: Option<SubAccount6>,
1243 #[validate]
1244 #[serde(rename = "UnitsNb")]
1245 pub units_nb: DecimalNumber,
1246 #[serde(rename = "Rndg", skip_serializing_if = "Option::is_none")]
1247 pub rndg: Option<RoundingDirection2Code>,
1248 #[serde(rename = "NetAmt", skip_serializing_if = "Option::is_none")]
1249 pub net_amt: Option<ActiveCurrencyAndAmount>,
1250 #[serde(rename = "GrssAmt", skip_serializing_if = "Option::is_none")]
1251 pub grss_amt: Option<ActiveCurrencyAndAmount>,
1252 #[serde(rename = "TradDtTm")]
1253 pub trad_dt_tm: DateAndDateTimeChoice,
1254 #[validate]
1255 #[serde(rename = "DealgPricDtls")]
1256 pub dealg_pric_dtls: UnitPrice22,
1257 #[validate(length(min = 0, max = 2,))]
1258 #[serde(rename = "InftvPricDtls", default)]
1259 pub inftv_pric_dtls: Vec<UnitPrice22>,
1260 #[validate]
1261 #[serde(rename = "SttlmAmt")]
1262 pub sttlm_amt: ActiveCurrencyAndAmount,
1263 #[serde(rename = "CshSttlmDt", skip_serializing_if = "Option::is_none")]
1264 pub csh_sttlm_dt: Option<IsoDate>,
1265 #[serde(rename = "SttlmMtd", skip_serializing_if = "Option::is_none")]
1266 pub sttlm_mtd: Option<DeliveryReceiptType2Code>,
1267 #[validate]
1268 #[serde(rename = "PrtlyExctdInd")]
1269 pub prtly_exctd_ind: YesNoIndicator,
1270 #[serde(rename = "BestExctn", skip_serializing_if = "Option::is_none")]
1271 pub best_exctn: Option<BestExecution1Code>,
1272 #[validate]
1273 #[serde(rename = "CumDvddInd")]
1274 pub cum_dvdd_ind: YesNoIndicator,
1275 #[serde(rename = "IntrmPrftAmt", skip_serializing_if = "Option::is_none")]
1276 pub intrm_prft_amt: Option<ProfitAndLoss2Choice>,
1277 #[validate(length(min = 0,))]
1278 #[serde(rename = "FXDtls", default)]
1279 pub fx_dtls: Vec<ForeignExchangeTerms33>,
1280 #[serde(rename = "IncmPref", skip_serializing_if = "Option::is_none")]
1281 pub incm_pref: Option<IncomePreference1Code>,
1282 #[serde(rename = "LttrInttRef", skip_serializing_if = "Option::is_none")]
1283 pub lttr_intt_ref: Option<Max35Text>,
1284 #[serde(rename = "AcmltnRghtRef", skip_serializing_if = "Option::is_none")]
1285 pub acmltn_rght_ref: Option<Max35Text>,
1286 #[serde(rename = "TxOvrhd", skip_serializing_if = "Option::is_none")]
1287 pub tx_ovrhd: Option<TotalFeesAndTaxes40>,
1288 #[serde(rename = "InftvTaxDtls", skip_serializing_if = "Option::is_none")]
1289 pub inftv_tax_dtls: Option<InformativeTax1>,
1290 #[serde(rename = "SttlmAndCtdyDtls", skip_serializing_if = "Option::is_none")]
1291 pub sttlm_and_ctdy_dtls: Option<FundSettlementParameters12>,
1292 #[validate]
1293 #[serde(rename = "PhysDlvryInd")]
1294 pub phys_dlvry_ind: YesNoIndicator,
1295 #[serde(rename = "PhysDlvryDtls", skip_serializing_if = "Option::is_none")]
1296 pub phys_dlvry_dtls: Option<DeliveryParameters3>,
1297 #[serde(rename = "ReqdSttlmCcy", skip_serializing_if = "Option::is_none")]
1298 pub reqd_sttlm_ccy: Option<ActiveCurrencyCode>,
1299 #[serde(rename = "ReqdNAVCcy", skip_serializing_if = "Option::is_none")]
1300 pub reqd_nav_ccy: Option<ActiveOrHistoricCurrencyCode>,
1301 #[serde(rename = "Rfnd", skip_serializing_if = "Option::is_none")]
1302 pub rfnd: Option<ActiveCurrencyAndAmount>,
1303 #[serde(rename = "SbcptIntrst", skip_serializing_if = "Option::is_none")]
1304 pub sbcpt_intrst: Option<ActiveCurrencyAndAmount>,
1305 #[serde(rename = "CshSttlmDtls", skip_serializing_if = "Option::is_none")]
1306 pub csh_sttlm_dtls: Option<PaymentTransaction70>,
1307 #[serde(rename = "NonStdSttlmInf", skip_serializing_if = "Option::is_none")]
1308 pub non_std_sttlm_inf: Option<Max350Text>,
1309 #[serde(rename = "PrtlSttlmOfUnits", skip_serializing_if = "Option::is_none")]
1310 pub prtl_sttlm_of_units: Option<PercentageRate>,
1311 #[serde(rename = "PrtlSttlmOfCsh", skip_serializing_if = "Option::is_none")]
1312 pub prtl_sttlm_of_csh: Option<PercentageRate>,
1313 #[validate(length(min = 0, max = 4,))]
1314 #[serde(rename = "StffClntBrkdwn", default)]
1315 pub stff_clnt_brkdwn: Vec<InvestmentFundsOrderBreakdown2>,
1316 #[serde(rename = "FinAdvc", skip_serializing_if = "Option::is_none")]
1317 pub fin_advc: Option<FinancialAdvice1Code>,
1318 #[serde(rename = "NgtdTrad", skip_serializing_if = "Option::is_none")]
1319 pub ngtd_trad: Option<NegotiatedTrade1Code>,
1320 #[serde(rename = "LateRpt", skip_serializing_if = "Option::is_none")]
1321 pub late_rpt: Option<LateReport1Code>,
1322 #[validate(length(min = 0, max = 10,))]
1323 #[serde(rename = "RltdPtyDtls", default)]
1324 pub rltd_pty_dtls: Vec<Intermediary39>,
1325 #[serde(rename = "Equlstn", skip_serializing_if = "Option::is_none")]
1326 pub equlstn: Option<Equalisation1>,
1327 #[validate(length(min = 0,))]
1328 #[serde(rename = "SrcOfCsh", default)]
1329 pub src_of_csh: Vec<SourceOfCash1Choice>,
1330 #[serde(rename = "CstmrCndctClssfctn", skip_serializing_if = "Option::is_none")]
1331 pub cstmr_cndct_clssfctn: Option<CustomerConductClassification1Choice>,
1332 #[serde(rename = "TxChanlTp", skip_serializing_if = "Option::is_none")]
1333 pub tx_chanl_tp: Option<TransactionChannelType1Choice>,
1334 #[serde(rename = "SgntrTp", skip_serializing_if = "Option::is_none")]
1335 pub sgntr_tp: Option<SignatureType1Choice>,
1336 #[serde(rename = "OrdrWvrDtls", skip_serializing_if = "Option::is_none")]
1337 pub ordr_wvr_dtls: Option<OrderWaiver1>,
1338}
1339#[derive(
1340 Debug,
1341 Default,
1342 Clone,
1343 PartialEq,
1344 ::serde::Serialize,
1345 ::serde::Deserialize,
1346 ::derive_builder::Builder,
1347 ::validator::Validate,
1348)]
1349pub struct Tax31 {
1350 #[serde(rename = "Tp")]
1351 pub tp: TaxType3Choice,
1352 #[validate]
1353 #[serde(rename = "ApldAmt")]
1354 pub apld_amt: ActiveCurrencyAndAmount,
1355 #[serde(rename = "ApldRate", skip_serializing_if = "Option::is_none")]
1356 pub apld_rate: Option<PercentageRate>,
1357 #[serde(rename = "Ctry", skip_serializing_if = "Option::is_none")]
1358 pub ctry: Option<CountryCode>,
1359 #[serde(rename = "RcptId", skip_serializing_if = "Option::is_none")]
1360 pub rcpt_id: Option<PartyIdentification113>,
1361 #[serde(rename = "TaxClctnDtls", skip_serializing_if = "Option::is_none")]
1362 pub tax_clctn_dtls: Option<TaxCalculationInformation10>,
1363}
1364#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1365pub enum TaxableIncomePerShareCalculated2Code {
1366 #[serde(rename = "TSIY")]
1367 Tsiy,
1368 #[serde(rename = "TSIN")]
1369 Tsin,
1370 #[serde(rename = "UKWN")]
1371 Ukwn,
1372 #[default]
1373 Unknown,
1374}
1375#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1376pub enum CardType1Code {
1377 #[serde(rename = "CRDT")]
1378 Crdt,
1379 #[serde(rename = "DBIT")]
1380 Dbit,
1381 #[default]
1382 Unknown,
1383}
1384#[derive(
1385 Debug,
1386 Default,
1387 Clone,
1388 PartialEq,
1389 ::serde::Serialize,
1390 ::serde::Deserialize,
1391 ::derive_builder::Builder,
1392 ::validator::Validate,
1393)]
1394pub struct AccountIdentification4ChoiceEnum {
1395 #[serde(rename = "IBAN", skip_serializing_if = "Option::is_none")]
1396 pub iban: Option<Iban2007Identifier>,
1397 #[serde(rename = "Othr", skip_serializing_if = "Option::is_none")]
1398 pub othr: Option<GenericAccountIdentification1>,
1399}
1400#[derive(
1401 Debug,
1402 Default,
1403 Clone,
1404 PartialEq,
1405 ::serde::Serialize,
1406 ::serde::Deserialize,
1407 ::derive_builder::Builder,
1408 ::validator::Validate,
1409)]
1410pub struct AccountIdentification4Choice {
1411 #[serde(flatten)]
1412 pub value: AccountIdentification4ChoiceEnum,
1413}
1414#[derive(
1415 Debug,
1416 Default,
1417 Clone,
1418 PartialEq,
1419 ::serde::Serialize,
1420 ::serde::Deserialize,
1421 ::derive_builder::Builder,
1422 ::validator::Validate,
1423)]
1424pub struct PlaceOfTradeIdentification1ChoiceEnum {
1425 #[serde(rename = "Xchg", skip_serializing_if = "Option::is_none")]
1426 pub xchg: Option<MicIdentifier>,
1427 #[serde(rename = "Pty", skip_serializing_if = "Option::is_none")]
1428 pub pty: Option<AnyBicIdentifier>,
1429 #[serde(rename = "Ctry", skip_serializing_if = "Option::is_none")]
1430 pub ctry: Option<CountryCode>,
1431 #[serde(rename = "OverTheCntr", skip_serializing_if = "Option::is_none")]
1432 pub over_the_cntr: Option<Max35Text>,
1433}
1434#[derive(
1435 Debug,
1436 Default,
1437 Clone,
1438 PartialEq,
1439 ::serde::Serialize,
1440 ::serde::Deserialize,
1441 ::derive_builder::Builder,
1442 ::validator::Validate,
1443)]
1444pub struct PlaceOfTradeIdentification1Choice {
1445 #[serde(flatten)]
1446 pub value: PlaceOfTradeIdentification1ChoiceEnum,
1447}
1448#[derive(
1449 Debug,
1450 Default,
1451 Clone,
1452 PartialEq,
1453 ::serde::Serialize,
1454 ::serde::Deserialize,
1455 ::derive_builder::Builder,
1456 ::validator::Validate,
1457)]
1458pub struct SafekeepingPlaceTypeAndText6 {
1459 #[serde(rename = "SfkpgPlcTp")]
1460 pub sfkpg_plc_tp: SafekeepingPlace2Code,
1461 #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
1462 pub id: Option<Max35Text>,
1463}
1464#[derive(
1465 Debug,
1466 Default,
1467 Clone,
1468 PartialEq,
1469 ::serde::Serialize,
1470 ::serde::Deserialize,
1471 ::derive_builder::Builder,
1472 ::validator::Validate,
1473)]
1474pub struct SubscriptionOrderConfirmationV04 {
1475 #[validate]
1476 #[serde(rename = "MsgId")]
1477 pub msg_id: MessageIdentification1,
1478 #[serde(rename = "PoolRef", skip_serializing_if = "Option::is_none")]
1479 pub pool_ref: Option<AdditionalReference9>,
1480 #[validate(length(min = 0,))]
1481 #[serde(rename = "PrvsRef", default)]
1482 pub prvs_ref: Vec<AdditionalReference8>,
1483 #[serde(rename = "RltdRef", skip_serializing_if = "Option::is_none")]
1484 pub rltd_ref: Option<AdditionalReference8>,
1485 #[validate]
1486 #[serde(rename = "MltplExctnDtls")]
1487 pub mltpl_exctn_dtls: SubscriptionMultipleExecution5,
1488 #[serde(rename = "CpyDtls", skip_serializing_if = "Option::is_none")]
1489 pub cpy_dtls: Option<CopyInformation4>,
1490 #[validate(length(min = 0,))]
1491 #[serde(rename = "Xtnsn", default)]
1492 pub xtnsn: Vec<Extension1>,
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 PartyIdentification113 {
1505 #[serde(rename = "Pty")]
1506 pub pty: PartyIdentification90Choice,
1507 #[serde(rename = "LEI", skip_serializing_if = "Option::is_none")]
1508 pub lei: Option<LeiIdentifier>,
1509}
1510#[derive(
1511 Debug,
1512 Default,
1513 Clone,
1514 PartialEq,
1515 ::serde::Serialize,
1516 ::serde::Deserialize,
1517 ::derive_builder::Builder,
1518 ::validator::Validate,
1519)]
1520pub struct InvestmentAccountType1ChoiceEnum {
1521 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
1522 pub cd: Option<FundCashAccount2Code>,
1523 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
1524 pub prtry: Option<GenericIdentification47>,
1525}
1526#[derive(
1527 Debug,
1528 Default,
1529 Clone,
1530 PartialEq,
1531 ::serde::Serialize,
1532 ::serde::Deserialize,
1533 ::derive_builder::Builder,
1534 ::validator::Validate,
1535)]
1536pub struct InvestmentAccountType1Choice {
1537 #[serde(flatten)]
1538 pub value: InvestmentAccountType1ChoiceEnum,
1539}
1540#[derive(
1541 Debug,
1542 Default,
1543 Clone,
1544 PartialEq,
1545 ::serde::Serialize,
1546 ::serde::Deserialize,
1547 ::derive_builder::Builder,
1548 ::validator::Validate,
1549)]
1550pub struct GenericIdentification164 {
1551 #[validate]
1552 #[serde(rename = "Id")]
1553 pub id: Max35Text,
1554 #[serde(rename = "IdTp")]
1555 pub id_tp: OtherIdentification3Choice,
1556 #[serde(rename = "Issr", skip_serializing_if = "Option::is_none")]
1557 pub issr: Option<Max35Text>,
1558}
1559#[derive(
1560 Debug,
1561 Default,
1562 Clone,
1563 PartialEq,
1564 ::serde::Serialize,
1565 ::serde::Deserialize,
1566 ::derive_builder::Builder,
1567 ::validator::Validate,
1568)]
1569pub struct CustomerConductClassification1ChoiceEnum {
1570 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
1571 pub cd: Option<ConductClassification1Code>,
1572 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
1573 pub prtry: Option<GenericIdentification47>,
1574}
1575#[derive(
1576 Debug,
1577 Default,
1578 Clone,
1579 PartialEq,
1580 ::serde::Serialize,
1581 ::serde::Deserialize,
1582 ::derive_builder::Builder,
1583 ::validator::Validate,
1584)]
1585pub struct CustomerConductClassification1Choice {
1586 #[serde(flatten)]
1587 pub value: CustomerConductClassification1ChoiceEnum,
1588}
1589#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1590pub enum ConductClassification1Code {
1591 #[serde(rename = "NSTA")]
1592 Nsta,
1593 #[serde(rename = "RCLT")]
1594 Rclt,
1595 #[serde(rename = "STAN")]
1596 Stan,
1597 #[default]
1598 Unknown,
1599}
1600#[derive(
1601 Debug,
1602 Default,
1603 Clone,
1604 PartialEq,
1605 ::serde::Serialize,
1606 ::serde::Deserialize,
1607 ::derive_builder::Builder,
1608 ::validator::Validate,
1609)]
1610pub struct ForeignExchangeTerms33 {
1611 #[serde(rename = "ToAmt", skip_serializing_if = "Option::is_none")]
1612 pub to_amt: Option<ActiveCurrencyAndAmount>,
1613 #[serde(rename = "FrAmt", skip_serializing_if = "Option::is_none")]
1614 pub fr_amt: Option<ActiveCurrencyAndAmount>,
1615 #[serde(rename = "UnitCcy")]
1616 pub unit_ccy: ActiveCurrencyCode,
1617 #[serde(rename = "QtdCcy")]
1618 pub qtd_ccy: ActiveCurrencyCode,
1619 #[validate]
1620 #[serde(rename = "XchgRate")]
1621 pub xchg_rate: BaseOneRate,
1622 #[serde(rename = "QtnDt", skip_serializing_if = "Option::is_none")]
1623 pub qtn_dt: Option<IsoDateTime>,
1624 #[serde(rename = "QtgInstn", skip_serializing_if = "Option::is_none")]
1625 pub qtg_instn: Option<PartyIdentification113>,
1626}
1627#[derive(
1628 Debug,
1629 Default,
1630 Clone,
1631 PartialEq,
1632 ::serde::Serialize,
1633 ::serde::Deserialize,
1634 ::derive_builder::Builder,
1635 ::validator::Validate,
1636)]
1637pub struct InvestmentFundsOrderBreakdown2 {
1638 #[serde(rename = "OrdrBrkdwnTp")]
1639 pub ordr_brkdwn_tp: OrderBreakdownType1Choice,
1640 #[validate]
1641 #[serde(rename = "Amt")]
1642 pub amt: ActiveCurrencyAndAmount,
1643}
1644#[derive(
1645 Debug,
1646 Default,
1647 Clone,
1648 PartialEq,
1649 ::serde::Serialize,
1650 ::serde::Deserialize,
1651 ::derive_builder::Builder,
1652 ::validator::Validate,
1653)]
1654pub struct InvestmentAccount58 {
1655 #[validate]
1656 #[serde(rename = "AcctId")]
1657 pub acct_id: Max35Text,
1658 #[serde(rename = "AcctNm", skip_serializing_if = "Option::is_none")]
1659 pub acct_nm: Option<Max35Text>,
1660 #[serde(rename = "AcctDsgnt", skip_serializing_if = "Option::is_none")]
1661 pub acct_dsgnt: Option<Max35Text>,
1662 #[validate(length(min = 0,))]
1663 #[serde(rename = "OwnrId", default)]
1664 pub ownr_id: Vec<PartyIdentification113>,
1665 #[serde(rename = "AcctSvcr", skip_serializing_if = "Option::is_none")]
1666 pub acct_svcr: Option<PartyIdentification113>,
1667 #[serde(rename = "OrdrOrgtrElgblty", skip_serializing_if = "Option::is_none")]
1668 pub ordr_orgtr_elgblty: Option<OrderOriginatorEligibility1Code>,
1669 #[serde(rename = "SubAcctDtls", skip_serializing_if = "Option::is_none")]
1670 pub sub_acct_dtls: Option<SubAccount6>,
1671}
1672#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1673pub enum NegotiatedTrade1Code {
1674 #[serde(rename = "NEGO")]
1675 Nego,
1676 #[serde(rename = "NNGO")]
1677 Nngo,
1678 #[serde(rename = "UNKW")]
1679 Unkw,
1680 #[default]
1681 Unknown,
1682}
1683#[derive(
1684 Debug,
1685 Default,
1686 Clone,
1687 PartialEq,
1688 ::serde::Serialize,
1689 ::serde::Deserialize,
1690 ::derive_builder::Builder,
1691 ::validator::Validate,
1692)]
1693pub struct EuCapitalGain3ChoiceEnum {
1694 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
1695 pub prtry: Option<GenericIdentification47>,
1696 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
1697 pub cd: Option<EuCapitalGain2Code>,
1698}
1699#[derive(
1700 Debug,
1701 Default,
1702 Clone,
1703 PartialEq,
1704 ::serde::Serialize,
1705 ::serde::Deserialize,
1706 ::derive_builder::Builder,
1707 ::validator::Validate,
1708)]
1709pub struct EuCapitalGain3Choice {
1710 #[serde(flatten)]
1711 pub value: EuCapitalGain3ChoiceEnum,
1712}
1713#[derive(
1714 Debug,
1715 Default,
1716 Clone,
1717 PartialEq,
1718 ::serde::Serialize,
1719 ::serde::Deserialize,
1720 ::derive_builder::Builder,
1721 ::validator::Validate,
1722)]
1723pub struct PaymentCard25 {
1724 #[serde(rename = "Tp")]
1725 pub tp: CardType1Code,
1726 #[validate]
1727 #[serde(rename = "Nb")]
1728 pub nb: Max35Text,
1729 #[validate]
1730 #[serde(rename = "HldrNm")]
1731 pub hldr_nm: Max35Text,
1732 #[serde(rename = "StartDt", skip_serializing_if = "Option::is_none")]
1733 pub start_dt: Option<IsoYearMonth>,
1734 #[validate]
1735 #[serde(rename = "XpryDt")]
1736 pub xpry_dt: IsoYearMonth,
1737 #[serde(rename = "CardIssrNm", skip_serializing_if = "Option::is_none")]
1738 pub card_issr_nm: Option<Max35Text>,
1739 #[serde(rename = "CardIssrId", skip_serializing_if = "Option::is_none")]
1740 pub card_issr_id: Option<PartyIdentification113>,
1741 #[serde(rename = "SctyCd", skip_serializing_if = "Option::is_none")]
1742 pub scty_cd: Option<Max35Text>,
1743 #[serde(rename = "SeqNb", skip_serializing_if = "Option::is_none")]
1744 pub seq_nb: Option<Max3Text>,
1745}
1746#[derive(
1747 Debug,
1748 Default,
1749 Clone,
1750 PartialEq,
1751 ::serde::Serialize,
1752 ::serde::Deserialize,
1753 ::derive_builder::Builder,
1754 ::validator::Validate,
1755)]
1756pub struct ItalianDomesticIdentifier {
1757 #[validate(regex = "ITALIAN_DOMESTIC_IDENTIFIER_REGEX")]
1758 #[serde(rename = "$text")]
1759 pub value: String,
1760}
1761#[derive(
1762 Debug,
1763 Default,
1764 Clone,
1765 PartialEq,
1766 ::serde::Serialize,
1767 ::serde::Deserialize,
1768 ::derive_builder::Builder,
1769 ::validator::Validate,
1770)]
1771pub struct AccountIdentificationAndName5 {
1772 #[serde(rename = "Id")]
1773 pub id: AccountIdentification4Choice,
1774 #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
1775 pub nm: Option<Max35Text>,
1776}
1777#[derive(
1778 Debug,
1779 Default,
1780 Clone,
1781 PartialEq,
1782 ::serde::Serialize,
1783 ::serde::Deserialize,
1784 ::derive_builder::Builder,
1785 ::validator::Validate,
1786)]
1787pub struct ChargeType5ChoiceEnum {
1788 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
1789 pub cd: Option<InvestmentFundFee1Code>,
1790 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
1791 pub prtry: Option<GenericIdentification47>,
1792}
1793#[derive(
1794 Debug,
1795 Default,
1796 Clone,
1797 PartialEq,
1798 ::serde::Serialize,
1799 ::serde::Deserialize,
1800 ::derive_builder::Builder,
1801 ::validator::Validate,
1802)]
1803pub struct ChargeType5Choice {
1804 #[serde(flatten)]
1805 pub value: ChargeType5ChoiceEnum,
1806}
1807#[derive(
1808 Debug,
1809 Default,
1810 Clone,
1811 PartialEq,
1812 ::serde::Serialize,
1813 ::serde::Deserialize,
1814 ::derive_builder::Builder,
1815 ::validator::Validate,
1816)]
1817pub struct InvestmentFundRole2ChoiceEnum {
1818 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
1819 pub prtry: Option<GenericIdentification47>,
1820 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
1821 pub cd: Option<InvestmentFundRole2Code>,
1822}
1823#[derive(
1824 Debug,
1825 Default,
1826 Clone,
1827 PartialEq,
1828 ::serde::Serialize,
1829 ::serde::Deserialize,
1830 ::derive_builder::Builder,
1831 ::validator::Validate,
1832)]
1833pub struct InvestmentFundRole2Choice {
1834 #[serde(flatten)]
1835 pub value: InvestmentFundRole2ChoiceEnum,
1836}
1837#[derive(
1838 Debug,
1839 Default,
1840 Clone,
1841 PartialEq,
1842 ::serde::Serialize,
1843 ::serde::Deserialize,
1844 ::derive_builder::Builder,
1845 ::validator::Validate,
1846)]
1847pub struct DutchIdentifier {
1848 #[serde(rename = "$text")]
1849 pub value: String,
1850}
1851#[derive(
1852 Debug,
1853 Default,
1854 Clone,
1855 PartialEq,
1856 ::serde::Serialize,
1857 ::serde::Deserialize,
1858 ::derive_builder::Builder,
1859 ::validator::Validate,
1860)]
1861pub struct IrishNscIdentifier {
1862 #[validate(regex = "IRISH_NSC_IDENTIFIER_REGEX")]
1863 #[serde(rename = "$text")]
1864 pub value: String,
1865}
1866#[derive(
1867 Debug,
1868 Default,
1869 Clone,
1870 PartialEq,
1871 ::serde::Serialize,
1872 ::serde::Deserialize,
1873 ::derive_builder::Builder,
1874 ::validator::Validate,
1875)]
1876pub struct IsoDateTime {
1877 #[serde(rename = "$text")]
1878 pub value: ::chrono::DateTime<::chrono::Utc>,
1879}
1880#[derive(
1881 Debug,
1882 Default,
1883 Clone,
1884 PartialEq,
1885 ::serde::Serialize,
1886 ::serde::Deserialize,
1887 ::derive_builder::Builder,
1888 ::validator::Validate,
1889)]
1890pub struct YesNoIndicator {
1891 #[serde(rename = "$text")]
1892 pub value: bool,
1893}
1894#[derive(
1895 Debug,
1896 Default,
1897 Clone,
1898 PartialEq,
1899 ::serde::Serialize,
1900 ::serde::Deserialize,
1901 ::derive_builder::Builder,
1902 ::validator::Validate,
1903)]
1904pub struct BaseOneRate {
1905 #[serde(rename = "$text")]
1906 pub value: f64,
1907}
1908#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1909pub enum FundOrderType8Code {
1910 #[serde(rename = "BEDB")]
1911 Bedb,
1912 #[serde(rename = "INVP")]
1913 Invp,
1914 #[serde(rename = "PREA")]
1915 Prea,
1916 #[serde(rename = "RGSV")]
1917 Rgsv,
1918 #[serde(rename = "RGSU")]
1919 Rgsu,
1920 #[serde(rename = "RDIV")]
1921 Rdiv,
1922 #[serde(rename = "STAF")]
1923 Staf,
1924 #[serde(rename = "WIDP")]
1925 Widp,
1926 #[default]
1927 Unknown,
1928}
1929#[derive(
1930 Debug,
1931 Default,
1932 Clone,
1933 PartialEq,
1934 ::serde::Serialize,
1935 ::serde::Deserialize,
1936 ::derive_builder::Builder,
1937 ::validator::Validate,
1938)]
1939pub struct TaxableIncomePerShareCalculated2ChoiceEnum {
1940 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
1941 pub prtry: Option<GenericIdentification47>,
1942 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
1943 pub cd: Option<TaxableIncomePerShareCalculated2Code>,
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 TaxableIncomePerShareCalculated2Choice {
1956 #[serde(flatten)]
1957 pub value: TaxableIncomePerShareCalculated2ChoiceEnum,
1958}
1959#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1960pub enum EuDividendStatus1Code {
1961 #[serde(rename = "DIVI")]
1962 Divi,
1963 #[serde(rename = "DIVO")]
1964 Divo,
1965 #[serde(rename = "UKWN")]
1966 Ukwn,
1967 #[default]
1968 Unknown,
1969}
1970#[derive(
1971 Debug,
1972 Default,
1973 Clone,
1974 PartialEq,
1975 ::serde::Serialize,
1976 ::serde::Deserialize,
1977 ::derive_builder::Builder,
1978 ::validator::Validate,
1979)]
1980pub struct Equalisation1 {
1981 #[serde(rename = "Amt", skip_serializing_if = "Option::is_none")]
1982 pub amt: Option<ActiveOrHistoricCurrencyAndAmount>,
1983 #[serde(rename = "Rate", skip_serializing_if = "Option::is_none")]
1984 pub rate: Option<PercentageRate>,
1985}
1986#[derive(
1987 Debug,
1988 Default,
1989 Clone,
1990 PartialEq,
1991 ::serde::Serialize,
1992 ::serde::Deserialize,
1993 ::derive_builder::Builder,
1994 ::validator::Validate,
1995)]
1996pub struct ChipsParticipantIdentifier {
1997 #[validate(regex = "CHIPS_PARTICIPANT_IDENTIFIER_REGEX")]
1998 #[serde(rename = "$text")]
1999 pub value: String,
2000}
2001#[derive(
2002 Debug,
2003 Default,
2004 Clone,
2005 PartialEq,
2006 ::serde::Serialize,
2007 ::serde::Deserialize,
2008 ::derive_builder::Builder,
2009 ::validator::Validate,
2010)]
2011pub struct DeliveryParameters3 {
2012 #[validate]
2013 #[serde(rename = "Adr")]
2014 pub adr: NameAndAddress4,
2015 #[serde(rename = "IssdCertNb", skip_serializing_if = "Option::is_none")]
2016 pub issd_cert_nb: Option<Max35Text>,
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 CancellationRight1ChoiceEnum {
2029 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
2030 pub cd: Option<CancellationRight1Code>,
2031 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
2032 pub prtry: Option<GenericIdentification47>,
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 CancellationRight1Choice {
2045 #[serde(flatten)]
2046 pub value: CancellationRight1ChoiceEnum,
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 AdditionalReference9 {
2059 #[validate]
2060 #[serde(rename = "Ref")]
2061 pub r#ref: Max35Text,
2062 #[serde(rename = "RefIssr", skip_serializing_if = "Option::is_none")]
2063 pub ref_issr: Option<PartyIdentification113>,
2064 #[serde(rename = "MsgNm", skip_serializing_if = "Option::is_none")]
2065 pub msg_nm: Option<Max35Text>,
2066}
2067#[derive(
2068 Debug,
2069 Default,
2070 Clone,
2071 PartialEq,
2072 ::serde::Serialize,
2073 ::serde::Deserialize,
2074 ::derive_builder::Builder,
2075 ::validator::Validate,
2076)]
2077pub struct IsinOct2015Identifier {
2078 #[validate(regex = "ISIN_OCT_2015_IDENTIFIER_REGEX")]
2079 #[serde(rename = "$text")]
2080 pub value: String,
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 PartyIdentificationAndAccount147 {
2093 #[validate]
2094 #[serde(rename = "PtyId")]
2095 pub pty_id: PartyIdentification113,
2096 #[serde(rename = "AcctId", skip_serializing_if = "Option::is_none")]
2097 pub acct_id: Option<Max35Text>,
2098}
2099#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2100pub enum DeliveryReceiptType2Code {
2101 #[serde(rename = "FREE")]
2102 Free,
2103 #[serde(rename = "APMT")]
2104 Apmt,
2105 #[default]
2106 Unknown,
2107}
2108#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2109pub enum DistributionPolicy1Code {
2110 #[serde(rename = "DIST")]
2111 Dist,
2112 #[serde(rename = "ACCU")]
2113 Accu,
2114 #[default]
2115 Unknown,
2116}
2117#[derive(
2118 Debug,
2119 Default,
2120 Clone,
2121 PartialEq,
2122 ::serde::Serialize,
2123 ::serde::Deserialize,
2124 ::derive_builder::Builder,
2125 ::validator::Validate,
2126)]
2127pub struct FinancialInstitutionIdentification8ChoiceEnum {
2128 #[serde(rename = "PrtryId", skip_serializing_if = "Option::is_none")]
2129 pub prtry_id: Option<Max35Text>,
2130 #[serde(rename = "BICFI", skip_serializing_if = "Option::is_none")]
2131 pub bicfi: Option<BicfiIdentifier>,
2132 #[serde(rename = "NmAndAdr", skip_serializing_if = "Option::is_none")]
2133 pub nm_and_adr: Option<NameAndAddress5>,
2134 #[serde(rename = "ClrSysMmbId", skip_serializing_if = "Option::is_none")]
2135 pub clr_sys_mmb_id: Option<ClearingSystemMemberIdentificationChoice>,
2136}
2137#[derive(
2138 Debug,
2139 Default,
2140 Clone,
2141 PartialEq,
2142 ::serde::Serialize,
2143 ::serde::Deserialize,
2144 ::derive_builder::Builder,
2145 ::validator::Validate,
2146)]
2147pub struct FinancialInstitutionIdentification8Choice {
2148 #[serde(flatten)]
2149 pub value: FinancialInstitutionIdentification8ChoiceEnum,
2150}
2151#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2152pub enum InvestmentFundFee1Code {
2153 #[serde(rename = "BEND")]
2154 Bend,
2155 #[serde(rename = "BRKF")]
2156 Brkf,
2157 #[serde(rename = "COMM")]
2158 Comm,
2159 #[serde(rename = "CDPL")]
2160 Cdpl,
2161 #[serde(rename = "CDSC")]
2162 Cdsc,
2163 #[serde(rename = "CBCH")]
2164 Cbch,
2165 #[serde(rename = "DLEV")]
2166 Dlev,
2167 #[serde(rename = "FEND")]
2168 Fend,
2169 #[serde(rename = "INIT")]
2170 Init,
2171 #[serde(rename = "ADDF")]
2172 Addf,
2173 #[serde(rename = "POST")]
2174 Post,
2175 #[serde(rename = "PREM")]
2176 Prem,
2177 #[serde(rename = "CHAR")]
2178 Char,
2179 #[serde(rename = "SHIP")]
2180 Ship,
2181 #[serde(rename = "SWIT")]
2182 Swit,
2183 #[serde(rename = "UCIC")]
2184 Ucic,
2185 #[serde(rename = "REGF")]
2186 Regf,
2187 #[serde(rename = "PENA")]
2188 Pena,
2189 #[default]
2190 Unknown,
2191}
2192#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2193pub enum TaxExemptReason1Code {
2194 #[serde(rename = "NONE")]
2195 None,
2196 #[serde(rename = "MASA")]
2197 Masa,
2198 #[serde(rename = "MISA")]
2199 Misa,
2200 #[serde(rename = "SISA")]
2201 Sisa,
2202 #[serde(rename = "IISA")]
2203 Iisa,
2204 #[serde(rename = "CUYP")]
2205 Cuyp,
2206 #[serde(rename = "PRYP")]
2207 Pryp,
2208 #[serde(rename = "ASTR")]
2209 Astr,
2210 #[serde(rename = "EMPY")]
2211 Empy,
2212 #[serde(rename = "EMCY")]
2213 Emcy,
2214 #[serde(rename = "EPRY")]
2215 Epry,
2216 #[serde(rename = "ECYE")]
2217 Ecye,
2218 #[serde(rename = "NFPI")]
2219 Nfpi,
2220 #[serde(rename = "NFQP")]
2221 Nfqp,
2222 #[serde(rename = "DECP")]
2223 Decp,
2224 #[serde(rename = "IRAC")]
2225 Irac,
2226 #[serde(rename = "IRAR")]
2227 Irar,
2228 #[serde(rename = "KEOG")]
2229 Keog,
2230 #[serde(rename = "PFSP")]
2231 Pfsp,
2232 #[serde(rename = "401K")]
2233 X401K,
2234 #[serde(rename = "SIRA")]
2235 Sira,
2236 #[serde(rename = "403B")]
2237 X403B,
2238 #[serde(rename = "457X")]
2239 X457X,
2240 #[serde(rename = "RIRA")]
2241 Rira,
2242 #[serde(rename = "RIAN")]
2243 Rian,
2244 #[serde(rename = "RCRF")]
2245 Rcrf,
2246 #[serde(rename = "RCIP")]
2247 Rcip,
2248 #[serde(rename = "EIFP")]
2249 Eifp,
2250 #[serde(rename = "EIOP")]
2251 Eiop,
2252 #[default]
2253 Unknown,
2254}
2255#[derive(
2256 Debug,
2257 Default,
2258 Clone,
2259 PartialEq,
2260 ::serde::Serialize,
2261 ::serde::Deserialize,
2262 ::derive_builder::Builder,
2263 ::validator::Validate,
2264)]
2265pub struct BelgianIdentifier {
2266 #[serde(rename = "$text")]
2267 pub value: String,
2268}
2269#[derive(
2270 Debug,
2271 Default,
2272 Clone,
2273 PartialEq,
2274 ::serde::Serialize,
2275 ::serde::Deserialize,
2276 ::derive_builder::Builder,
2277 ::validator::Validate,
2278)]
2279pub struct CreditTransfer8 {
2280 #[serde(rename = "Ref", skip_serializing_if = "Option::is_none")]
2281 pub r#ref: Option<Max35Text>,
2282 #[serde(rename = "Dbtr", skip_serializing_if = "Option::is_none")]
2283 pub dbtr: Option<PartyIdentification113>,
2284 #[serde(rename = "DbtrAcct", skip_serializing_if = "Option::is_none")]
2285 pub dbtr_acct: Option<AccountIdentificationAndName5>,
2286 #[serde(rename = "DbtrAgt", skip_serializing_if = "Option::is_none")]
2287 pub dbtr_agt: Option<FinancialInstitutionIdentification10>,
2288 #[serde(rename = "DbtrAgtAcct", skip_serializing_if = "Option::is_none")]
2289 pub dbtr_agt_acct: Option<AccountIdentificationAndName5>,
2290 #[serde(rename = "IntrmyAgt1", skip_serializing_if = "Option::is_none")]
2291 pub intrmy_agt_1: Option<FinancialInstitutionIdentification10>,
2292 #[serde(rename = "IntrmyAgt1Acct", skip_serializing_if = "Option::is_none")]
2293 pub intrmy_agt_1_acct: Option<AccountIdentificationAndName5>,
2294 #[serde(rename = "IntrmyAgt2", skip_serializing_if = "Option::is_none")]
2295 pub intrmy_agt_2: Option<FinancialInstitutionIdentification10>,
2296 #[serde(rename = "IntrmyAgt2Acct", skip_serializing_if = "Option::is_none")]
2297 pub intrmy_agt_2_acct: Option<AccountIdentificationAndName5>,
2298 #[validate]
2299 #[serde(rename = "CdtrAgt")]
2300 pub cdtr_agt: FinancialInstitutionIdentification10,
2301 #[serde(rename = "CdtrAgtAcct", skip_serializing_if = "Option::is_none")]
2302 pub cdtr_agt_acct: Option<AccountIdentificationAndName5>,
2303 #[serde(rename = "Cdtr", skip_serializing_if = "Option::is_none")]
2304 pub cdtr: Option<PartyIdentification113>,
2305 #[validate]
2306 #[serde(rename = "CdtrAcct")]
2307 pub cdtr_acct: AccountIdentificationAndName5,
2308}
2309#[derive(
2310 Debug,
2311 Default,
2312 Clone,
2313 PartialEq,
2314 ::serde::Serialize,
2315 ::serde::Deserialize,
2316 ::derive_builder::Builder,
2317 ::validator::Validate,
2318)]
2319pub struct HongKongBankIdentifier {
2320 #[validate(regex = "HONG_KONG_BANK_IDENTIFIER_REGEX")]
2321 #[serde(rename = "$text")]
2322 pub value: String,
2323}
2324#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2325pub enum PartyIdentificationType7Code {
2326 #[serde(rename = "ATIN")]
2327 Atin,
2328 #[serde(rename = "IDCD")]
2329 Idcd,
2330 #[serde(rename = "NRIN")]
2331 Nrin,
2332 #[serde(rename = "OTHR")]
2333 Othr,
2334 #[serde(rename = "PASS")]
2335 Pass,
2336 #[serde(rename = "POCD")]
2337 Pocd,
2338 #[serde(rename = "SOCS")]
2339 Socs,
2340 #[serde(rename = "SRSA")]
2341 Srsa,
2342 #[serde(rename = "GUNL")]
2343 Gunl,
2344 #[serde(rename = "GTIN")]
2345 Gtin,
2346 #[serde(rename = "ITIN")]
2347 Itin,
2348 #[serde(rename = "CPFA")]
2349 Cpfa,
2350 #[serde(rename = "AREG")]
2351 Areg,
2352 #[serde(rename = "DRLC")]
2353 Drlc,
2354 #[serde(rename = "EMID")]
2355 Emid,
2356 #[serde(rename = "NINV")]
2357 Ninv,
2358 #[serde(rename = "INCL")]
2359 Incl,
2360 #[serde(rename = "GIIN")]
2361 Giin,
2362 #[default]
2363 Unknown,
2364}
2365#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2366pub enum TradingCapacity8Code {
2367 #[serde(rename = "AGEN")]
2368 Agen,
2369 #[serde(rename = "PRIN")]
2370 Prin,
2371 #[default]
2372 Unknown,
2373}
2374#[derive(
2375 Debug,
2376 Default,
2377 Clone,
2378 PartialEq,
2379 ::serde::Serialize,
2380 ::serde::Deserialize,
2381 ::derive_builder::Builder,
2382 ::validator::Validate,
2383)]
2384pub struct RicIdentifier {
2385 #[validate(length(min = 1, max = 35,))]
2386 #[serde(rename = "$text")]
2387 pub value: String,
2388}
2389#[derive(
2390 Debug,
2391 Default,
2392 Clone,
2393 PartialEq,
2394 ::serde::Serialize,
2395 ::serde::Deserialize,
2396 ::derive_builder::Builder,
2397 ::validator::Validate,
2398)]
2399pub struct ClearingSystemMemberIdentificationChoiceEnum {
2400 #[serde(rename = "CHSIC", skip_serializing_if = "Option::is_none")]
2401 pub chsic: Option<SwissSicIdentifier>,
2402 #[serde(rename = "USCH", skip_serializing_if = "Option::is_none")]
2403 pub usch: Option<ChipsParticipantIdentifier>,
2404 #[serde(rename = "DEBLZ", skip_serializing_if = "Option::is_none")]
2405 pub deblz: Option<GermanBankleitzahlIdentifier>,
2406 #[serde(rename = "CHBC", skip_serializing_if = "Option::is_none")]
2407 pub chbc: Option<SwissBcIdentifier>,
2408 #[serde(rename = "HKNCC", skip_serializing_if = "Option::is_none")]
2409 pub hkncc: Option<HongKongBankIdentifier>,
2410 #[serde(rename = "AUBSBs", skip_serializing_if = "Option::is_none")]
2411 pub aubs_bs: Option<SmallNetworkIdentifier>,
2412 #[serde(rename = "PTNCC", skip_serializing_if = "Option::is_none")]
2413 pub ptncc: Option<PortugueseNccIdentifier>,
2414 #[serde(rename = "IENSC", skip_serializing_if = "Option::is_none")]
2415 pub iensc: Option<IrishNscIdentifier>,
2416 #[serde(rename = "USFW", skip_serializing_if = "Option::is_none")]
2417 pub usfw: Option<FedwireRoutingNumberIdentifier>,
2418 #[serde(rename = "ITNCC", skip_serializing_if = "Option::is_none")]
2419 pub itncc: Option<ItalianDomesticIdentifier>,
2420 #[serde(rename = "USCHU", skip_serializing_if = "Option::is_none")]
2421 pub uschu: Option<ChipsUniversalIdentifier>,
2422 #[serde(rename = "NZNCC", skip_serializing_if = "Option::is_none")]
2423 pub nzncc: Option<NewZealandNccIdentifier>,
2424 #[serde(rename = "ESNCC", skip_serializing_if = "Option::is_none")]
2425 pub esncc: Option<SpanishDomesticInterbankingIdentifier>,
2426 #[serde(rename = "GBSC", skip_serializing_if = "Option::is_none")]
2427 pub gbsc: Option<UkDomesticSortCodeIdentifier>,
2428 #[serde(rename = "AUBSBx", skip_serializing_if = "Option::is_none")]
2429 pub aubs_bx: Option<ExtensiveBranchNetworkIdentifier>,
2430 #[serde(rename = "ATBLZ", skip_serializing_if = "Option::is_none")]
2431 pub atblz: Option<AustrianBankleitzahlIdentifier>,
2432 #[serde(rename = "ZANCC", skip_serializing_if = "Option::is_none")]
2433 pub zancc: Option<SouthAfricanNccIdentifier>,
2434 #[serde(rename = "RUCB", skip_serializing_if = "Option::is_none")]
2435 pub rucb: Option<RussianCentralBankIdentificationCodeIdentifier>,
2436 #[serde(rename = "CACPA", skip_serializing_if = "Option::is_none")]
2437 pub cacpa: Option<CanadianPaymentsArnIdentifier>,
2438}
2439#[derive(
2440 Debug,
2441 Default,
2442 Clone,
2443 PartialEq,
2444 ::serde::Serialize,
2445 ::serde::Deserialize,
2446 ::derive_builder::Builder,
2447 ::validator::Validate,
2448)]
2449pub struct ClearingSystemMemberIdentificationChoice {
2450 #[serde(flatten)]
2451 pub value: ClearingSystemMemberIdentificationChoiceEnum,
2452}
2453#[derive(
2454 Debug,
2455 Default,
2456 Clone,
2457 PartialEq,
2458 ::serde::Serialize,
2459 ::serde::Deserialize,
2460 ::derive_builder::Builder,
2461 ::validator::Validate,
2462)]
2463pub struct EuDividendStatusType2ChoiceEnum {
2464 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
2465 pub cd: Option<EuDividendStatus1Code>,
2466 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
2467 pub prtry: Option<GenericIdentification47>,
2468}
2469#[derive(
2470 Debug,
2471 Default,
2472 Clone,
2473 PartialEq,
2474 ::serde::Serialize,
2475 ::serde::Deserialize,
2476 ::derive_builder::Builder,
2477 ::validator::Validate,
2478)]
2479pub struct EuDividendStatusType2Choice {
2480 #[serde(flatten)]
2481 pub value: EuDividendStatusType2ChoiceEnum,
2482}
2483#[derive(
2484 Debug,
2485 Default,
2486 Clone,
2487 PartialEq,
2488 ::serde::Serialize,
2489 ::serde::Deserialize,
2490 ::derive_builder::Builder,
2491 ::validator::Validate,
2492)]
2493pub struct FedwireRoutingNumberIdentifier {
2494 #[validate(regex = "FEDWIRE_ROUTING_NUMBER_IDENTIFIER_REGEX")]
2495 #[serde(rename = "$text")]
2496 pub value: String,
2497}
2498#[derive(
2499 Debug,
2500 Default,
2501 Clone,
2502 PartialEq,
2503 ::serde::Serialize,
2504 ::serde::Deserialize,
2505 ::derive_builder::Builder,
2506 ::validator::Validate,
2507)]
2508pub struct ActiveOrHistoricCurrencyAndAmountSimpleType {
2509 #[validate(range(min = 0,))]
2510 #[serde(rename = "$text")]
2511 pub value: f64,
2512}
2513#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2514pub enum CancellationRight1Code {
2515 #[serde(rename = "VALI")]
2516 Vali,
2517 #[serde(rename = "NOXO")]
2518 Noxo,
2519 #[serde(rename = "NOWA")]
2520 Nowa,
2521 #[serde(rename = "NOIN")]
2522 Noin,
2523 #[default]
2524 Unknown,
2525}
2526#[derive(
2527 Debug,
2528 Default,
2529 Clone,
2530 PartialEq,
2531 ::serde::Serialize,
2532 ::serde::Deserialize,
2533 ::derive_builder::Builder,
2534 ::validator::Validate,
2535)]
2536pub struct ChargeBasis2ChoiceEnum {
2537 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
2538 pub prtry: Option<GenericIdentification47>,
2539 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
2540 pub cd: Option<TaxationBasis5Code>,
2541}
2542#[derive(
2543 Debug,
2544 Default,
2545 Clone,
2546 PartialEq,
2547 ::serde::Serialize,
2548 ::serde::Deserialize,
2549 ::derive_builder::Builder,
2550 ::validator::Validate,
2551)]
2552pub struct ChargeBasis2Choice {
2553 #[serde(flatten)]
2554 pub value: ChargeBasis2ChoiceEnum,
2555}
2556#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2557pub enum PriceMethod1Code {
2558 #[serde(rename = "FORW")]
2559 Forw,
2560 #[serde(rename = "HIST")]
2561 Hist,
2562 #[default]
2563 Unknown,
2564}
2565#[derive(
2566 Debug,
2567 Default,
2568 Clone,
2569 PartialEq,
2570 ::serde::Serialize,
2571 ::serde::Deserialize,
2572 ::derive_builder::Builder,
2573 ::validator::Validate,
2574)]
2575pub struct SafekeepingPlaceFormat8ChoiceEnum {
2576 #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
2577 pub id: Option<SafekeepingPlaceTypeAndText6>,
2578 #[serde(rename = "Ctry", skip_serializing_if = "Option::is_none")]
2579 pub ctry: Option<CountryCode>,
2580 #[serde(rename = "TpAndId", skip_serializing_if = "Option::is_none")]
2581 pub tp_and_id: Option<SafekeepingPlaceTypeAndAnyBicIdentifier1>,
2582 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
2583 pub prtry: Option<GenericIdentification78>,
2584}
2585#[derive(
2586 Debug,
2587 Default,
2588 Clone,
2589 PartialEq,
2590 ::serde::Serialize,
2591 ::serde::Deserialize,
2592 ::derive_builder::Builder,
2593 ::validator::Validate,
2594)]
2595pub struct SafekeepingPlaceFormat8Choice {
2596 #[serde(flatten)]
2597 pub value: SafekeepingPlaceFormat8ChoiceEnum,
2598}
2599#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2600pub enum SettlementTransactionCondition11Code {
2601 #[serde(rename = "NOMC")]
2602 Nomc,
2603 #[default]
2604 Unknown,
2605}
2606#[derive(
2607 Debug,
2608 Default,
2609 Clone,
2610 PartialEq,
2611 ::serde::Serialize,
2612 ::serde::Deserialize,
2613 ::derive_builder::Builder,
2614 ::validator::Validate,
2615)]
2616pub struct NameAndAddress5 {
2617 #[validate]
2618 #[serde(rename = "Nm")]
2619 pub nm: Max350Text,
2620 #[serde(rename = "Adr", skip_serializing_if = "Option::is_none")]
2621 pub adr: Option<PostalAddress1>,
2622}
2623#[derive(
2624 Debug,
2625 Default,
2626 Clone,
2627 PartialEq,
2628 ::serde::Serialize,
2629 ::serde::Deserialize,
2630 ::derive_builder::Builder,
2631 ::validator::Validate,
2632)]
2633pub struct TaxCalculationInformation10 {
2634 #[serde(rename = "Bsis", skip_serializing_if = "Option::is_none")]
2635 pub bsis: Option<TaxBasis1Choice>,
2636 #[validate]
2637 #[serde(rename = "TaxblAmt")]
2638 pub taxbl_amt: ActiveCurrencyAndAmount,
2639}
2640#[derive(
2641 Debug,
2642 Default,
2643 Clone,
2644 PartialEq,
2645 ::serde::Serialize,
2646 ::serde::Deserialize,
2647 ::derive_builder::Builder,
2648 ::validator::Validate,
2649)]
2650pub struct NameAndAddress4 {
2651 #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
2652 pub nm: Option<Max350Text>,
2653 #[validate]
2654 #[serde(rename = "Adr")]
2655 pub adr: PostalAddress1,
2656}
2657#[derive(
2658 Debug,
2659 Default,
2660 Clone,
2661 PartialEq,
2662 ::serde::Serialize,
2663 ::serde::Deserialize,
2664 ::derive_builder::Builder,
2665 ::validator::Validate,
2666)]
2667pub struct ConsolidatedTapeAssociationIdentifier {
2668 #[validate(length(min = 1, max = 35,))]
2669 #[serde(rename = "$text")]
2670 pub value: String,
2671}
2672#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2673pub enum IncomePreference1Code {
2674 #[serde(rename = "CASH")]
2675 Cash,
2676 #[serde(rename = "DRIP")]
2677 Drip,
2678 #[default]
2679 Unknown,
2680}
2681#[derive(
2682 Debug,
2683 Default,
2684 Clone,
2685 PartialEq,
2686 ::serde::Serialize,
2687 ::serde::Deserialize,
2688 ::derive_builder::Builder,
2689 ::validator::Validate,
2690)]
2691pub struct Max3Text {
2692 #[validate(length(min = 1, max = 3,))]
2693 #[serde(rename = "$text")]
2694 pub value: String,
2695}
2696#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2697pub enum TaxationBasis5Code {
2698 #[serde(rename = "FLAT")]
2699 Flat,
2700 #[serde(rename = "GRAM")]
2701 Gram,
2702 #[serde(rename = "NEAM")]
2703 Neam,
2704 #[serde(rename = "NAVP")]
2705 Navp,
2706 #[serde(rename = "PERU")]
2707 Peru,
2708 #[default]
2709 Unknown,
2710}
2711#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2712pub enum WaivingInstruction1Code {
2713 #[serde(rename = "WICA")]
2714 Wica,
2715 #[serde(rename = "WIUN")]
2716 Wiun,
2717 #[default]
2718 Unknown,
2719}
2720#[derive(
2721 Debug,
2722 Default,
2723 Clone,
2724 PartialEq,
2725 ::serde::Serialize,
2726 ::serde::Deserialize,
2727 ::derive_builder::Builder,
2728 ::validator::Validate,
2729)]
2730pub struct GenericIdentification78 {
2731 #[validate]
2732 #[serde(rename = "Tp")]
2733 pub tp: GenericIdentification30,
2734 #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
2735 pub id: Option<Max35Text>,
2736}
2737#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2738pub enum FundOrderType5Code {
2739 #[serde(rename = "NSPN")]
2740 Nspn,
2741 #[serde(rename = "NCPN")]
2742 Ncpn,
2743 #[serde(rename = "SWSP")]
2744 Swsp,
2745 #[serde(rename = "CWSP")]
2746 Cwsp,
2747 #[default]
2748 Unknown,
2749}
2750#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2751pub enum OrderWaiverReason1Code {
2752 #[serde(rename = "LATE")]
2753 Late,
2754 #[serde(rename = "FEND")]
2755 Fend,
2756 #[serde(rename = "BMIN")]
2757 Bmin,
2758 #[serde(rename = "CUTO")]
2759 Cuto,
2760 #[serde(rename = "COMW")]
2761 Comw,
2762 #[default]
2763 Unknown,
2764}
2765#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2766pub enum FinancialAdvice1Code {
2767 #[serde(rename = "RECE")]
2768 Rece,
2769 #[serde(rename = "NREC")]
2770 Nrec,
2771 #[serde(rename = "UKWN")]
2772 Ukwn,
2773 #[default]
2774 Unknown,
2775}
2776#[derive(
2777 Debug,
2778 Default,
2779 Clone,
2780 PartialEq,
2781 ::serde::Serialize,
2782 ::serde::Deserialize,
2783 ::derive_builder::Builder,
2784 ::validator::Validate,
2785)]
2786pub struct SwissSicIdentifier {
2787 #[validate(regex = "SWISS_SIC_IDENTIFIER_REGEX")]
2788 #[serde(rename = "$text")]
2789 pub value: String,
2790}
2791#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2792pub enum TypeOfPrice10Code {
2793 #[serde(rename = "BIDE")]
2794 Bide,
2795 #[serde(rename = "OFFR")]
2796 Offr,
2797 #[serde(rename = "NAVL")]
2798 Navl,
2799 #[serde(rename = "CREA")]
2800 Crea,
2801 #[serde(rename = "CANC")]
2802 Canc,
2803 #[serde(rename = "INTE")]
2804 Inte,
2805 #[serde(rename = "SWNG")]
2806 Swng,
2807 #[serde(rename = "MIDD")]
2808 Midd,
2809 #[serde(rename = "RINV")]
2810 Rinv,
2811 #[serde(rename = "SWIC")]
2812 Swic,
2813 #[serde(rename = "DDVR")]
2814 Ddvr,
2815 #[serde(rename = "ACTU")]
2816 Actu,
2817 #[default]
2818 Unknown,
2819}
2820#[derive(
2821 Debug,
2822 Default,
2823 Clone,
2824 PartialEq,
2825 ::serde::Serialize,
2826 ::serde::Deserialize,
2827 ::derive_builder::Builder,
2828 ::validator::Validate,
2829)]
2830pub struct ValorenIdentifier {
2831 #[serde(rename = "$text")]
2832 pub value: String,
2833}
2834#[derive(
2835 Debug,
2836 Default,
2837 Clone,
2838 PartialEq,
2839 ::serde::Serialize,
2840 ::serde::Deserialize,
2841 ::derive_builder::Builder,
2842 ::validator::Validate,
2843)]
2844pub struct WaivingInstruction2ChoiceEnum {
2845 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
2846 pub prtry: Option<GenericIdentification47>,
2847 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
2848 pub cd: Option<WaivingInstruction1Code>,
2849}
2850#[derive(
2851 Debug,
2852 Default,
2853 Clone,
2854 PartialEq,
2855 ::serde::Serialize,
2856 ::serde::Deserialize,
2857 ::derive_builder::Builder,
2858 ::validator::Validate,
2859)]
2860pub struct WaivingInstruction2Choice {
2861 #[serde(flatten)]
2862 pub value: WaivingInstruction2ChoiceEnum,
2863}
2864#[derive(
2865 Debug,
2866 Default,
2867 Clone,
2868 PartialEq,
2869 ::serde::Serialize,
2870 ::serde::Deserialize,
2871 ::derive_builder::Builder,
2872 ::validator::Validate,
2873)]
2874pub struct Exact4AlphaNumericText {
2875 #[validate(regex = "EXACT_4_ALPHA_NUMERIC_TEXT_REGEX")]
2876 #[serde(rename = "$text")]
2877 pub value: String,
2878}
2879#[derive(
2880 Debug,
2881 Default,
2882 Clone,
2883 PartialEq,
2884 ::serde::Serialize,
2885 ::serde::Deserialize,
2886 ::derive_builder::Builder,
2887 ::validator::Validate,
2888)]
2889pub struct GermanBankleitzahlIdentifier {
2890 #[validate(regex = "GERMAN_BANKLEITZAHL_IDENTIFIER_REGEX")]
2891 #[serde(rename = "$text")]
2892 pub value: String,
2893}
2894#[derive(
2895 Debug,
2896 Default,
2897 Clone,
2898 PartialEq,
2899 ::serde::Serialize,
2900 ::serde::Deserialize,
2901 ::derive_builder::Builder,
2902 ::validator::Validate,
2903)]
2904pub struct ReceivingPartiesAndAccount16 {
2905 #[serde(rename = "RcvrsCtdnDtls", skip_serializing_if = "Option::is_none")]
2906 pub rcvrs_ctdn_dtls: Option<PartyIdentificationAndAccount147>,
2907 #[serde(rename = "RcvrsIntrmy1Dtls", skip_serializing_if = "Option::is_none")]
2908 pub rcvrs_intrmy_1_dtls: Option<PartyIdentificationAndAccount147>,
2909 #[serde(rename = "RcvrsIntrmy2Dtls", skip_serializing_if = "Option::is_none")]
2910 pub rcvrs_intrmy_2_dtls: Option<PartyIdentificationAndAccount147>,
2911 #[validate]
2912 #[serde(rename = "RcvgAgtDtls")]
2913 pub rcvg_agt_dtls: PartyIdentificationAndAccount147,
2914}
2915#[derive(
2916 Debug,
2917 Default,
2918 Clone,
2919 PartialEq,
2920 ::serde::Serialize,
2921 ::serde::Deserialize,
2922 ::derive_builder::Builder,
2923 ::validator::Validate,
2924)]
2925pub struct SwissBcIdentifier {
2926 #[validate(regex = "SWISS_BC_IDENTIFIER_REGEX")]
2927 #[serde(rename = "$text")]
2928 pub value: String,
2929}
2930#[derive(
2931 Debug,
2932 Default,
2933 Clone,
2934 PartialEq,
2935 ::serde::Serialize,
2936 ::serde::Deserialize,
2937 ::derive_builder::Builder,
2938 ::validator::Validate,
2939)]
2940pub struct Max34Text {
2941 #[validate(length(min = 1, max = 34,))]
2942 #[serde(rename = "$text")]
2943 pub value: String,
2944}
2945#[derive(
2946 Debug,
2947 Default,
2948 Clone,
2949 PartialEq,
2950 ::serde::Serialize,
2951 ::serde::Deserialize,
2952 ::derive_builder::Builder,
2953 ::validator::Validate,
2954)]
2955pub struct Max350Text {
2956 #[validate(length(min = 1, max = 350,))]
2957 #[serde(rename = "$text")]
2958 pub value: String,
2959}
2960#[derive(
2961 Debug,
2962 Default,
2963 Clone,
2964 PartialEq,
2965 ::serde::Serialize,
2966 ::serde::Deserialize,
2967 ::derive_builder::Builder,
2968 ::validator::Validate,
2969)]
2970pub struct IsoDate {
2971 #[serde(rename = "$text")]
2972 pub value: ::chrono::NaiveDate,
2973}
2974#[derive(
2975 Debug,
2976 Default,
2977 Clone,
2978 PartialEq,
2979 ::serde::Serialize,
2980 ::serde::Deserialize,
2981 ::derive_builder::Builder,
2982 ::validator::Validate,
2983)]
2984pub struct Fee2 {
2985 #[serde(rename = "Tp")]
2986 pub tp: ChargeType5Choice,
2987 #[serde(rename = "Bsis", skip_serializing_if = "Option::is_none")]
2988 pub bsis: Option<ChargeBasis2Choice>,
2989 #[serde(rename = "StdAmt", skip_serializing_if = "Option::is_none")]
2990 pub std_amt: Option<ActiveCurrencyAndAmount>,
2991 #[serde(rename = "StdRate", skip_serializing_if = "Option::is_none")]
2992 pub std_rate: Option<PercentageRate>,
2993 #[serde(rename = "DscntDtls", skip_serializing_if = "Option::is_none")]
2994 pub dscnt_dtls: Option<ChargeOrCommissionDiscount1>,
2995 #[serde(rename = "ApldAmt", skip_serializing_if = "Option::is_none")]
2996 pub apld_amt: Option<ActiveCurrencyAndAmount>,
2997 #[serde(rename = "ApldRate", skip_serializing_if = "Option::is_none")]
2998 pub apld_rate: Option<PercentageRate>,
2999 #[serde(rename = "NonStdSLARef", skip_serializing_if = "Option::is_none")]
3000 pub non_std_sla_ref: Option<Max35Text>,
3001 #[serde(rename = "RcptId", skip_serializing_if = "Option::is_none")]
3002 pub rcpt_id: Option<PartyIdentification113>,
3003 #[validate]
3004 #[serde(rename = "InftvInd")]
3005 pub inftv_ind: YesNoIndicator,
3006}
3007#[derive(
3008 Debug,
3009 Default,
3010 Clone,
3011 PartialEq,
3012 ::serde::Serialize,
3013 ::serde::Deserialize,
3014 ::derive_builder::Builder,
3015 ::validator::Validate,
3016)]
3017pub struct AustrianBankleitzahlIdentifier {
3018 #[validate(regex = "AUSTRIAN_BANKLEITZAHL_IDENTIFIER_REGEX")]
3019 #[serde(rename = "$text")]
3020 pub value: String,
3021}
3022#[derive(
3023 Debug,
3024 Default,
3025 Clone,
3026 PartialEq,
3027 ::serde::Serialize,
3028 ::serde::Deserialize,
3029 ::derive_builder::Builder,
3030 ::validator::Validate,
3031)]
3032pub struct MessageIdentification1 {
3033 #[validate]
3034 #[serde(rename = "Id")]
3035 pub id: Max35Text,
3036 #[validate]
3037 #[serde(rename = "CreDtTm")]
3038 pub cre_dt_tm: IsoDateTime,
3039}
3040#[derive(
3041 Debug,
3042 Default,
3043 Clone,
3044 PartialEq,
3045 ::serde::Serialize,
3046 ::serde::Deserialize,
3047 ::derive_builder::Builder,
3048 ::validator::Validate,
3049)]
3050pub struct CopyInformation4 {
3051 #[validate]
3052 #[serde(rename = "CpyInd")]
3053 pub cpy_ind: YesNoIndicator,
3054 #[serde(rename = "OrgnlRcvr", skip_serializing_if = "Option::is_none")]
3055 pub orgnl_rcvr: Option<AnyBicIdentifier>,
3056}
3057#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3058pub enum TransactionChannel2Code {
3059 #[serde(rename = "FIAD")]
3060 Fiad,
3061 #[serde(rename = "HOBA")]
3062 Hoba,
3063 #[serde(rename = "BRAN")]
3064 Bran,
3065 #[default]
3066 Unknown,
3067}
3068#[derive(
3069 Debug,
3070 Default,
3071 Clone,
3072 PartialEq,
3073 ::serde::Serialize,
3074 ::serde::Deserialize,
3075 ::derive_builder::Builder,
3076 ::validator::Validate,
3077)]
3078pub struct PostalAddress1 {
3079 #[serde(rename = "AdrTp", skip_serializing_if = "Option::is_none")]
3080 pub adr_tp: Option<AddressType2Code>,
3081 #[validate(length(min = 0, max = 5,))]
3082 #[serde(rename = "AdrLine", default)]
3083 pub adr_line: Vec<Max70Text>,
3084 #[serde(rename = "StrtNm", skip_serializing_if = "Option::is_none")]
3085 pub strt_nm: Option<Max70Text>,
3086 #[serde(rename = "BldgNb", skip_serializing_if = "Option::is_none")]
3087 pub bldg_nb: Option<Max16Text>,
3088 #[serde(rename = "PstCd", skip_serializing_if = "Option::is_none")]
3089 pub pst_cd: Option<Max16Text>,
3090 #[serde(rename = "TwnNm", skip_serializing_if = "Option::is_none")]
3091 pub twn_nm: Option<Max35Text>,
3092 #[serde(rename = "CtrySubDvsn", skip_serializing_if = "Option::is_none")]
3093 pub ctry_sub_dvsn: Option<Max35Text>,
3094 #[serde(rename = "Ctry")]
3095 pub ctry: CountryCode,
3096}
3097#[derive(
3098 Debug,
3099 Default,
3100 Clone,
3101 PartialEq,
3102 ::serde::Serialize,
3103 ::serde::Deserialize,
3104 ::derive_builder::Builder,
3105 ::validator::Validate,
3106)]
3107pub struct SouthAfricanNccIdentifier {
3108 #[validate(regex = "SOUTH_AFRICAN_NCC_IDENTIFIER_REGEX")]
3109 #[serde(rename = "$text")]
3110 pub value: String,
3111}
3112#[derive(
3113 Debug,
3114 Default,
3115 Clone,
3116 PartialEq,
3117 ::serde::Serialize,
3118 ::serde::Deserialize,
3119 ::derive_builder::Builder,
3120 ::validator::Validate,
3121)]
3122pub struct Intermediary39 {
3123 #[validate]
3124 #[serde(rename = "Id")]
3125 pub id: PartyIdentification113,
3126 #[serde(rename = "Acct", skip_serializing_if = "Option::is_none")]
3127 pub acct: Option<Account22>,
3128 #[serde(rename = "OrdrOrgtrElgblty", skip_serializing_if = "Option::is_none")]
3129 pub ordr_orgtr_elgblty: Option<OrderOriginatorEligibility1Code>,
3130 #[serde(rename = "TradgPtyCpcty", skip_serializing_if = "Option::is_none")]
3131 pub tradg_pty_cpcty: Option<TradingCapacity8Code>,
3132 #[serde(rename = "Role", skip_serializing_if = "Option::is_none")]
3133 pub role: Option<InvestmentFundRole2Choice>,
3134}
3135#[derive(
3136 Debug,
3137 Default,
3138 Clone,
3139 PartialEq,
3140 ::serde::Serialize,
3141 ::serde::Deserialize,
3142 ::derive_builder::Builder,
3143 ::validator::Validate,
3144)]
3145pub struct GenericIdentification30 {
3146 #[validate]
3147 #[serde(rename = "Id")]
3148 pub id: Exact4AlphaNumericText,
3149 #[validate]
3150 #[serde(rename = "Issr")]
3151 pub issr: Max35Text,
3152 #[serde(rename = "SchmeNm", skip_serializing_if = "Option::is_none")]
3153 pub schme_nm: Option<Max35Text>,
3154}
3155#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3156pub enum OrderOriginatorEligibility1Code {
3157 #[serde(rename = "ELIG")]
3158 Elig,
3159 #[serde(rename = "RETL")]
3160 Retl,
3161 #[serde(rename = "PROF")]
3162 Prof,
3163 #[default]
3164 Unknown,
3165}
3166#[derive(
3167 Debug,
3168 Default,
3169 Clone,
3170 PartialEq,
3171 ::serde::Serialize,
3172 ::serde::Deserialize,
3173 ::derive_builder::Builder,
3174 ::validator::Validate,
3175)]
3176pub struct FinancialInstitutionIdentification10 {
3177 #[serde(rename = "Pty")]
3178 pub pty: FinancialInstitutionIdentification8Choice,
3179 #[serde(rename = "LEI", skip_serializing_if = "Option::is_none")]
3180 pub lei: Option<LeiIdentifier>,
3181}
3182#[derive(
3183 Debug,
3184 Default,
3185 Clone,
3186 PartialEq,
3187 ::serde::Serialize,
3188 ::serde::Deserialize,
3189 ::derive_builder::Builder,
3190 ::validator::Validate,
3191)]
3192pub struct TradeTransactionCondition8ChoiceEnum {
3193 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
3194 pub cd: Option<TradeTransactionCondition5Code>,
3195 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
3196 pub prtry: Option<GenericIdentification30>,
3197}
3198#[derive(
3199 Debug,
3200 Default,
3201 Clone,
3202 PartialEq,
3203 ::serde::Serialize,
3204 ::serde::Deserialize,
3205 ::derive_builder::Builder,
3206 ::validator::Validate,
3207)]
3208pub struct TradeTransactionCondition8Choice {
3209 #[serde(flatten)]
3210 pub value: TradeTransactionCondition8ChoiceEnum,
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 Max4AlphaNumericText {
3223 #[validate(length(min = 1, max = 4,), regex = "MAX_4_ALPHA_NUMERIC_TEXT_REGEX")]
3224 #[serde(rename = "$text")]
3225 pub value: String,
3226}
3227#[derive(
3228 Debug,
3229 Default,
3230 Clone,
3231 PartialEq,
3232 ::serde::Serialize,
3233 ::serde::Deserialize,
3234 ::derive_builder::Builder,
3235 ::validator::Validate,
3236)]
3237pub struct UnitPrice22 {
3238 #[serde(rename = "Tp")]
3239 pub tp: TypeOfPrice46Choice,
3240 #[validate]
3241 #[serde(rename = "Val")]
3242 pub val: PriceValue1,
3243 #[serde(rename = "PricMtd", skip_serializing_if = "Option::is_none")]
3244 pub pric_mtd: Option<PriceMethod1Code>,
3245 #[serde(rename = "NbOfDaysAcrd", skip_serializing_if = "Option::is_none")]
3246 pub nb_of_days_acrd: Option<Number>,
3247 #[serde(rename = "TaxblIncmPerShr", skip_serializing_if = "Option::is_none")]
3248 pub taxbl_incm_per_shr: Option<ActiveCurrencyAnd13DecimalAmount>,
3249 #[serde(
3250 rename = "TaxblIncmPerShrClctd",
3251 skip_serializing_if = "Option::is_none"
3252 )]
3253 pub taxbl_incm_per_shr_clctd: Option<TaxableIncomePerShareCalculated2Choice>,
3254 #[serde(rename = "PricDiffRsn", skip_serializing_if = "Option::is_none")]
3255 pub pric_diff_rsn: Option<Max350Text>,
3256}
3257#[derive(
3258 Debug,
3259 Default,
3260 Clone,
3261 PartialEq,
3262 ::serde::Serialize,
3263 ::serde::Deserialize,
3264 ::derive_builder::Builder,
3265 ::validator::Validate,
3266)]
3267pub struct Max70Text {
3268 #[validate(length(min = 1, max = 70,))]
3269 #[serde(rename = "$text")]
3270 pub value: String,
3271}
3272#[derive(
3273 Debug,
3274 Default,
3275 Clone,
3276 PartialEq,
3277 ::serde::Serialize,
3278 ::serde::Deserialize,
3279 ::derive_builder::Builder,
3280 ::validator::Validate,
3281)]
3282pub struct SecurityIdentification25ChoiceEnum {
3283 #[serde(rename = "TckrSymb", skip_serializing_if = "Option::is_none")]
3284 pub tckr_symb: Option<TickerIdentifier>,
3285 #[serde(rename = "Blmbrg", skip_serializing_if = "Option::is_none")]
3286 pub blmbrg: Option<Bloomberg2Identifier>,
3287 #[serde(rename = "CUSIP", skip_serializing_if = "Option::is_none")]
3288 pub cusip: Option<CusipIdentifier>,
3289 #[serde(rename = "CTA", skip_serializing_if = "Option::is_none")]
3290 pub cta: Option<ConsolidatedTapeAssociationIdentifier>,
3291 #[serde(rename = "Vlrn", skip_serializing_if = "Option::is_none")]
3292 pub vlrn: Option<ValorenIdentifier>,
3293 #[serde(rename = "SEDOL", skip_serializing_if = "Option::is_none")]
3294 pub sedol: Option<SedolIdentifier>,
3295 #[serde(rename = "RIC", skip_serializing_if = "Option::is_none")]
3296 pub ric: Option<RicIdentifier>,
3297 #[serde(rename = "Cmon", skip_serializing_if = "Option::is_none")]
3298 pub cmon: Option<EuroclearClearstreamIdentifier>,
3299 #[serde(rename = "Belgn", skip_serializing_if = "Option::is_none")]
3300 pub belgn: Option<BelgianIdentifier>,
3301 #[serde(rename = "Wrtppr", skip_serializing_if = "Option::is_none")]
3302 pub wrtppr: Option<WertpapierIdentifier>,
3303 #[serde(rename = "OthrPrtryId", skip_serializing_if = "Option::is_none")]
3304 pub othr_prtry_id: Option<AlternateSecurityIdentification7>,
3305 #[serde(rename = "QUICK", skip_serializing_if = "Option::is_none")]
3306 pub quick: Option<QuickIdentifier>,
3307 #[serde(rename = "ISIN", skip_serializing_if = "Option::is_none")]
3308 pub isin: Option<IsinOct2015Identifier>,
3309 #[serde(rename = "Dtch", skip_serializing_if = "Option::is_none")]
3310 pub dtch: Option<DutchIdentifier>,
3311 #[serde(rename = "SCVM", skip_serializing_if = "Option::is_none")]
3312 pub scvm: Option<SicovamIdentifier>,
3313}
3314#[derive(
3315 Debug,
3316 Default,
3317 Clone,
3318 PartialEq,
3319 ::serde::Serialize,
3320 ::serde::Deserialize,
3321 ::derive_builder::Builder,
3322 ::validator::Validate,
3323)]
3324pub struct SecurityIdentification25Choice {
3325 #[serde(flatten)]
3326 pub value: SecurityIdentification25ChoiceEnum,
3327}
3328#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3329pub enum TradeTransactionCondition5Code {
3330 #[serde(rename = "XCPN")]
3331 Xcpn,
3332 #[serde(rename = "CCPN")]
3333 Ccpn,
3334 #[default]
3335 Unknown,
3336}
3337#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3338pub enum RoundingDirection2Code {
3339 #[serde(rename = "RDUP")]
3340 Rdup,
3341 #[serde(rename = "RDWN")]
3342 Rdwn,
3343 #[default]
3344 Unknown,
3345}
3346#[derive(
3347 Debug,
3348 Default,
3349 Clone,
3350 PartialEq,
3351 ::serde::Serialize,
3352 ::serde::Deserialize,
3353 ::derive_builder::Builder,
3354 ::validator::Validate,
3355)]
3356pub struct AdditionalReference8 {
3357 #[validate]
3358 #[serde(rename = "Ref")]
3359 pub r#ref: Max35Text,
3360 #[serde(rename = "RefIssr", skip_serializing_if = "Option::is_none")]
3361 pub ref_issr: Option<PartyIdentification113>,
3362 #[serde(rename = "MsgNm", skip_serializing_if = "Option::is_none")]
3363 pub msg_nm: Option<Max35Text>,
3364}
3365#[derive(
3366 Debug,
3367 Default,
3368 Clone,
3369 PartialEq,
3370 ::serde::Serialize,
3371 ::serde::Deserialize,
3372 ::derive_builder::Builder,
3373 ::validator::Validate,
3374)]
3375pub struct Number {
3376 #[serde(rename = "$text")]
3377 pub value: f64,
3378}
3379#[derive(
3380 Debug,
3381 Default,
3382 Clone,
3383 PartialEq,
3384 ::serde::Serialize,
3385 ::serde::Deserialize,
3386 ::derive_builder::Builder,
3387 ::validator::Validate,
3388)]
3389pub struct QuickIdentifier {
3390 #[serde(rename = "$text")]
3391 pub value: String,
3392}
3393#[derive(
3394 Debug,
3395 Default,
3396 Clone,
3397 PartialEq,
3398 ::serde::Serialize,
3399 ::serde::Deserialize,
3400 ::derive_builder::Builder,
3401 ::validator::Validate,
3402)]
3403pub struct CountryAndResidentialStatusType2 {
3404 #[serde(rename = "Ctry")]
3405 pub ctry: CountryCode,
3406 #[serde(rename = "ResdtlSts")]
3407 pub resdtl_sts: ResidentialStatus1Code,
3408}
3409#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3410pub enum FormOfSecurity1Code {
3411 #[serde(rename = "BEAR")]
3412 Bear,
3413 #[serde(rename = "REGD")]
3414 Regd,
3415 #[default]
3416 Unknown,
3417}
3418#[derive(
3419 Debug,
3420 Default,
3421 Clone,
3422 PartialEq,
3423 ::serde::Serialize,
3424 ::serde::Deserialize,
3425 ::derive_builder::Builder,
3426 ::validator::Validate,
3427)]
3428pub struct IsoYearMonth {
3429 #[validate(regex = "ISO_YEAR_MONTH_REGEX")]
3430 #[serde(rename = "$text")]
3431 pub value: String,
3432}
3433#[derive(
3434 Debug,
3435 Default,
3436 Clone,
3437 PartialEq,
3438 ::serde::Serialize,
3439 ::serde::Deserialize,
3440 ::derive_builder::Builder,
3441 ::validator::Validate,
3442)]
3443pub struct ActiveCurrencyAndAmount {
3444 #[serde(rename = "ActiveCurrencyAndAmount")]
3445 pub value: ActiveCurrencyAndAmountSimpleType,
3446 #[serde(rename = "@Ccy")]
3447 pub ccy: ActiveCurrencyCode,
3448}
3449#[derive(
3450 Debug,
3451 Default,
3452 Clone,
3453 PartialEq,
3454 ::serde::Serialize,
3455 ::serde::Deserialize,
3456 ::derive_builder::Builder,
3457 ::validator::Validate,
3458)]
3459pub struct ActiveOrHistoricCurrencyAndAmount {
3460 #[serde(rename = "ActiveOrHistoricCurrencyAndAmount")]
3461 pub value: ActiveOrHistoricCurrencyAndAmountSimpleType,
3462 #[serde(rename = "@Ccy")]
3463 pub ccy: ActiveOrHistoricCurrencyCode,
3464}
3465#[derive(
3466 Debug,
3467 Default,
3468 Clone,
3469 PartialEq,
3470 ::serde::Serialize,
3471 ::serde::Deserialize,
3472 ::derive_builder::Builder,
3473 ::validator::Validate,
3474)]
3475pub struct ChargeOrCommissionDiscount1 {
3476 #[serde(rename = "Amt", skip_serializing_if = "Option::is_none")]
3477 pub amt: Option<ActiveCurrencyAndAmount>,
3478 #[serde(rename = "Rate", skip_serializing_if = "Option::is_none")]
3479 pub rate: Option<PercentageRate>,
3480 #[serde(rename = "Bsis", skip_serializing_if = "Option::is_none")]
3481 pub bsis: Option<WaivingInstruction2Choice>,
3482}
3483#[derive(
3484 Debug,
3485 Default,
3486 Clone,
3487 PartialEq,
3488 ::serde::Serialize,
3489 ::serde::Deserialize,
3490 ::derive_builder::Builder,
3491 ::validator::Validate,
3492)]
3493pub struct BranchData {
3494 #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
3495 pub id: Option<Max35Text>,
3496 #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
3497 pub nm: Option<Max35Text>,
3498 #[serde(rename = "PstlAdr", skip_serializing_if = "Option::is_none")]
3499 pub pstl_adr: Option<PostalAddress1>,
3500}
3501#[derive(
3502 Debug,
3503 Default,
3504 Clone,
3505 PartialEq,
3506 ::serde::Serialize,
3507 ::serde::Deserialize,
3508 ::derive_builder::Builder,
3509 ::validator::Validate,
3510)]
3511pub struct ExemptionReason1ChoiceEnum {
3512 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
3513 pub cd: Option<TaxExemptReason1Code>,
3514 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
3515 pub prtry: Option<GenericIdentification47>,
3516}
3517#[derive(
3518 Debug,
3519 Default,
3520 Clone,
3521 PartialEq,
3522 ::serde::Serialize,
3523 ::serde::Deserialize,
3524 ::derive_builder::Builder,
3525 ::validator::Validate,
3526)]
3527pub struct ExemptionReason1Choice {
3528 #[serde(flatten)]
3529 pub value: ExemptionReason1ChoiceEnum,
3530}
3531#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3532pub enum FundCashAccount2Code {
3533 #[serde(rename = "CASH")]
3534 Cash,
3535 #[serde(rename = "CPFO")]
3536 Cpfo,
3537 #[serde(rename = "CPFS")]
3538 Cpfs,
3539 #[serde(rename = "SRSA")]
3540 Srsa,
3541 #[default]
3542 Unknown,
3543}
3544#[derive(
3545 Debug,
3546 Default,
3547 Clone,
3548 PartialEq,
3549 ::serde::Serialize,
3550 ::serde::Deserialize,
3551 ::derive_builder::Builder,
3552 ::validator::Validate,
3553)]
3554pub struct GenericIdentification47 {
3555 #[validate]
3556 #[serde(rename = "Id")]
3557 pub id: Exact4AlphaNumericText,
3558 #[validate]
3559 #[serde(rename = "Issr")]
3560 pub issr: Max4AlphaNumericText,
3561 #[serde(rename = "SchmeNm", skip_serializing_if = "Option::is_none")]
3562 pub schme_nm: Option<Max4AlphaNumericText>,
3563}
3564#[derive(
3565 Debug,
3566 Default,
3567 Clone,
3568 PartialEq,
3569 ::serde::Serialize,
3570 ::serde::Deserialize,
3571 ::derive_builder::Builder,
3572 ::validator::Validate,
3573)]
3574pub struct OrderBreakdownType1ChoiceEnum {
3575 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
3576 pub cd: Option<FundOrderType5Code>,
3577 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
3578 pub prtry: Option<GenericIdentification47>,
3579}
3580#[derive(
3581 Debug,
3582 Default,
3583 Clone,
3584 PartialEq,
3585 ::serde::Serialize,
3586 ::serde::Deserialize,
3587 ::derive_builder::Builder,
3588 ::validator::Validate,
3589)]
3590pub struct OrderBreakdownType1Choice {
3591 #[serde(flatten)]
3592 pub value: OrderBreakdownType1ChoiceEnum,
3593}
3594#[derive(
3595 Debug,
3596 Default,
3597 Clone,
3598 PartialEq,
3599 ::serde::Serialize,
3600 ::serde::Deserialize,
3601 ::derive_builder::Builder,
3602 ::validator::Validate,
3603)]
3604pub struct OrderWaiver1 {
3605 #[validate(length(min = 0,))]
3606 #[serde(rename = "OrdrWvrRsn", default)]
3607 pub ordr_wvr_rsn: Vec<OrderWaiverReason3Choice>,
3608 #[serde(rename = "InfVal", skip_serializing_if = "Option::is_none")]
3609 pub inf_val: Option<Max350Text>,
3610}
3611#[derive(
3612 Debug,
3613 Default,
3614 Clone,
3615 PartialEq,
3616 ::serde::Serialize,
3617 ::serde::Deserialize,
3618 ::derive_builder::Builder,
3619 ::validator::Validate,
3620)]
3621pub struct PercentageRate {
3622 #[serde(rename = "$text")]
3623 pub value: f64,
3624}
3625#[derive(
3626 Debug,
3627 Default,
3628 Clone,
3629 PartialEq,
3630 ::serde::Serialize,
3631 ::serde::Deserialize,
3632 ::derive_builder::Builder,
3633 ::validator::Validate,
3634)]
3635pub struct PriceValue1 {
3636 #[validate]
3637 #[serde(rename = "Amt")]
3638 pub amt: ActiveCurrencyAnd13DecimalAmount,
3639}
3640#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3641pub enum SafekeepingPlace1Code {
3642 #[serde(rename = "CUST")]
3643 Cust,
3644 #[serde(rename = "ICSD")]
3645 Icsd,
3646 #[serde(rename = "NCSD")]
3647 Ncsd,
3648 #[serde(rename = "SHHE")]
3649 Shhe,
3650 #[default]
3651 Unknown,
3652}
3653#[derive(
3654 Debug,
3655 Default,
3656 Clone,
3657 PartialEq,
3658 ::serde::Serialize,
3659 ::serde::Deserialize,
3660 ::derive_builder::Builder,
3661 ::validator::Validate,
3662)]
3663pub struct Max140Text {
3664 #[validate(length(min = 1, max = 140,))]
3665 #[serde(rename = "$text")]
3666 pub value: String,
3667}
3668#[derive(
3669 Debug,
3670 Default,
3671 Clone,
3672 PartialEq,
3673 ::serde::Serialize,
3674 ::serde::Deserialize,
3675 ::derive_builder::Builder,
3676 ::validator::Validate,
3677)]
3678pub struct SafekeepingPlaceTypeAndAnyBicIdentifier1 {
3679 #[serde(rename = "SfkpgPlcTp")]
3680 pub sfkpg_plc_tp: SafekeepingPlace1Code,
3681 #[validate]
3682 #[serde(rename = "Id")]
3683 pub id: AnyBicIdentifier,
3684}
3685#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3686pub enum SourceOfCash1Code {
3687 #[serde(rename = "ALMY")]
3688 Almy,
3689 #[serde(rename = "CASH")]
3690 Cash,
3691 #[serde(rename = "COMP")]
3692 Comp,
3693 #[serde(rename = "EMIN")]
3694 Emin,
3695 #[serde(rename = "GIFT")]
3696 Gift,
3697 #[serde(rename = "INHE")]
3698 Inhe,
3699 #[serde(rename = "INLQ")]
3700 Inlq,
3701 #[serde(rename = "REST")]
3702 Rest,
3703 #[serde(rename = "REDM")]
3704 Redm,
3705 #[serde(rename = "REPY")]
3706 Repy,
3707 #[serde(rename = "SEAQ")]
3708 Seaq,
3709 #[serde(rename = "SALE")]
3710 Sale,
3711 #[serde(rename = "SVGS")]
3712 Svgs,
3713 #[serde(rename = "SELF")]
3714 XSelf,
3715 #[serde(rename = "WINS")]
3716 Wins,
3717 #[default]
3718 Unknown,
3719}
3720#[derive(
3721 Debug,
3722 Default,
3723 Clone,
3724 PartialEq,
3725 ::serde::Serialize,
3726 ::serde::Deserialize,
3727 ::derive_builder::Builder,
3728 ::validator::Validate,
3729)]
3730pub struct CountryCode {
3731 #[validate(regex = "COUNTRY_CODE_REGEX")]
3732 #[serde(rename = "$text")]
3733 pub value: String,
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 RussianCentralBankIdentificationCodeIdentifier {
3746 #[validate(regex = "RUSSIAN_CENTRAL_BANK_IDENTIFICATION_CODE_IDENTIFIER_REGEX")]
3747 #[serde(rename = "$text")]
3748 pub value: String,
3749}
3750#[derive(
3751 Debug,
3752 Default,
3753 Clone,
3754 PartialEq,
3755 ::serde::Serialize,
3756 ::serde::Deserialize,
3757 ::derive_builder::Builder,
3758 ::validator::Validate,
3759)]
3760pub struct OtherIdentification3ChoiceEnum {
3761 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
3762 pub prtry: Option<GenericIdentification47>,
3763 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
3764 pub cd: Option<PartyIdentificationType7Code>,
3765}
3766#[derive(
3767 Debug,
3768 Default,
3769 Clone,
3770 PartialEq,
3771 ::serde::Serialize,
3772 ::serde::Deserialize,
3773 ::derive_builder::Builder,
3774 ::validator::Validate,
3775)]
3776pub struct OtherIdentification3Choice {
3777 #[serde(flatten)]
3778 pub value: OtherIdentification3ChoiceEnum,
3779}
3780#[derive(
3781 Debug,
3782 Default,
3783 Clone,
3784 PartialEq,
3785 ::serde::Serialize,
3786 ::serde::Deserialize,
3787 ::derive_builder::Builder,
3788 ::validator::Validate,
3789)]
3790pub struct SubAccount6 {
3791 #[validate]
3792 #[serde(rename = "Id")]
3793 pub id: Max35Text,
3794 #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
3795 pub nm: Option<Max35Text>,
3796 #[serde(rename = "Chrtc", skip_serializing_if = "Option::is_none")]
3797 pub chrtc: Option<Max35Text>,
3798 #[serde(rename = "AcctDsgnt", skip_serializing_if = "Option::is_none")]
3799 pub acct_dsgnt: Option<Max35Text>,
3800}
3801#[derive(
3802 Debug,
3803 Default,
3804 Clone,
3805 PartialEq,
3806 ::serde::Serialize,
3807 ::serde::Deserialize,
3808 ::derive_builder::Builder,
3809 ::validator::Validate,
3810)]
3811pub struct SpanishDomesticInterbankingIdentifier {
3812 #[validate(regex = "SPANISH_DOMESTIC_INTERBANKING_IDENTIFIER_REGEX")]
3813 #[serde(rename = "$text")]
3814 pub value: String,
3815}
3816#[derive(
3817 Debug,
3818 Default,
3819 Clone,
3820 PartialEq,
3821 ::serde::Serialize,
3822 ::serde::Deserialize,
3823 ::derive_builder::Builder,
3824 ::validator::Validate,
3825)]
3826pub struct Tax32 {
3827 #[serde(rename = "Tp")]
3828 pub tp: TaxType3Choice,
3829 #[serde(rename = "InftvAmt", skip_serializing_if = "Option::is_none")]
3830 pub inftv_amt: Option<ActiveCurrencyAndAmount>,
3831 #[serde(rename = "InftvRate", skip_serializing_if = "Option::is_none")]
3832 pub inftv_rate: Option<PercentageRate>,
3833 #[serde(rename = "Ctry", skip_serializing_if = "Option::is_none")]
3834 pub ctry: Option<CountryCode>,
3835 #[validate]
3836 #[serde(rename = "XmptnInd")]
3837 pub xmptn_ind: YesNoIndicator,
3838 #[serde(rename = "XmptnRsn", skip_serializing_if = "Option::is_none")]
3839 pub xmptn_rsn: Option<ExemptionReason1Choice>,
3840 #[serde(rename = "RcptId", skip_serializing_if = "Option::is_none")]
3841 pub rcpt_id: Option<PartyIdentification113>,
3842 #[serde(rename = "TaxClctnDtls", skip_serializing_if = "Option::is_none")]
3843 pub tax_clctn_dtls: Option<TaxCalculationInformation10>,
3844}
3845#[derive(
3846 Debug,
3847 Default,
3848 Clone,
3849 PartialEq,
3850 ::serde::Serialize,
3851 ::serde::Deserialize,
3852 ::derive_builder::Builder,
3853 ::validator::Validate,
3854)]
3855pub struct TaxBasis1ChoiceEnum {
3856 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
3857 pub prtry: Option<GenericIdentification47>,
3858 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
3859 pub cd: Option<TaxationBasis2Code>,
3860}
3861#[derive(
3862 Debug,
3863 Default,
3864 Clone,
3865 PartialEq,
3866 ::serde::Serialize,
3867 ::serde::Deserialize,
3868 ::derive_builder::Builder,
3869 ::validator::Validate,
3870)]
3871pub struct TaxBasis1Choice {
3872 #[serde(flatten)]
3873 pub value: TaxBasis1ChoiceEnum,
3874}
3875#[derive(
3876 Debug,
3877 Default,
3878 Clone,
3879 PartialEq,
3880 ::serde::Serialize,
3881 ::serde::Deserialize,
3882 ::derive_builder::Builder,
3883 ::validator::Validate,
3884)]
3885pub struct TotalFeesAndTaxes40 {
3886 #[serde(rename = "TtlOvrhdApld", skip_serializing_if = "Option::is_none")]
3887 pub ttl_ovrhd_apld: Option<ActiveCurrencyAndAmount>,
3888 #[serde(rename = "TtlFees", skip_serializing_if = "Option::is_none")]
3889 pub ttl_fees: Option<ActiveCurrencyAndAmount>,
3890 #[serde(rename = "TtlTaxs", skip_serializing_if = "Option::is_none")]
3891 pub ttl_taxs: Option<ActiveCurrencyAndAmount>,
3892 #[serde(rename = "ComrclAgrmtRef", skip_serializing_if = "Option::is_none")]
3893 pub comrcl_agrmt_ref: Option<Max35Text>,
3894 #[validate(length(min = 0,))]
3895 #[serde(rename = "IndvFee", default)]
3896 pub indv_fee: Vec<Fee2>,
3897 #[validate(length(min = 0,))]
3898 #[serde(rename = "IndvTax", default)]
3899 pub indv_tax: Vec<Tax31>,
3900}
3901#[derive(
3902 Debug,
3903 Default,
3904 Clone,
3905 PartialEq,
3906 ::serde::Serialize,
3907 ::serde::Deserialize,
3908 ::derive_builder::Builder,
3909 ::validator::Validate,
3910)]
3911pub struct InvestmentAccount60 {
3912 #[serde(rename = "AcctId", skip_serializing_if = "Option::is_none")]
3913 pub acct_id: Option<Max35Text>,
3914 #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
3915 pub tp: Option<InvestmentAccountType1Choice>,
3916}
3917#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3918pub enum LateReport1Code {
3919 #[serde(rename = "LAT1")]
3920 Lat1,
3921 #[serde(rename = "LAT2")]
3922 Lat2,
3923 #[default]
3924 Unknown,
3925}
3926#[derive(
3927 Debug,
3928 Default,
3929 Clone,
3930 PartialEq,
3931 ::serde::Serialize,
3932 ::serde::Deserialize,
3933 ::derive_builder::Builder,
3934 ::validator::Validate,
3935)]
3936pub struct FinancialInstrument57 {
3937 #[serde(rename = "Id")]
3938 pub id: SecurityIdentification25Choice,
3939 #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
3940 pub nm: Option<Max350Text>,
3941 #[serde(rename = "ShrtNm", skip_serializing_if = "Option::is_none")]
3942 pub shrt_nm: Option<Max35Text>,
3943 #[serde(rename = "SplmtryId", skip_serializing_if = "Option::is_none")]
3944 pub splmtry_id: Option<Max35Text>,
3945 #[serde(rename = "ClssTp", skip_serializing_if = "Option::is_none")]
3946 pub clss_tp: Option<Max35Text>,
3947 #[serde(rename = "SctiesForm", skip_serializing_if = "Option::is_none")]
3948 pub scties_form: Option<FormOfSecurity1Code>,
3949 #[serde(rename = "DstrbtnPlcy", skip_serializing_if = "Option::is_none")]
3950 pub dstrbtn_plcy: Option<DistributionPolicy1Code>,
3951 #[serde(rename = "PdctGrp", skip_serializing_if = "Option::is_none")]
3952 pub pdct_grp: Option<Max140Text>,
3953 #[serde(rename = "SrsId", skip_serializing_if = "Option::is_none")]
3954 pub srs_id: Option<Series1>,
3955}
3956#[derive(
3957 Debug,
3958 Default,
3959 Clone,
3960 PartialEq,
3961 ::serde::Serialize,
3962 ::serde::Deserialize,
3963 ::derive_builder::Builder,
3964 ::validator::Validate,
3965)]
3966pub struct Iban2007Identifier {
3967 #[validate(regex = "IBAN_2007_IDENTIFIER_REGEX")]
3968 #[serde(rename = "$text")]
3969 pub value: String,
3970}
3971#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3972pub enum ResidentialStatus1Code {
3973 #[serde(rename = "RESI")]
3974 Resi,
3975 #[serde(rename = "PRES")]
3976 Pres,
3977 #[serde(rename = "NRES")]
3978 Nres,
3979 #[default]
3980 Unknown,
3981}
3982#[derive(
3983 Debug,
3984 Default,
3985 Clone,
3986 PartialEq,
3987 ::serde::Serialize,
3988 ::serde::Deserialize,
3989 ::derive_builder::Builder,
3990 ::validator::Validate,
3991)]
3992pub struct DirectDebitMandate6 {
3993 #[validate]
3994 #[serde(rename = "DbtrAcct")]
3995 pub dbtr_acct: AccountIdentificationAndName5,
3996 #[serde(rename = "Dbtr", skip_serializing_if = "Option::is_none")]
3997 pub dbtr: Option<PartyIdentification113>,
3998 #[serde(rename = "DbtrTaxIdNb", skip_serializing_if = "Option::is_none")]
3999 pub dbtr_tax_id_nb: Option<Max35Text>,
4000 #[serde(rename = "DbtrNtlRegnNb", skip_serializing_if = "Option::is_none")]
4001 pub dbtr_ntl_regn_nb: Option<Max35Text>,
4002 #[serde(rename = "Cdtr", skip_serializing_if = "Option::is_none")]
4003 pub cdtr: Option<PartyIdentification113>,
4004 #[validate]
4005 #[serde(rename = "DbtrAgt")]
4006 pub dbtr_agt: FinancialInstitutionIdentification10,
4007 #[serde(rename = "DbtrAgtBrnch", skip_serializing_if = "Option::is_none")]
4008 pub dbtr_agt_brnch: Option<BranchData>,
4009 #[serde(rename = "CdtrAgt", skip_serializing_if = "Option::is_none")]
4010 pub cdtr_agt: Option<FinancialInstitutionIdentification10>,
4011 #[serde(rename = "CdtrAgtBrnch", skip_serializing_if = "Option::is_none")]
4012 pub cdtr_agt_brnch: Option<BranchData>,
4013 #[serde(rename = "RegnId", skip_serializing_if = "Option::is_none")]
4014 pub regn_id: Option<Max35Text>,
4015 #[serde(rename = "MndtId", skip_serializing_if = "Option::is_none")]
4016 pub mndt_id: Option<Max35Text>,
4017}
4018#[derive(
4019 Debug,
4020 Default,
4021 Clone,
4022 PartialEq,
4023 ::serde::Serialize,
4024 ::serde::Deserialize,
4025 ::derive_builder::Builder,
4026 ::validator::Validate,
4027)]
4028pub struct IndividualPerson32 {
4029 #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
4030 pub nm: Option<Max350Text>,
4031 #[serde(rename = "BirthDt", skip_serializing_if = "Option::is_none")]
4032 pub birth_dt: Option<IsoDate>,
4033 #[serde(rename = "CtryAndResdtlSts", skip_serializing_if = "Option::is_none")]
4034 pub ctry_and_resdtl_sts: Option<CountryAndResidentialStatusType2>,
4035 #[validate(length(min = 0,))]
4036 #[serde(rename = "OthrId", default)]
4037 pub othr_id: Vec<GenericIdentification164>,
4038}
4039#[derive(
4040 Debug,
4041 Default,
4042 Clone,
4043 PartialEq,
4044 ::serde::Serialize,
4045 ::serde::Deserialize,
4046 ::derive_builder::Builder,
4047 ::validator::Validate,
4048)]
4049pub struct OrderWaiverReason3ChoiceEnum {
4050 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
4051 pub cd: Option<OrderWaiverReason1Code>,
4052 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
4053 pub prtry: Option<GenericIdentification47>,
4054}
4055#[derive(
4056 Debug,
4057 Default,
4058 Clone,
4059 PartialEq,
4060 ::serde::Serialize,
4061 ::serde::Deserialize,
4062 ::derive_builder::Builder,
4063 ::validator::Validate,
4064)]
4065pub struct OrderWaiverReason3Choice {
4066 #[serde(flatten)]
4067 pub value: OrderWaiverReason3ChoiceEnum,
4068}
4069#[derive(
4070 Debug,
4071 Default,
4072 Clone,
4073 PartialEq,
4074 ::serde::Serialize,
4075 ::serde::Deserialize,
4076 ::derive_builder::Builder,
4077 ::validator::Validate,
4078)]
4079pub struct ChipsUniversalIdentifier {
4080 #[validate(regex = "CHIPS_UNIVERSAL_IDENTIFIER_REGEX")]
4081 #[serde(rename = "$text")]
4082 pub value: String,
4083}
4084#[derive(
4085 Debug,
4086 Default,
4087 Clone,
4088 PartialEq,
4089 ::serde::Serialize,
4090 ::serde::Deserialize,
4091 ::derive_builder::Builder,
4092 ::validator::Validate,
4093)]
4094pub struct FundSettlementParameters12 {
4095 #[serde(rename = "SttlmDt", skip_serializing_if = "Option::is_none")]
4096 pub sttlm_dt: Option<IsoDate>,
4097 #[validate]
4098 #[serde(rename = "SttlmPlc")]
4099 pub sttlm_plc: PartyIdentification113,
4100 #[serde(rename = "SfkpgPlc", skip_serializing_if = "Option::is_none")]
4101 pub sfkpg_plc: Option<SafekeepingPlaceFormat8Choice>,
4102 #[serde(rename = "SctiesSttlmSysId", skip_serializing_if = "Option::is_none")]
4103 pub scties_sttlm_sys_id: Option<Max35Text>,
4104 #[validate(length(min = 0,))]
4105 #[serde(rename = "TradTxCond", default)]
4106 pub trad_tx_cond: Vec<TradeTransactionCondition8Choice>,
4107 #[validate(length(min = 0,))]
4108 #[serde(rename = "SttlmTxCond", default)]
4109 pub sttlm_tx_cond: Vec<SettlementTransactionCondition30Choice>,
4110 #[serde(rename = "RcvgSdDtls", skip_serializing_if = "Option::is_none")]
4111 pub rcvg_sd_dtls: Option<ReceivingPartiesAndAccount16>,
4112 #[validate]
4113 #[serde(rename = "DlvrgSdDtls")]
4114 pub dlvrg_sd_dtls: DeliveringPartiesAndAccount16,
4115}
4116#[derive(
4117 Debug,
4118 Default,
4119 Clone,
4120 PartialEq,
4121 ::serde::Serialize,
4122 ::serde::Deserialize,
4123 ::derive_builder::Builder,
4124 ::validator::Validate,
4125)]
4126pub struct SubscriptionMultipleExecution5 {
4127 #[serde(rename = "AmdmntInd", skip_serializing_if = "Option::is_none")]
4128 pub amdmnt_ind: Option<YesNoIndicator>,
4129 #[serde(rename = "MstrRef", skip_serializing_if = "Option::is_none")]
4130 pub mstr_ref: Option<Max35Text>,
4131 #[serde(rename = "PlcOfTrad", skip_serializing_if = "Option::is_none")]
4132 pub plc_of_trad: Option<PlaceOfTradeIdentification1Choice>,
4133 #[serde(rename = "OrdrDtTm", skip_serializing_if = "Option::is_none")]
4134 pub ordr_dt_tm: Option<IsoDateTime>,
4135 #[serde(rename = "RcvdDtTm", skip_serializing_if = "Option::is_none")]
4136 pub rcvd_dt_tm: Option<IsoDateTime>,
4137 #[serde(rename = "ReqdFutrTradDt", skip_serializing_if = "Option::is_none")]
4138 pub reqd_futr_trad_dt: Option<IsoDate>,
4139 #[serde(rename = "CxlRght", skip_serializing_if = "Option::is_none")]
4140 pub cxl_rght: Option<CancellationRight1Choice>,
4141 #[validate]
4142 #[serde(rename = "InvstmtAcctDtls")]
4143 pub invstmt_acct_dtls: InvestmentAccount58,
4144 #[validate(length(min = 0,))]
4145 #[serde(rename = "BnfcryDtls", default)]
4146 pub bnfcry_dtls: Vec<IndividualPerson32>,
4147 #[validate(length(min = 1,))]
4148 #[serde(rename = "IndvExctnDtls", default)]
4149 pub indv_exctn_dtls: Vec<SubscriptionExecution13>,
4150 #[serde(rename = "TtlSttlmAmt", skip_serializing_if = "Option::is_none")]
4151 pub ttl_sttlm_amt: Option<ActiveCurrencyAndAmount>,
4152 #[serde(rename = "BlkCshSttlmDtls", skip_serializing_if = "Option::is_none")]
4153 pub blk_csh_sttlm_dtls: Option<PaymentTransaction70>,
4154}
4155#[derive(
4156 Debug,
4157 Default,
4158 Clone,
4159 PartialEq,
4160 ::serde::Serialize,
4161 ::serde::Deserialize,
4162 ::derive_builder::Builder,
4163 ::validator::Validate,
4164)]
4165pub struct TickerIdentifier {
4166 #[validate(length(min = 1, max = 35,))]
4167 #[serde(rename = "$text")]
4168 pub value: String,
4169}
4170#[derive(
4171 Debug,
4172 Default,
4173 Clone,
4174 PartialEq,
4175 ::serde::Serialize,
4176 ::serde::Deserialize,
4177 ::derive_builder::Builder,
4178 ::validator::Validate,
4179)]
4180pub struct WertpapierIdentifier {
4181 #[serde(rename = "$text")]
4182 pub value: String,
4183}
4184#[derive(
4185 Debug,
4186 Default,
4187 Clone,
4188 PartialEq,
4189 ::serde::Serialize,
4190 ::serde::Deserialize,
4191 ::derive_builder::Builder,
4192 ::validator::Validate,
4193)]
4194pub struct TypeOfPrice46ChoiceEnum {
4195 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
4196 pub prtry: Option<GenericIdentification47>,
4197 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
4198 pub cd: Option<TypeOfPrice10Code>,
4199}
4200#[derive(
4201 Debug,
4202 Default,
4203 Clone,
4204 PartialEq,
4205 ::serde::Serialize,
4206 ::serde::Deserialize,
4207 ::derive_builder::Builder,
4208 ::validator::Validate,
4209)]
4210pub struct TypeOfPrice46Choice {
4211 #[serde(flatten)]
4212 pub value: TypeOfPrice46ChoiceEnum,
4213}
4214#[derive(
4215 Debug,
4216 Default,
4217 Clone,
4218 PartialEq,
4219 ::serde::Serialize,
4220 ::serde::Deserialize,
4221 ::derive_builder::Builder,
4222 ::validator::Validate,
4223)]
4224pub struct TransactionChannelType1ChoiceEnum {
4225 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
4226 pub cd: Option<TransactionChannel2Code>,
4227 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
4228 pub prtry: Option<GenericIdentification47>,
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 TransactionChannelType1Choice {
4241 #[serde(flatten)]
4242 pub value: TransactionChannelType1ChoiceEnum,
4243}