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