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