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