1use validator::Validate;
22
23::lazy_static::lazy_static! {
24 static ref MIC_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Z0-9]{4,4}"#).unwrap();
25}
26
27::lazy_static::lazy_static! {
28 static ref MAX_3_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,3}"#).unwrap();
29}
30
31::lazy_static::lazy_static! {
32 static ref ACTIVE_CURRENCY_CODE_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Z]{3,3}"#).unwrap();
33}
34
35::lazy_static::lazy_static! {
36 static ref EXACT_4_ALPHA_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[a-zA-Z0-9]{4}"#).unwrap();
37}
38
39::lazy_static::lazy_static! {
40 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();
41}
42
43::lazy_static::lazy_static! {
44 static ref COUNTRY_CODE_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Z]{2,2}"#).unwrap();
45}
46
47::lazy_static::lazy_static! {
48 static ref IBAN_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[a-zA-Z]{2,2}[0-9]{2,2}[a-zA-Z0-9]{1,30}"#).unwrap();
49}
50
51::lazy_static::lazy_static! {
52 static ref EXACT_3_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{3}"#).unwrap();
53}
54
55::lazy_static::lazy_static! {
56 static ref CURRENCY_CODE_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Z]{3,3}"#).unwrap();
57}
58
59::lazy_static::lazy_static! {
60 static ref ACTIVE_OR_HISTORIC_CURRENCY_CODE_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Z]{3,3}"#).unwrap();
61}
62
63::lazy_static::lazy_static! {
64 static ref BIC_NON_FI_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();
65}
66
67::lazy_static::lazy_static! {
68 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();
69}
70
71::lazy_static::lazy_static! {
72 static ref BBAN_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[a-zA-Z0-9]{1,30}"#).unwrap();
73}
74
75::lazy_static::lazy_static! {
76 static ref ISIN_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Z0-9]{12,12}"#).unwrap();
77}
78
79::lazy_static::lazy_static! {
80 static ref ISO_20022_MESSAGE_IDENTIFICATION_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[a-z]{4}\.[0-9]{3}\.[0-9]{3}\.[0-9]{2}"#).unwrap();
81}
82
83::lazy_static::lazy_static! {
84 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();
85}
86
87::lazy_static::lazy_static! {
88 static ref CFI_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Z]{1,6}"#).unwrap();
89}
90
91::lazy_static::lazy_static! {
92 static ref EXACT_4_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{4}"#).unwrap();
93}
94
95::lazy_static::lazy_static! {
96 static ref MAX_4_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,4}"#).unwrap();
97}
98
99::lazy_static::lazy_static! {
100 static ref UPIC_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{8,17}"#).unwrap();
101}
102
103pub fn namespace() -> String {
105 "urn:iso:std:iso:20022:tech:xsd:setr.027.001.03".to_string()
106}
107
108#[derive(
109 Debug,
110 Default,
111 Clone,
112 PartialEq,
113 ::serde::Serialize,
114 ::serde::Deserialize,
115 ::derive_builder::Builder,
116 ::validator::Validate,
117)]
118pub struct MicIdentifier {
119 #[validate(regex = "MIC_IDENTIFIER_REGEX")]
120 #[serde(rename = "$text")]
121 pub value: String,
122}
123#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
124pub enum DeliveryReceiptType2Code {
125 #[serde(rename = "FREE")]
126 Free,
127 #[serde(rename = "APMT")]
128 Apmt,
129 #[default]
130 Unknown,
131}
132#[derive(
133 Debug,
134 Default,
135 Clone,
136 PartialEq,
137 ::serde::Serialize,
138 ::serde::Deserialize,
139 ::derive_builder::Builder,
140 ::validator::Validate,
141)]
142pub struct GenericIdentification20 {
143 #[validate]
144 #[serde(rename = "Id")]
145 pub id: Exact4AlphaNumericText,
146 #[validate]
147 #[serde(rename = "Issr")]
148 pub issr: Max35Text,
149 #[serde(rename = "SchmeNm", skip_serializing_if = "Option::is_none")]
150 pub schme_nm: Option<Max35Text>,
151}
152#[derive(
153 Debug,
154 Default,
155 Clone,
156 PartialEq,
157 ::serde::Serialize,
158 ::serde::Deserialize,
159 ::derive_builder::Builder,
160 ::validator::Validate,
161)]
162pub struct OtherPrices2 {
163 #[serde(rename = "Max", skip_serializing_if = "Option::is_none")]
164 pub max: Option<Price4>,
165 #[serde(rename = "Tx", skip_serializing_if = "Option::is_none")]
166 pub tx: Option<Price4>,
167 #[serde(rename = "MktBrkrComssn", skip_serializing_if = "Option::is_none")]
168 pub mkt_brkr_comssn: Option<Price4>,
169 #[serde(rename = "MrkdUp", skip_serializing_if = "Option::is_none")]
170 pub mrkd_up: Option<Price4>,
171 #[serde(rename = "MrkdDwn", skip_serializing_if = "Option::is_none")]
172 pub mrkd_dwn: Option<Price4>,
173 #[serde(rename = "NetDscld", skip_serializing_if = "Option::is_none")]
174 pub net_dscld: Option<Price4>,
175 #[serde(rename = "NetUdscld", skip_serializing_if = "Option::is_none")]
176 pub net_udscld: Option<Price4>,
177 #[serde(rename = "NtnlGrss", skip_serializing_if = "Option::is_none")]
178 pub ntnl_grss: Option<Price4>,
179 #[serde(rename = "BchmkWghtdAvrg", skip_serializing_if = "Option::is_none")]
180 pub bchmk_wghtd_avrg: Option<Price4>,
181 #[serde(rename = "AllMktsWghtdAvrg", skip_serializing_if = "Option::is_none")]
182 pub all_mkts_wghtd_avrg: Option<Price4>,
183 #[serde(rename = "Bchmk", skip_serializing_if = "Option::is_none")]
184 pub bchmk: Option<Price4>,
185 #[serde(rename = "OthrPric", skip_serializing_if = "Option::is_none")]
186 pub othr_pric: Option<Price4>,
187 #[serde(rename = "IndxPric", skip_serializing_if = "Option::is_none")]
188 pub indx_pric: Option<Price4>,
189 #[serde(rename = "RptdPric", skip_serializing_if = "Option::is_none")]
190 pub rptd_pric: Option<Price4>,
191 #[serde(rename = "RefPric", skip_serializing_if = "Option::is_none")]
192 pub ref_pric: Option<PriceInformation11>,
193}
194#[derive(
195 Debug,
196 Default,
197 Clone,
198 PartialEq,
199 ::serde::Serialize,
200 ::serde::Deserialize,
201 ::derive_builder::Builder,
202 ::validator::Validate,
203)]
204pub struct FinancialInstrumentQuantity18ChoiceEnum {
205 #[serde(rename = "Unit", skip_serializing_if = "Option::is_none")]
206 pub unit: Option<DecimalNumber>,
207 #[serde(rename = "FaceAmt", skip_serializing_if = "Option::is_none")]
208 pub face_amt: Option<ImpliedCurrencyAndAmount>,
209}
210#[derive(
211 Debug,
212 Default,
213 Clone,
214 PartialEq,
215 ::serde::Serialize,
216 ::serde::Deserialize,
217 ::derive_builder::Builder,
218 ::validator::Validate,
219)]
220pub struct FinancialInstrumentQuantity18Choice {
221 #[serde(flatten)]
222 pub value: FinancialInstrumentQuantity18ChoiceEnum,
223}
224#[derive(
225 Debug,
226 Default,
227 Clone,
228 PartialEq,
229 ::serde::Serialize,
230 ::serde::Deserialize,
231 ::derive_builder::Builder,
232 ::validator::Validate,
233)]
234pub struct SupplementaryData1<
235 A: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
236> {
237 #[serde(rename = "PlcAndNm", skip_serializing_if = "Option::is_none")]
238 pub plc_and_nm: Option<Max350Text>,
239 #[validate]
240 #[serde(rename = "Envlp")]
241 pub envlp: SupplementaryDataEnvelope1<A>,
242}
243#[derive(
244 Debug,
245 Default,
246 Clone,
247 PartialEq,
248 ::serde::Serialize,
249 ::serde::Deserialize,
250 ::derive_builder::Builder,
251 ::validator::Validate,
252)]
253pub struct SettlementDetails43 {
254 #[serde(rename = "SttlmTxTp")]
255 pub sttlm_tx_tp: SettlementTransactionType1Choice,
256 #[serde(rename = "HldInd", skip_serializing_if = "Option::is_none")]
257 pub hld_ind: Option<YesNoIndicator>,
258 #[serde(rename = "Prty", skip_serializing_if = "Option::is_none")]
259 pub prty: Option<PriorityNumeric3Choice>,
260 #[serde(rename = "SttlmInstrGnrtn", skip_serializing_if = "Option::is_none")]
261 pub sttlm_instr_gnrtn: Option<SettlementInstructionGeneration1Choice>,
262 #[validate(length(min = 0,))]
263 #[serde(rename = "SttlmTxCond", default)]
264 pub sttlm_tx_cond: Vec<SettlementTransactionCondition11Choice>,
265 #[serde(rename = "PrtlSttlmInd", skip_serializing_if = "Option::is_none")]
266 pub prtl_sttlm_ind: Option<YesNoIndicator>,
267 #[serde(rename = "BnfclOwnrsh", skip_serializing_if = "Option::is_none")]
268 pub bnfcl_ownrsh: Option<BeneficialOwnership3Choice>,
269 #[serde(rename = "BlckTrad", skip_serializing_if = "Option::is_none")]
270 pub blck_trad: Option<BlockTrade3Choice>,
271 #[serde(rename = "CCPElgblty", skip_serializing_if = "Option::is_none")]
272 pub ccp_elgblty: Option<CentralCounterPartyEligibility3Choice>,
273 #[serde(rename = "CshClrSys", skip_serializing_if = "Option::is_none")]
274 pub csh_clr_sys: Option<CashSettlementSystem3Choice>,
275 #[serde(rename = "XpsrTp", skip_serializing_if = "Option::is_none")]
276 pub xpsr_tp: Option<ExposureType9Choice>,
277 #[serde(rename = "FxStgInstr", skip_serializing_if = "Option::is_none")]
278 pub fx_stg_instr: Option<FxStandingInstruction3Choice>,
279 #[serde(rename = "CcyToBuyOrSell", skip_serializing_if = "Option::is_none")]
280 pub ccy_to_buy_or_sell: Option<CurrencyToBuyOrSell1Choice>,
281 #[serde(rename = "MktClntSd", skip_serializing_if = "Option::is_none")]
282 pub mkt_clnt_sd: Option<MarketClientSide3Choice>,
283 #[serde(rename = "NetgElgblty", skip_serializing_if = "Option::is_none")]
284 pub netg_elgblty: Option<NettingEligibility3Choice>,
285 #[serde(rename = "Regn", skip_serializing_if = "Option::is_none")]
286 pub regn: Option<Registration6Choice>,
287 #[serde(rename = "RpTp", skip_serializing_if = "Option::is_none")]
288 pub rp_tp: Option<RepurchaseType11Choice>,
289 #[serde(rename = "LglRstrctns", skip_serializing_if = "Option::is_none")]
290 pub lgl_rstrctns: Option<Restriction3Choice>,
291 #[serde(rename = "SctiesRTGS", skip_serializing_if = "Option::is_none")]
292 pub scties_rtgs: Option<SecuritiesRtgs3Choice>,
293 #[serde(rename = "SttlgCpcty", skip_serializing_if = "Option::is_none")]
294 pub sttlg_cpcty: Option<SettlingCapacity3Choice>,
295 #[serde(rename = "SttlmSysMtd", skip_serializing_if = "Option::is_none")]
296 pub sttlm_sys_mtd: Option<SettlementSystemMethod3Choice>,
297 #[serde(rename = "TaxCpcty", skip_serializing_if = "Option::is_none")]
298 pub tax_cpcty: Option<TaxCapacityParty3Choice>,
299 #[serde(rename = "StmpDtyInd", skip_serializing_if = "Option::is_none")]
300 pub stmp_dty_ind: Option<YesNoIndicator>,
301 #[serde(rename = "StmpDtyTaxBsis", skip_serializing_if = "Option::is_none")]
302 pub stmp_dty_tax_bsis: Option<GenericIdentification38>,
303 #[serde(rename = "Trckg", skip_serializing_if = "Option::is_none")]
304 pub trckg: Option<Tracking3Choice>,
305 #[serde(rename = "AutomtcBrrwg", skip_serializing_if = "Option::is_none")]
306 pub automtc_brrwg: Option<AutomaticBorrowing5Choice>,
307 #[serde(rename = "LttrOfGrnt", skip_serializing_if = "Option::is_none")]
308 pub lttr_of_grnt: Option<LetterOfGuarantee3Choice>,
309 #[serde(rename = "RtrLeg", skip_serializing_if = "Option::is_none")]
310 pub rtr_leg: Option<YesNoIndicator>,
311 #[serde(rename = "ModCxlAllwd", skip_serializing_if = "Option::is_none")]
312 pub mod_cxl_allwd: Option<ModificationCancellationAllowed3Choice>,
313 #[serde(rename = "ElgblForColl", skip_serializing_if = "Option::is_none")]
314 pub elgbl_for_coll: Option<YesNoIndicator>,
315}
316#[derive(
317 Debug,
318 Default,
319 Clone,
320 PartialEq,
321 ::serde::Serialize,
322 ::serde::Deserialize,
323 ::derive_builder::Builder,
324 ::validator::Validate,
325)]
326pub struct PartyIdentificationAndAccount77 {
327 #[serde(rename = "Id")]
328 pub id: PartyIdentification32Choice,
329 #[serde(rename = "AltrnId", skip_serializing_if = "Option::is_none")]
330 pub altrn_id: Option<AlternatePartyIdentification5>,
331 #[serde(rename = "SfkpgAcct", skip_serializing_if = "Option::is_none")]
332 pub sfkpg_acct: Option<Max35Text>,
333 #[serde(rename = "PrcgId", skip_serializing_if = "Option::is_none")]
334 pub prcg_id: Option<Max35Text>,
335 #[serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none")]
336 pub addtl_inf: Option<PartyTextInformation1>,
337}
338#[derive(
339 Debug,
340 Default,
341 Clone,
342 PartialEq,
343 ::serde::Serialize,
344 ::serde::Deserialize,
345 ::derive_builder::Builder,
346 ::validator::Validate,
347)]
348pub struct ActiveOrHistoricCurrencyAndAmount {
349 #[serde(rename = "ActiveOrHistoricCurrencyAndAmount")]
350 pub value: ActiveOrHistoricCurrencyAndAmountSimpleType,
351 #[serde(rename = "@Ccy")]
352 pub ccy: ActiveOrHistoricCurrencyCode,
353}
354#[derive(
355 Debug,
356 Default,
357 Clone,
358 PartialEq,
359 ::serde::Serialize,
360 ::serde::Deserialize,
361 ::derive_builder::Builder,
362 ::validator::Validate,
363)]
364pub struct Max3NumericText {
365 #[validate(regex = "MAX_3_NUMERIC_TEXT_REGEX")]
366 #[serde(rename = "$text")]
367 pub value: String,
368}
369#[derive(
370 Debug,
371 Default,
372 Clone,
373 PartialEq,
374 ::serde::Serialize,
375 ::serde::Deserialize,
376 ::derive_builder::Builder,
377 ::validator::Validate,
378)]
379pub struct CashSettlementSystem3ChoiceEnum {
380 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
381 pub cd: Option<CashSettlementSystem2Code>,
382 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
383 pub prtry: Option<GenericIdentification38>,
384}
385#[derive(
386 Debug,
387 Default,
388 Clone,
389 PartialEq,
390 ::serde::Serialize,
391 ::serde::Deserialize,
392 ::derive_builder::Builder,
393 ::validator::Validate,
394)]
395pub struct CashSettlementSystem3Choice {
396 #[serde(flatten)]
397 pub value: CashSettlementSystem3ChoiceEnum,
398}
399#[derive(
400 Debug,
401 Default,
402 Clone,
403 PartialEq,
404 ::serde::Serialize,
405 ::serde::Deserialize,
406 ::derive_builder::Builder,
407 ::validator::Validate,
408)]
409pub struct Restriction3ChoiceEnum {
410 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
411 pub cd: Option<OwnershipLegalRestrictions1Code>,
412 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
413 pub prtry: Option<GenericIdentification38>,
414}
415#[derive(
416 Debug,
417 Default,
418 Clone,
419 PartialEq,
420 ::serde::Serialize,
421 ::serde::Deserialize,
422 ::derive_builder::Builder,
423 ::validator::Validate,
424)]
425pub struct Restriction3Choice {
426 #[serde(flatten)]
427 pub value: Restriction3ChoiceEnum,
428}
429#[derive(
430 Debug,
431 Default,
432 Clone,
433 PartialEq,
434 ::serde::Serialize,
435 ::serde::Deserialize,
436 ::derive_builder::Builder,
437 ::validator::Validate,
438)]
439pub struct Reversible1ChoiceEnum {
440 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
441 pub cd: Option<Reversible1Code>,
442 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
443 pub prtry: Option<GenericIdentification38>,
444}
445#[derive(
446 Debug,
447 Default,
448 Clone,
449 PartialEq,
450 ::serde::Serialize,
451 ::serde::Deserialize,
452 ::derive_builder::Builder,
453 ::validator::Validate,
454)]
455pub struct Reversible1Choice {
456 #[serde(flatten)]
457 pub value: Reversible1ChoiceEnum,
458}
459#[derive(
460 Debug,
461 Default,
462 Clone,
463 PartialEq,
464 ::serde::Serialize,
465 ::serde::Deserialize,
466 ::derive_builder::Builder,
467 ::validator::Validate,
468)]
469pub struct ActiveCurrencyCode {
470 #[validate(regex = "ACTIVE_CURRENCY_CODE_REGEX")]
471 #[serde(rename = "$text")]
472 pub value: String,
473}
474#[derive(
475 Debug,
476 Default,
477 Clone,
478 PartialEq,
479 ::serde::Serialize,
480 ::serde::Deserialize,
481 ::derive_builder::Builder,
482 ::validator::Validate,
483)]
484pub struct SimpleIdentificationInformation2 {
485 #[validate]
486 #[serde(rename = "Id")]
487 pub id: Max34Text,
488}
489#[derive(
490 Debug,
491 Default,
492 Clone,
493 PartialEq,
494 ::serde::Serialize,
495 ::serde::Deserialize,
496 ::derive_builder::Builder,
497 ::validator::Validate,
498)]
499#[serde(rename = "Document")]
500pub struct Document<
501 A: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
502> {
503 #[validate]
504 #[serde(rename = "SctiesTradConf")]
505 pub scties_trad_conf: SecuritiesTradeConfirmationV03<A>,
506 #[serde(rename = "@xmlns", default = "namespace")]
507 pub xmlns: String,
508}
509#[derive(
510 Debug,
511 Default,
512 Clone,
513 PartialEq,
514 ::serde::Serialize,
515 ::serde::Deserialize,
516 ::derive_builder::Builder,
517 ::validator::Validate,
518)]
519pub struct PostalAddress8 {
520 #[serde(rename = "AdrTp", skip_serializing_if = "Option::is_none")]
521 pub adr_tp: Option<AddressType2Code>,
522 #[validate(length(min = 0, max = 5,))]
523 #[serde(rename = "AdrLine", default)]
524 pub adr_line: Vec<Max70Text>,
525 #[serde(rename = "StrtNm", skip_serializing_if = "Option::is_none")]
526 pub strt_nm: Option<Max70Text>,
527 #[serde(rename = "BldgNb", skip_serializing_if = "Option::is_none")]
528 pub bldg_nb: Option<Max16Text>,
529 #[serde(rename = "PstCd", skip_serializing_if = "Option::is_none")]
530 pub pst_cd: Option<Max16Text>,
531 #[serde(rename = "TwnNm", skip_serializing_if = "Option::is_none")]
532 pub twn_nm: Option<Max35Text>,
533 #[serde(rename = "CtrySubDvsn", skip_serializing_if = "Option::is_none")]
534 pub ctry_sub_dvsn: Option<Max35Text>,
535 #[serde(rename = "Ctry")]
536 pub ctry: CountryCode,
537}
538#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
539pub enum Registration1Code {
540 #[serde(rename = "NREG")]
541 Nreg,
542 #[serde(rename = "YREG")]
543 Yreg,
544 #[default]
545 Unknown,
546}
547#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
548pub enum SettlementDate5Code {
549 #[serde(rename = "REGU")]
550 Regu,
551 #[serde(rename = "CASH")]
552 Cash,
553 #[serde(rename = "NXTD")]
554 Nxtd,
555 #[serde(rename = "TONE")]
556 Tone,
557 #[serde(rename = "TTWO")]
558 Ttwo,
559 #[serde(rename = "TTRE")]
560 Ttre,
561 #[serde(rename = "TFOR")]
562 Tfor,
563 #[serde(rename = "TFIV")]
564 Tfiv,
565 #[serde(rename = "SELL")]
566 Sell,
567 #[serde(rename = "WDIS")]
568 Wdis,
569 #[serde(rename = "WHID")]
570 Whid,
571 #[serde(rename = "TBAT")]
572 Tbat,
573 #[serde(rename = "WISS")]
574 Wiss,
575 #[default]
576 Unknown,
577}
578#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
579pub enum SettlementSystemMethod1Code {
580 #[serde(rename = "NSET")]
581 Nset,
582 #[serde(rename = "YSET")]
583 Yset,
584 #[default]
585 Unknown,
586}
587#[derive(
588 Debug,
589 Default,
590 Clone,
591 PartialEq,
592 ::serde::Serialize,
593 ::serde::Deserialize,
594 ::derive_builder::Builder,
595 ::validator::Validate,
596)]
597pub struct OriginalAndCurrentQuantities1 {
598 #[validate]
599 #[serde(rename = "FaceAmt")]
600 pub face_amt: ImpliedCurrencyAndAmount,
601 #[validate]
602 #[serde(rename = "AmtsdVal")]
603 pub amtsd_val: ImpliedCurrencyAndAmount,
604}
605#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
606pub enum SettlementTransactionCondition7Code {
607 #[serde(rename = "ASGN")]
608 Asgn,
609 #[serde(rename = "CLEN")]
610 Clen,
611 #[serde(rename = "DIRT")]
612 Dirt,
613 #[serde(rename = "DLWM")]
614 Dlwm,
615 #[serde(rename = "DRAW")]
616 Draw,
617 #[serde(rename = "EXER")]
618 Exer,
619 #[serde(rename = "FRCL")]
620 Frcl,
621 #[serde(rename = "KNOC")]
622 Knoc,
623 #[serde(rename = "PHYS")]
624 Phys,
625 #[serde(rename = "CSDP")]
626 Csdp,
627 #[serde(rename = "SPCS")]
628 Spcs,
629 #[serde(rename = "SPDL")]
630 Spdl,
631 #[serde(rename = "SPST")]
632 Spst,
633 #[serde(rename = "UNEX")]
634 Unex,
635 #[default]
636 Unknown,
637}
638#[derive(
639 Debug,
640 Default,
641 Clone,
642 PartialEq,
643 ::serde::Serialize,
644 ::serde::Deserialize,
645 ::derive_builder::Builder,
646 ::validator::Validate,
647)]
648pub struct Tracking3ChoiceEnum {
649 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
650 pub prtry: Option<GenericIdentification38>,
651 #[serde(rename = "Ind", skip_serializing_if = "Option::is_none")]
652 pub ind: Option<YesNoIndicator>,
653}
654#[derive(
655 Debug,
656 Default,
657 Clone,
658 PartialEq,
659 ::serde::Serialize,
660 ::serde::Deserialize,
661 ::derive_builder::Builder,
662 ::validator::Validate,
663)]
664pub struct Tracking3Choice {
665 #[serde(flatten)]
666 pub value: Tracking3ChoiceEnum,
667}
668#[derive(
669 Debug,
670 Default,
671 Clone,
672 PartialEq,
673 ::serde::Serialize,
674 ::serde::Deserialize,
675 ::derive_builder::Builder,
676 ::validator::Validate,
677)]
678pub struct CashParties18 {
679 #[serde(rename = "Dbtr", skip_serializing_if = "Option::is_none")]
680 pub dbtr: Option<PartyIdentificationAndAccount80>,
681 #[serde(rename = "DbtrAgt", skip_serializing_if = "Option::is_none")]
682 pub dbtr_agt: Option<PartyIdentificationAndAccount80>,
683 #[serde(rename = "Cdtr", skip_serializing_if = "Option::is_none")]
684 pub cdtr: Option<PartyIdentificationAndAccount80>,
685 #[serde(rename = "CdtrAgt", skip_serializing_if = "Option::is_none")]
686 pub cdtr_agt: Option<PartyIdentificationAndAccount80>,
687 #[serde(rename = "Intrmy", skip_serializing_if = "Option::is_none")]
688 pub intrmy: Option<PartyIdentificationAndAccount80>,
689}
690#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
691pub enum SettlementInstructionGeneration1Code {
692 #[serde(rename = "GENS")]
693 Gens,
694 #[serde(rename = "NOGE")]
695 Noge,
696 #[default]
697 Unknown,
698}
699#[derive(
700 Debug,
701 Default,
702 Clone,
703 PartialEq,
704 ::serde::Serialize,
705 ::serde::Deserialize,
706 ::derive_builder::Builder,
707 ::validator::Validate,
708)]
709pub struct CashAccountIdentification2ChoiceEnum {
710 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
711 pub prtry: Option<Max34Text>,
712 #[serde(rename = "IBAN", skip_serializing_if = "Option::is_none")]
713 pub iban: Option<IbanIdentifier>,
714}
715#[derive(
716 Debug,
717 Default,
718 Clone,
719 PartialEq,
720 ::serde::Serialize,
721 ::serde::Deserialize,
722 ::derive_builder::Builder,
723 ::validator::Validate,
724)]
725pub struct CashAccountIdentification2Choice {
726 #[serde(flatten)]
727 pub value: CashAccountIdentification2ChoiceEnum,
728}
729#[derive(
730 Debug,
731 Default,
732 Clone,
733 PartialEq,
734 ::serde::Serialize,
735 ::serde::Deserialize,
736 ::derive_builder::Builder,
737 ::validator::Validate,
738)]
739pub struct SettlementDateCode5ChoiceEnum {
740 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
741 pub cd: Option<SettlementDate5Code>,
742 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
743 pub prtry: Option<GenericIdentification38>,
744}
745#[derive(
746 Debug,
747 Default,
748 Clone,
749 PartialEq,
750 ::serde::Serialize,
751 ::serde::Deserialize,
752 ::derive_builder::Builder,
753 ::validator::Validate,
754)]
755pub struct SettlementDateCode5Choice {
756 #[serde(flatten)]
757 pub value: SettlementDateCode5ChoiceEnum,
758}
759#[derive(
760 Debug,
761 Default,
762 Clone,
763 PartialEq,
764 ::serde::Serialize,
765 ::serde::Deserialize,
766 ::derive_builder::Builder,
767 ::validator::Validate,
768)]
769pub struct IdentificationReference8ChoiceEnum {
770 #[serde(rename = "MktInfrstrctrTxId", skip_serializing_if = "Option::is_none")]
771 pub mkt_infrstrctr_tx_id: Option<Max35Text>,
772 #[serde(rename = "BlckId", skip_serializing_if = "Option::is_none")]
773 pub blck_id: Option<Max35Text>,
774 #[serde(rename = "IndvAllcnId", skip_serializing_if = "Option::is_none")]
775 pub indv_allcn_id: Option<Max35Text>,
776 #[serde(rename = "IndxId", skip_serializing_if = "Option::is_none")]
777 pub indx_id: Option<Max35Text>,
778 #[serde(rename = "CmplcId", skip_serializing_if = "Option::is_none")]
779 pub cmplc_id: Option<Max35Text>,
780 #[serde(rename = "PoolId", skip_serializing_if = "Option::is_none")]
781 pub pool_id: Option<Max35Text>,
782 #[serde(rename = "InstgPtyTxId", skip_serializing_if = "Option::is_none")]
783 pub instg_pty_tx_id: Option<Max35Text>,
784 #[serde(rename = "CollTxId", skip_serializing_if = "Option::is_none")]
785 pub coll_tx_id: Option<Max35Text>,
786 #[serde(rename = "ExctgPtyTxId", skip_serializing_if = "Option::is_none")]
787 pub exctg_pty_tx_id: Option<Max35Text>,
788 #[serde(rename = "CmonId", skip_serializing_if = "Option::is_none")]
789 pub cmon_id: Option<Max35Text>,
790 #[serde(rename = "ClntOrdrLkId", skip_serializing_if = "Option::is_none")]
791 pub clnt_ordr_lk_id: Option<Max35Text>,
792 #[serde(rename = "ScndryAllcnId", skip_serializing_if = "Option::is_none")]
793 pub scndry_allcn_id: Option<Max35Text>,
794 #[serde(rename = "AllcnId", skip_serializing_if = "Option::is_none")]
795 pub allcn_id: Option<Max35Text>,
796}
797#[derive(
798 Debug,
799 Default,
800 Clone,
801 PartialEq,
802 ::serde::Serialize,
803 ::serde::Deserialize,
804 ::derive_builder::Builder,
805 ::validator::Validate,
806)]
807pub struct IdentificationReference8Choice {
808 #[serde(flatten)]
809 pub value: IdentificationReference8ChoiceEnum,
810}
811#[derive(
812 Debug,
813 Default,
814 Clone,
815 PartialEq,
816 ::serde::Serialize,
817 ::serde::Deserialize,
818 ::derive_builder::Builder,
819 ::validator::Validate,
820)]
821pub struct RateOrName1ChoiceEnum {
822 #[serde(rename = "RateNm", skip_serializing_if = "Option::is_none")]
823 pub rate_nm: Option<RateName1>,
824 #[serde(rename = "Rate", skip_serializing_if = "Option::is_none")]
825 pub rate: Option<Rate2>,
826}
827#[derive(
828 Debug,
829 Default,
830 Clone,
831 PartialEq,
832 ::serde::Serialize,
833 ::serde::Deserialize,
834 ::derive_builder::Builder,
835 ::validator::Validate,
836)]
837pub struct RateOrName1Choice {
838 #[serde(flatten)]
839 pub value: RateOrName1ChoiceEnum,
840}
841#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
842pub enum Frequency1Code {
843 #[serde(rename = "YEAR")]
844 Year,
845 #[serde(rename = "MNTH")]
846 Mnth,
847 #[serde(rename = "QURT")]
848 Qurt,
849 #[serde(rename = "MIAN")]
850 Mian,
851 #[serde(rename = "WEEK")]
852 Week,
853 #[serde(rename = "DAIL")]
854 Dail,
855 #[serde(rename = "ADHO")]
856 Adho,
857 #[serde(rename = "INDA")]
858 Inda,
859 #[default]
860 Unknown,
861}
862#[derive(
863 Debug,
864 Default,
865 Clone,
866 PartialEq,
867 ::serde::Serialize,
868 ::serde::Deserialize,
869 ::derive_builder::Builder,
870 ::validator::Validate,
871)]
872pub struct TaxCapacityParty3ChoiceEnum {
873 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
874 pub prtry: Option<GenericIdentification38>,
875 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
876 pub cd: Option<TaxLiability1Code>,
877}
878#[derive(
879 Debug,
880 Default,
881 Clone,
882 PartialEq,
883 ::serde::Serialize,
884 ::serde::Deserialize,
885 ::derive_builder::Builder,
886 ::validator::Validate,
887)]
888pub struct TaxCapacityParty3Choice {
889 #[serde(flatten)]
890 pub value: TaxCapacityParty3ChoiceEnum,
891}
892#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
893pub enum TypeOfIdentification2Code {
894 #[serde(rename = "ARNU")]
895 Arnu,
896 #[serde(rename = "CHTY")]
897 Chty,
898 #[serde(rename = "CORP")]
899 Corp,
900 #[serde(rename = "FIIN")]
901 Fiin,
902 #[serde(rename = "TXID")]
903 Txid,
904 #[default]
905 Unknown,
906}
907#[derive(
908 Debug,
909 Default,
910 Clone,
911 PartialEq,
912 ::serde::Serialize,
913 ::serde::Deserialize,
914 ::derive_builder::Builder,
915 ::validator::Validate,
916)]
917pub struct IdentificationSource3ChoiceEnum {
918 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
919 pub prtry: Option<Max35Text>,
920 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
921 pub cd: Option<ExternalFinancialInstrumentIdentificationType1Code>,
922}
923#[derive(
924 Debug,
925 Default,
926 Clone,
927 PartialEq,
928 ::serde::Serialize,
929 ::serde::Deserialize,
930 ::derive_builder::Builder,
931 ::validator::Validate,
932)]
933pub struct IdentificationSource3Choice {
934 #[serde(flatten)]
935 pub value: IdentificationSource3ChoiceEnum,
936}
937#[derive(
938 Debug,
939 Default,
940 Clone,
941 PartialEq,
942 ::serde::Serialize,
943 ::serde::Deserialize,
944 ::derive_builder::Builder,
945 ::validator::Validate,
946)]
947pub struct MarketIdentification80 {
948 #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
949 pub id: Option<MarketIdentification3Choice>,
950 #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
951 pub tp: Option<MarketType12Choice>,
952}
953#[derive(
954 Debug,
955 Default,
956 Clone,
957 PartialEq,
958 ::serde::Serialize,
959 ::serde::Deserialize,
960 ::derive_builder::Builder,
961 ::validator::Validate,
962)]
963pub struct TwoLegTransactionDetails1 {
964 #[serde(rename = "TradDt", skip_serializing_if = "Option::is_none")]
965 pub trad_dt: Option<TradeDate1Choice>,
966 #[serde(rename = "OpngLegId", skip_serializing_if = "Option::is_none")]
967 pub opng_leg_id: Option<Max35Text>,
968 #[serde(rename = "ClsgLegId", skip_serializing_if = "Option::is_none")]
969 pub clsg_leg_id: Option<Max35Text>,
970 #[serde(rename = "GrssTradAmt", skip_serializing_if = "Option::is_none")]
971 pub grss_trad_amt: Option<AmountAndDirection29>,
972 #[validate(length(min = 0,))]
973 #[serde(rename = "OthrAmts", default)]
974 pub othr_amts: Vec<OtherAmounts16>,
975 #[serde(rename = "ScndLegNrrtv", skip_serializing_if = "Option::is_none")]
976 pub scnd_leg_nrrtv: Option<Max140Text>,
977 #[serde(rename = "EndPric", skip_serializing_if = "Option::is_none")]
978 pub end_pric: Option<Price4>,
979 #[serde(rename = "ClsgDt", skip_serializing_if = "Option::is_none")]
980 pub clsg_dt: Option<ClosingDate1Choice>,
981 #[serde(rename = "ClsgSttlmAmt", skip_serializing_if = "Option::is_none")]
982 pub clsg_sttlm_amt: Option<AmountAndDirection5>,
983 #[serde(rename = "PrcgDt", skip_serializing_if = "Option::is_none")]
984 pub prcg_dt: Option<TradeDate4Choice>,
985 #[serde(rename = "TwoLegTxTp", skip_serializing_if = "Option::is_none")]
986 pub two_leg_tx_tp: Option<TwoLegTransactionType1Choice>,
987}
988#[derive(
989 Debug,
990 Default,
991 Clone,
992 PartialEq,
993 ::serde::Serialize,
994 ::serde::Deserialize,
995 ::derive_builder::Builder,
996 ::validator::Validate,
997)]
998pub struct SettlementDate8ChoiceEnum {
999 #[serde(rename = "Dt", skip_serializing_if = "Option::is_none")]
1000 pub dt: Option<DateAndDateTime1Choice>,
1001 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
1002 pub cd: Option<SettlementDateCode5Choice>,
1003}
1004#[derive(
1005 Debug,
1006 Default,
1007 Clone,
1008 PartialEq,
1009 ::serde::Serialize,
1010 ::serde::Deserialize,
1011 ::derive_builder::Builder,
1012 ::validator::Validate,
1013)]
1014pub struct SettlementDate8Choice {
1015 #[serde(flatten)]
1016 pub value: SettlementDate8ChoiceEnum,
1017}
1018#[derive(
1019 Debug,
1020 Default,
1021 Clone,
1022 PartialEq,
1023 ::serde::Serialize,
1024 ::serde::Deserialize,
1025 ::derive_builder::Builder,
1026 ::validator::Validate,
1027)]
1028pub struct PartyIdentification70ChoiceEnum {
1029 #[serde(rename = "AnyBIC", skip_serializing_if = "Option::is_none")]
1030 pub any_bic: Option<AnyBicIdentifier>,
1031 #[serde(rename = "PrtryId", skip_serializing_if = "Option::is_none")]
1032 pub prtry_id: Option<GenericIdentification1>,
1033 #[serde(rename = "NmAndAdr", skip_serializing_if = "Option::is_none")]
1034 pub nm_and_adr: Option<NameAndAddress5>,
1035}
1036#[derive(
1037 Debug,
1038 Default,
1039 Clone,
1040 PartialEq,
1041 ::serde::Serialize,
1042 ::serde::Deserialize,
1043 ::derive_builder::Builder,
1044 ::validator::Validate,
1045)]
1046pub struct PartyIdentification70Choice {
1047 #[serde(flatten)]
1048 pub value: PartyIdentification70ChoiceEnum,
1049}
1050#[derive(
1051 Debug,
1052 Default,
1053 Clone,
1054 PartialEq,
1055 ::serde::Serialize,
1056 ::serde::Deserialize,
1057 ::derive_builder::Builder,
1058 ::validator::Validate,
1059)]
1060pub struct GenericIdentification7 {
1061 #[validate]
1062 #[serde(rename = "Issr")]
1063 pub issr: Max8Text,
1064 #[validate]
1065 #[serde(rename = "Inf")]
1066 pub inf: Max35Text,
1067}
1068#[derive(
1069 Debug,
1070 Default,
1071 Clone,
1072 PartialEq,
1073 ::serde::Serialize,
1074 ::serde::Deserialize,
1075 ::derive_builder::Builder,
1076 ::validator::Validate,
1077)]
1078pub struct PartyIdentification35ChoiceEnum {
1079 #[serde(rename = "BIC", skip_serializing_if = "Option::is_none")]
1080 pub bic: Option<AnyBicIdentifier>,
1081 #[serde(rename = "PrtryId", skip_serializing_if = "Option::is_none")]
1082 pub prtry_id: Option<GenericIdentification29>,
1083}
1084#[derive(
1085 Debug,
1086 Default,
1087 Clone,
1088 PartialEq,
1089 ::serde::Serialize,
1090 ::serde::Deserialize,
1091 ::derive_builder::Builder,
1092 ::validator::Validate,
1093)]
1094pub struct PartyIdentification35Choice {
1095 #[serde(flatten)]
1096 pub value: PartyIdentification35ChoiceEnum,
1097}
1098#[derive(
1099 Debug,
1100 Default,
1101 Clone,
1102 PartialEq,
1103 ::serde::Serialize,
1104 ::serde::Deserialize,
1105 ::derive_builder::Builder,
1106 ::validator::Validate,
1107)]
1108pub struct SpreadRate1 {
1109 #[validate]
1110 #[serde(rename = "Sgn")]
1111 pub sgn: PlusOrMinusIndicator,
1112 #[serde(rename = "RateOrAmt")]
1113 pub rate_or_amt: AmountOrRate1Choice,
1114}
1115#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1116pub enum ClearingSide1Code {
1117 #[serde(rename = "BUYI")]
1118 Buyi,
1119 #[serde(rename = "SELL")]
1120 Sell,
1121 #[serde(rename = "LEND")]
1122 Lend,
1123 #[serde(rename = "BORW")]
1124 Borw,
1125 #[default]
1126 Unknown,
1127}
1128#[derive(
1129 Debug,
1130 Default,
1131 Clone,
1132 PartialEq,
1133 ::serde::Serialize,
1134 ::serde::Deserialize,
1135 ::derive_builder::Builder,
1136 ::validator::Validate,
1137)]
1138pub struct DateTimePeriodDetails1 {
1139 #[validate]
1140 #[serde(rename = "FrDtTm")]
1141 pub fr_dt_tm: IsoDateTime,
1142 #[serde(rename = "ToDtTm", skip_serializing_if = "Option::is_none")]
1143 pub to_dt_tm: Option<IsoDateTime>,
1144}
1145#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1146pub enum LegalFramework1Code {
1147 #[serde(rename = "FRAN")]
1148 Fran,
1149 #[default]
1150 Unknown,
1151}
1152#[derive(
1153 Debug,
1154 Default,
1155 Clone,
1156 PartialEq,
1157 ::serde::Serialize,
1158 ::serde::Deserialize,
1159 ::derive_builder::Builder,
1160 ::validator::Validate,
1161)]
1162pub struct SettlementStandingInstructionDatabase3ChoiceEnum {
1163 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
1164 pub prtry: Option<GenericIdentification38>,
1165 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
1166 pub cd: Option<SettlementStandingInstructionDatabase1Code>,
1167}
1168#[derive(
1169 Debug,
1170 Default,
1171 Clone,
1172 PartialEq,
1173 ::serde::Serialize,
1174 ::serde::Deserialize,
1175 ::derive_builder::Builder,
1176 ::validator::Validate,
1177)]
1178pub struct SettlementStandingInstructionDatabase3Choice {
1179 #[serde(flatten)]
1180 pub value: SettlementStandingInstructionDatabase3ChoiceEnum,
1181}
1182#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1183pub enum Appearance1Code {
1184 #[serde(rename = "DELI")]
1185 Deli,
1186 #[serde(rename = "NDEL")]
1187 Ndel,
1188 #[serde(rename = "LIMI")]
1189 Limi,
1190 #[serde(rename = "BENT")]
1191 Bent,
1192 #[serde(rename = "DFBE")]
1193 Dfbe,
1194 #[serde(rename = "DLBE")]
1195 Dlbe,
1196 #[serde(rename = "TMPG")]
1197 Tmpg,
1198 #[serde(rename = "GLOB")]
1199 Glob,
1200 #[default]
1201 Unknown,
1202}
1203#[derive(
1204 Debug,
1205 Default,
1206 Clone,
1207 PartialEq,
1208 ::serde::Serialize,
1209 ::serde::Deserialize,
1210 ::derive_builder::Builder,
1211 ::validator::Validate,
1212)]
1213pub struct Reporting5ChoiceEnum {
1214 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
1215 pub prtry: Option<GenericIdentification38>,
1216 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
1217 pub cd: Option<Reporting2Code>,
1218}
1219#[derive(
1220 Debug,
1221 Default,
1222 Clone,
1223 PartialEq,
1224 ::serde::Serialize,
1225 ::serde::Deserialize,
1226 ::derive_builder::Builder,
1227 ::validator::Validate,
1228)]
1229pub struct Reporting5Choice {
1230 #[serde(flatten)]
1231 pub value: Reporting5ChoiceEnum,
1232}
1233#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1234pub enum ClosingType1Code {
1235 #[serde(rename = "OVER")]
1236 Over,
1237 #[serde(rename = "TERM")]
1238 Term,
1239 #[serde(rename = "FLEX")]
1240 Flex,
1241 #[serde(rename = "OPEN")]
1242 Open,
1243 #[default]
1244 Unknown,
1245}
1246#[derive(
1247 Debug,
1248 Default,
1249 Clone,
1250 PartialEq,
1251 ::serde::Serialize,
1252 ::serde::Deserialize,
1253 ::derive_builder::Builder,
1254 ::validator::Validate,
1255)]
1256pub struct Order17 {
1257 #[serde(rename = "BizPrcTp", skip_serializing_if = "Option::is_none")]
1258 pub biz_prc_tp: Option<BusinessProcessType1Choice>,
1259 #[validate(length(min = 0,))]
1260 #[serde(rename = "OrdrId", default)]
1261 pub ordr_id: Vec<Max35Text>,
1262 #[validate(length(min = 0,))]
1263 #[serde(rename = "ClntOrdrId", default)]
1264 pub clnt_ordr_id: Vec<Max35Text>,
1265 #[validate(length(min = 0,))]
1266 #[serde(rename = "ScndryClntOrdrId", default)]
1267 pub scndry_clnt_ordr_id: Vec<Max35Text>,
1268 #[validate(length(min = 0,))]
1269 #[serde(rename = "ListId", default)]
1270 pub list_id: Vec<Max35Text>,
1271 #[serde(rename = "Sd")]
1272 pub sd: Side3Code,
1273 #[serde(rename = "Pmt", skip_serializing_if = "Option::is_none")]
1274 pub pmt: Option<DeliveryReceiptType2Code>,
1275 #[serde(rename = "TradTxTp", skip_serializing_if = "Option::is_none")]
1276 pub trad_tx_tp: Option<TradeType3Choice>,
1277 #[validate(length(min = 0,))]
1278 #[serde(rename = "TradTxCond", default)]
1279 pub trad_tx_cond: Vec<TradeTransactionCondition4Choice>,
1280 #[serde(rename = "PreAdvc", skip_serializing_if = "Option::is_none")]
1281 pub pre_advc: Option<YesNoIndicator>,
1282 #[serde(rename = "PlcOfTrad", skip_serializing_if = "Option::is_none")]
1283 pub plc_of_trad: Option<MarketIdentification79>,
1284 #[serde(rename = "OrdrBookgDt", skip_serializing_if = "Option::is_none")]
1285 pub ordr_bookg_dt: Option<IsoDate>,
1286 #[serde(rename = "TradOrgtnDt", skip_serializing_if = "Option::is_none")]
1287 pub trad_orgtn_dt: Option<IsoDateTime>,
1288 #[serde(rename = "TradDt")]
1289 pub trad_dt: TradeDate4Choice,
1290 #[serde(rename = "PrcgDt", skip_serializing_if = "Option::is_none")]
1291 pub prcg_dt: Option<TradeDate4Choice>,
1292 #[serde(rename = "SttlmDt")]
1293 pub sttlm_dt: SettlementDate8Choice,
1294 #[serde(rename = "NAVDt", skip_serializing_if = "Option::is_none")]
1295 pub nav_dt: Option<DateAndDateTime1Choice>,
1296 #[validate(length(min = 0,))]
1297 #[serde(rename = "PrtlFillDtls", default)]
1298 pub prtl_fill_dtls: Vec<PartialFill2>,
1299 #[serde(rename = "ConfQty")]
1300 pub conf_qty: Quantity6Choice,
1301 #[validate(length(min = 0,))]
1302 #[serde(rename = "QtyBrkdwn", default)]
1303 pub qty_brkdwn: Vec<QuantityBreakdown11>,
1304 #[serde(rename = "GrssTradAmt", skip_serializing_if = "Option::is_none")]
1305 pub grss_trad_amt: Option<AmountAndDirection29>,
1306 #[validate]
1307 #[serde(rename = "DealPric")]
1308 pub deal_pric: Price4,
1309 #[serde(rename = "TpOfPric", skip_serializing_if = "Option::is_none")]
1310 pub tp_of_pric: Option<TypeOfPrice10Choice>,
1311 #[serde(rename = "CshMrgn", skip_serializing_if = "Option::is_none")]
1312 pub csh_mrgn: Option<CashMarginOrder1Code>,
1313 #[serde(rename = "Comssn", skip_serializing_if = "Option::is_none")]
1314 pub comssn: Option<Commission16>,
1315 #[serde(rename = "NbOfDaysAcrd", skip_serializing_if = "Option::is_none")]
1316 pub nb_of_days_acrd: Option<Max3Number>,
1317 #[serde(rename = "GvUpNbOfDays", skip_serializing_if = "Option::is_none")]
1318 pub gv_up_nb_of_days: Option<Max3Number>,
1319 #[serde(rename = "IntrstTp", skip_serializing_if = "Option::is_none")]
1320 pub intrst_tp: Option<InterestType2Code>,
1321 #[serde(rename = "AcrdIntrstAmt", skip_serializing_if = "Option::is_none")]
1322 pub acrd_intrst_amt: Option<AmountAndDirection29>,
1323 #[serde(rename = "AcrdIntrstPctg", skip_serializing_if = "Option::is_none")]
1324 pub acrd_intrst_pctg: Option<PercentageRate>,
1325 #[serde(rename = "TradRgltryCondsTp", skip_serializing_if = "Option::is_none")]
1326 pub trad_rgltry_conds_tp: Option<TradeRegulatoryConditions1Code>,
1327 #[serde(rename = "CcyToBuyOrSell", skip_serializing_if = "Option::is_none")]
1328 pub ccy_to_buy_or_sell: Option<CurrencyToBuyOrSell1Choice>,
1329 #[serde(rename = "OrdrOrgtrElgblty", skip_serializing_if = "Option::is_none")]
1330 pub ordr_orgtr_elgblty: Option<Eligibility1Code>,
1331 #[serde(rename = "PosFct", skip_serializing_if = "Option::is_none")]
1332 pub pos_fct: Option<PositionEffect2Code>,
1333 #[serde(rename = "DerivCvrd", skip_serializing_if = "Option::is_none")]
1334 pub deriv_cvrd: Option<YesNoIndicator>,
1335 #[serde(rename = "ChrgTaxBsisTp", skip_serializing_if = "Option::is_none")]
1336 pub chrg_tax_bsis_tp: Option<ChargeTaxBasisType1Choice>,
1337 #[serde(rename = "CptlGnTp", skip_serializing_if = "Option::is_none")]
1338 pub cptl_gn_tp: Option<EuCapitalGainType2Choice>,
1339 #[serde(rename = "MtchSts", skip_serializing_if = "Option::is_none")]
1340 pub mtch_sts: Option<MatchingStatus8Choice>,
1341 #[serde(rename = "CallInTp", skip_serializing_if = "Option::is_none")]
1342 pub call_in_tp: Option<CallIn1Code>,
1343 #[serde(rename = "YldTp", skip_serializing_if = "Option::is_none")]
1344 pub yld_tp: Option<YieldCalculation2>,
1345 #[validate(length(min = 0,))]
1346 #[serde(rename = "Rptg", default)]
1347 pub rptg: Vec<Reporting5Choice>,
1348 #[serde(
1349 rename = "AddtlPhysOrRegnDtls",
1350 skip_serializing_if = "Option::is_none"
1351 )]
1352 pub addtl_phys_or_regn_dtls: Option<RegistrationParameters3>,
1353 #[serde(
1354 rename = "AddtlTradInstrPrcgInf",
1355 skip_serializing_if = "Option::is_none"
1356 )]
1357 pub addtl_trad_instr_prcg_inf: Option<Max350Text>,
1358}
1359#[derive(
1360 Debug,
1361 Default,
1362 Clone,
1363 PartialEq,
1364 ::serde::Serialize,
1365 ::serde::Deserialize,
1366 ::derive_builder::Builder,
1367 ::validator::Validate,
1368)]
1369pub struct ActiveOrHistoricCurrencyAnd13DecimalAmountSimpleType {
1370 #[validate(range(min = 0,))]
1371 #[serde(rename = "$text")]
1372 pub value: f64,
1373}
1374#[derive(
1375 Debug,
1376 Default,
1377 Clone,
1378 PartialEq,
1379 ::serde::Serialize,
1380 ::serde::Deserialize,
1381 ::derive_builder::Builder,
1382 ::validator::Validate,
1383)]
1384pub struct ExposureType9ChoiceEnum {
1385 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
1386 pub cd: Option<ExposureType3Code>,
1387 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
1388 pub prtry: Option<GenericIdentification38>,
1389}
1390#[derive(
1391 Debug,
1392 Default,
1393 Clone,
1394 PartialEq,
1395 ::serde::Serialize,
1396 ::serde::Deserialize,
1397 ::derive_builder::Builder,
1398 ::validator::Validate,
1399)]
1400pub struct ExposureType9Choice {
1401 #[serde(flatten)]
1402 pub value: ExposureType9ChoiceEnum,
1403}
1404#[derive(
1405 Debug,
1406 Default,
1407 Clone,
1408 PartialEq,
1409 ::serde::Serialize,
1410 ::serde::Deserialize,
1411 ::derive_builder::Builder,
1412 ::validator::Validate,
1413)]
1414pub struct GenericIdentification36 {
1415 #[validate]
1416 #[serde(rename = "Id")]
1417 pub id: Max35Text,
1418 #[validate]
1419 #[serde(rename = "Issr")]
1420 pub issr: Max35Text,
1421 #[serde(rename = "SchmeNm", skip_serializing_if = "Option::is_none")]
1422 pub schme_nm: Option<Max35Text>,
1423}
1424#[derive(
1425 Debug,
1426 Default,
1427 Clone,
1428 PartialEq,
1429 ::serde::Serialize,
1430 ::serde::Deserialize,
1431 ::derive_builder::Builder,
1432 ::validator::Validate,
1433)]
1434pub struct SecurityIdentification14 {
1435 #[serde(rename = "ISIN", skip_serializing_if = "Option::is_none")]
1436 pub isin: Option<IsinIdentifier>,
1437 #[validate(length(min = 0,))]
1438 #[serde(rename = "OthrId", default)]
1439 pub othr_id: Vec<OtherIdentification1>,
1440 #[serde(rename = "Desc", skip_serializing_if = "Option::is_none")]
1441 pub desc: Option<Max140Text>,
1442}
1443#[derive(
1444 Debug,
1445 Default,
1446 Clone,
1447 PartialEq,
1448 ::serde::Serialize,
1449 ::serde::Deserialize,
1450 ::derive_builder::Builder,
1451 ::validator::Validate,
1452)]
1453pub struct TotalNumber1 {
1454 #[validate]
1455 #[serde(rename = "CurInstrNb")]
1456 pub cur_instr_nb: Exact3NumericText,
1457 #[validate]
1458 #[serde(rename = "TtlOfLkdInstrs")]
1459 pub ttl_of_lkd_instrs: Exact3NumericText,
1460}
1461#[derive(
1462 Debug,
1463 Default,
1464 Clone,
1465 PartialEq,
1466 ::serde::Serialize,
1467 ::serde::Deserialize,
1468 ::derive_builder::Builder,
1469 ::validator::Validate,
1470)]
1471pub struct Exact4AlphaNumericText {
1472 #[validate(regex = "EXACT_4_ALPHA_NUMERIC_TEXT_REGEX")]
1473 #[serde(rename = "$text")]
1474 pub value: String,
1475}
1476#[derive(
1477 Debug,
1478 Default,
1479 Clone,
1480 PartialEq,
1481 ::serde::Serialize,
1482 ::serde::Deserialize,
1483 ::derive_builder::Builder,
1484 ::validator::Validate,
1485)]
1486pub struct FormOfSecurity4ChoiceEnum {
1487 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
1488 pub cd: Option<FormOfSecurity1Code>,
1489 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
1490 pub prtry: Option<GenericIdentification38>,
1491}
1492#[derive(
1493 Debug,
1494 Default,
1495 Clone,
1496 PartialEq,
1497 ::serde::Serialize,
1498 ::serde::Deserialize,
1499 ::derive_builder::Builder,
1500 ::validator::Validate,
1501)]
1502pub struct FormOfSecurity4Choice {
1503 #[serde(flatten)]
1504 pub value: FormOfSecurity4ChoiceEnum,
1505}
1506#[derive(
1507 Debug,
1508 Default,
1509 Clone,
1510 PartialEq,
1511 ::serde::Serialize,
1512 ::serde::Deserialize,
1513 ::derive_builder::Builder,
1514 ::validator::Validate,
1515)]
1516pub struct SecuritiesRtgs3ChoiceEnum {
1517 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
1518 pub prtry: Option<GenericIdentification38>,
1519 #[serde(rename = "Ind", skip_serializing_if = "Option::is_none")]
1520 pub ind: Option<YesNoIndicator>,
1521}
1522#[derive(
1523 Debug,
1524 Default,
1525 Clone,
1526 PartialEq,
1527 ::serde::Serialize,
1528 ::serde::Deserialize,
1529 ::derive_builder::Builder,
1530 ::validator::Validate,
1531)]
1532pub struct SecuritiesRtgs3Choice {
1533 #[serde(flatten)]
1534 pub value: SecuritiesRtgs3ChoiceEnum,
1535}
1536#[derive(
1537 Debug,
1538 Default,
1539 Clone,
1540 PartialEq,
1541 ::serde::Serialize,
1542 ::serde::Deserialize,
1543 ::derive_builder::Builder,
1544 ::validator::Validate,
1545)]
1546pub struct AnyBicIdentifier {
1547 #[validate(regex = "ANY_BIC_IDENTIFIER_REGEX")]
1548 #[serde(rename = "$text")]
1549 pub value: String,
1550}
1551#[derive(
1552 Debug,
1553 Default,
1554 Clone,
1555 PartialEq,
1556 ::serde::Serialize,
1557 ::serde::Deserialize,
1558 ::derive_builder::Builder,
1559 ::validator::Validate,
1560)]
1561pub struct AmountAndDirection28 {
1562 #[serde(rename = "AcrdIntrstInd", skip_serializing_if = "Option::is_none")]
1563 pub acrd_intrst_ind: Option<YesNoIndicator>,
1564 #[serde(rename = "StmpDtyInd", skip_serializing_if = "Option::is_none")]
1565 pub stmp_dty_ind: Option<YesNoIndicator>,
1566 #[validate]
1567 #[serde(rename = "Amt")]
1568 pub amt: ActiveCurrencyAndAmount,
1569 #[serde(rename = "CdtDbtInd", skip_serializing_if = "Option::is_none")]
1570 pub cdt_dbt_ind: Option<CreditDebitCode>,
1571 #[serde(
1572 rename = "OrgnlCcyAndOrdrdAmt",
1573 skip_serializing_if = "Option::is_none"
1574 )]
1575 pub orgnl_ccy_and_ordrd_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
1576 #[serde(rename = "FXDtls", skip_serializing_if = "Option::is_none")]
1577 pub fx_dtls: Option<ForeignExchangeTerms18>,
1578 #[serde(rename = "ValDt", skip_serializing_if = "Option::is_none")]
1579 pub val_dt: Option<DateAndDateTime1Choice>,
1580}
1581#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1582pub enum MarketClientSideCode {
1583 #[serde(rename = "MAKT")]
1584 Makt,
1585 #[serde(rename = "CLNT")]
1586 Clnt,
1587 #[default]
1588 Unknown,
1589}
1590#[derive(
1591 Debug,
1592 Default,
1593 Clone,
1594 PartialEq,
1595 ::serde::Serialize,
1596 ::serde::Deserialize,
1597 ::derive_builder::Builder,
1598 ::validator::Validate,
1599)]
1600pub struct DateTimePeriodChoiceEnum {
1601 #[serde(rename = "FrDtTm", skip_serializing_if = "Option::is_none")]
1602 pub fr_dt_tm: Option<IsoDateTime>,
1603 #[serde(rename = "DtTmRg", skip_serializing_if = "Option::is_none")]
1604 pub dt_tm_rg: Option<DateTimePeriodDetails>,
1605 #[serde(rename = "ToDtTm", skip_serializing_if = "Option::is_none")]
1606 pub to_dt_tm: Option<IsoDateTime>,
1607}
1608#[derive(
1609 Debug,
1610 Default,
1611 Clone,
1612 PartialEq,
1613 ::serde::Serialize,
1614 ::serde::Deserialize,
1615 ::derive_builder::Builder,
1616 ::validator::Validate,
1617)]
1618pub struct DateTimePeriodChoice {
1619 #[serde(flatten)]
1620 pub value: DateTimePeriodChoiceEnum,
1621}
1622#[derive(
1623 Debug,
1624 Default,
1625 Clone,
1626 PartialEq,
1627 ::serde::Serialize,
1628 ::serde::Deserialize,
1629 ::derive_builder::Builder,
1630 ::validator::Validate,
1631)]
1632pub struct MarketClientSide3ChoiceEnum {
1633 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
1634 pub cd: Option<MarketClientSideCode>,
1635 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
1636 pub prtry: Option<GenericIdentification38>,
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 MarketClientSide3Choice {
1649 #[serde(flatten)]
1650 pub value: MarketClientSide3ChoiceEnum,
1651}
1652#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1653pub enum Operation1Code {
1654 #[serde(rename = "TILL")]
1655 Till,
1656 #[serde(rename = "ORRR")]
1657 Orrr,
1658 #[serde(rename = "ANDD")]
1659 Andd,
1660 #[default]
1661 Unknown,
1662}
1663#[derive(
1664 Debug,
1665 Default,
1666 Clone,
1667 PartialEq,
1668 ::serde::Serialize,
1669 ::serde::Deserialize,
1670 ::derive_builder::Builder,
1671 ::validator::Validate,
1672)]
1673pub struct ExternalTradeTransactionCondition1Code {
1674 #[validate(length(min = 1, max = 4,))]
1675 #[serde(rename = "$text")]
1676 pub value: String,
1677}
1678#[derive(
1679 Debug,
1680 Default,
1681 Clone,
1682 PartialEq,
1683 ::serde::Serialize,
1684 ::serde::Deserialize,
1685 ::derive_builder::Builder,
1686 ::validator::Validate,
1687)]
1688pub struct AutomaticBorrowing5ChoiceEnum {
1689 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
1690 pub prtry: Option<GenericIdentification38>,
1691 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
1692 pub cd: Option<AutoBorrowing1Code>,
1693}
1694#[derive(
1695 Debug,
1696 Default,
1697 Clone,
1698 PartialEq,
1699 ::serde::Serialize,
1700 ::serde::Deserialize,
1701 ::derive_builder::Builder,
1702 ::validator::Validate,
1703)]
1704pub struct AutomaticBorrowing5Choice {
1705 #[serde(flatten)]
1706 pub value: AutomaticBorrowing5ChoiceEnum,
1707}
1708#[derive(
1709 Debug,
1710 Default,
1711 Clone,
1712 PartialEq,
1713 ::serde::Serialize,
1714 ::serde::Deserialize,
1715 ::derive_builder::Builder,
1716 ::validator::Validate,
1717)]
1718pub struct ConfirmationPartyDetails1 {
1719 #[serde(rename = "Id")]
1720 pub id: PartyIdentification32Choice,
1721 #[serde(rename = "AltrnId", skip_serializing_if = "Option::is_none")]
1722 pub altrn_id: Option<AlternatePartyIdentification5>,
1723 #[serde(rename = "PrcgId", skip_serializing_if = "Option::is_none")]
1724 pub prcg_id: Option<Max35Text>,
1725 #[serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none")]
1726 pub addtl_inf: Option<PartyTextInformation5>,
1727}
1728#[derive(
1729 Debug,
1730 Default,
1731 Clone,
1732 PartialEq,
1733 ::serde::Serialize,
1734 ::serde::Deserialize,
1735 ::derive_builder::Builder,
1736 ::validator::Validate,
1737)]
1738pub struct Number1ChoiceEnum {
1739 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
1740 pub prtry: Option<GenericIdentification7>,
1741 #[serde(rename = "NbId", skip_serializing_if = "Option::is_none")]
1742 pub nb_id: Option<Max3NumericText>,
1743}
1744#[derive(
1745 Debug,
1746 Default,
1747 Clone,
1748 PartialEq,
1749 ::serde::Serialize,
1750 ::serde::Deserialize,
1751 ::derive_builder::Builder,
1752 ::validator::Validate,
1753)]
1754pub struct Number1Choice {
1755 #[serde(flatten)]
1756 pub value: Number1ChoiceEnum,
1757}
1758#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1759pub enum OwnershipLegalRestrictions1Code {
1760 #[serde(rename = "A144")]
1761 A144,
1762 #[serde(rename = "NRST")]
1763 Nrst,
1764 #[serde(rename = "RSTR")]
1765 Rstr,
1766 #[default]
1767 Unknown,
1768}
1769#[derive(
1770 Debug,
1771 Default,
1772 Clone,
1773 PartialEq,
1774 ::serde::Serialize,
1775 ::serde::Deserialize,
1776 ::derive_builder::Builder,
1777 ::validator::Validate,
1778)]
1779pub struct ActiveCurrencyAndAmountSimpleType {
1780 #[validate(range(min = 0,))]
1781 #[serde(rename = "$text")]
1782 pub value: f64,
1783}
1784#[derive(
1785 Debug,
1786 Default,
1787 Clone,
1788 PartialEq,
1789 ::serde::Serialize,
1790 ::serde::Deserialize,
1791 ::derive_builder::Builder,
1792 ::validator::Validate,
1793)]
1794pub struct OtherIdentification1 {
1795 #[validate]
1796 #[serde(rename = "Id")]
1797 pub id: Max35Text,
1798 #[serde(rename = "Sfx", skip_serializing_if = "Option::is_none")]
1799 pub sfx: Option<Max16Text>,
1800 #[serde(rename = "Tp")]
1801 pub tp: IdentificationSource3Choice,
1802}
1803#[derive(
1804 Debug,
1805 Default,
1806 Clone,
1807 PartialEq,
1808 ::serde::Serialize,
1809 ::serde::Deserialize,
1810 ::derive_builder::Builder,
1811 ::validator::Validate,
1812)]
1813pub struct UnderlyingRatio1 {
1814 #[serde(rename = "UndrlygQtyDnmtr")]
1815 pub undrlyg_qty_dnmtr: FinancialInstrumentQuantity1Choice,
1816 #[serde(rename = "UndrlygQtyNmrtr")]
1817 pub undrlyg_qty_nmrtr: FinancialInstrumentQuantity1Choice,
1818 #[validate(length(min = 0,))]
1819 #[serde(rename = "RltdFinInstrmId", default)]
1820 pub rltd_fin_instrm_id: Vec<SecurityIdentification14>,
1821}
1822#[derive(
1823 Debug,
1824 Default,
1825 Clone,
1826 PartialEq,
1827 ::serde::Serialize,
1828 ::serde::Deserialize,
1829 ::derive_builder::Builder,
1830 ::validator::Validate,
1831)]
1832pub struct YieldCalculation2 {
1833 #[validate]
1834 #[serde(rename = "Val")]
1835 pub val: PercentageRate,
1836 #[serde(rename = "ClctnTp")]
1837 pub clctn_tp: CalculationType1Code,
1838 #[serde(rename = "RedPric", skip_serializing_if = "Option::is_none")]
1839 pub red_pric: Option<Price4>,
1840 #[serde(rename = "ValDt", skip_serializing_if = "Option::is_none")]
1841 pub val_dt: Option<IsoDate>,
1842 #[serde(rename = "ValPrd", skip_serializing_if = "Option::is_none")]
1843 pub val_prd: Option<DateTimePeriodChoice>,
1844 #[serde(rename = "ClctnDt", skip_serializing_if = "Option::is_none")]
1845 pub clctn_dt: Option<IsoDate>,
1846}
1847#[derive(
1848 Debug,
1849 Default,
1850 Clone,
1851 PartialEq,
1852 ::serde::Serialize,
1853 ::serde::Deserialize,
1854 ::derive_builder::Builder,
1855 ::validator::Validate,
1856)]
1857pub struct NameAndAddress5 {
1858 #[validate]
1859 #[serde(rename = "Nm")]
1860 pub nm: Max350Text,
1861 #[serde(rename = "Adr", skip_serializing_if = "Option::is_none")]
1862 pub adr: Option<PostalAddress1>,
1863}
1864#[derive(
1865 Debug,
1866 Default,
1867 Clone,
1868 PartialEq,
1869 ::serde::Serialize,
1870 ::serde::Deserialize,
1871 ::derive_builder::Builder,
1872 ::validator::Validate,
1873)]
1874pub struct TradeType3ChoiceEnum {
1875 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
1876 pub cd: Option<TradeType3Code>,
1877 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
1878 pub prtry: Option<GenericIdentification38>,
1879}
1880#[derive(
1881 Debug,
1882 Default,
1883 Clone,
1884 PartialEq,
1885 ::serde::Serialize,
1886 ::serde::Deserialize,
1887 ::derive_builder::Builder,
1888 ::validator::Validate,
1889)]
1890pub struct TradeType3Choice {
1891 #[serde(flatten)]
1892 pub value: TradeType3ChoiceEnum,
1893}
1894#[derive(
1895 Debug,
1896 Default,
1897 Clone,
1898 PartialEq,
1899 ::serde::Serialize,
1900 ::serde::Deserialize,
1901 ::derive_builder::Builder,
1902 ::validator::Validate,
1903)]
1904pub struct Max16Text {
1905 #[validate(length(min = 1, max = 16,))]
1906 #[serde(rename = "$text")]
1907 pub value: String,
1908}
1909#[derive(
1910 Debug,
1911 Default,
1912 Clone,
1913 PartialEq,
1914 ::serde::Serialize,
1915 ::serde::Deserialize,
1916 ::derive_builder::Builder,
1917 ::validator::Validate,
1918)]
1919pub struct PartialFill2 {
1920 #[serde(rename = "ConfQty")]
1921 pub conf_qty: Quantity6Choice,
1922 #[validate]
1923 #[serde(rename = "DealPric")]
1924 pub deal_pric: Price4,
1925 #[serde(rename = "TradDt", skip_serializing_if = "Option::is_none")]
1926 pub trad_dt: Option<TradeDate4Choice>,
1927 #[serde(rename = "PlcOfTrad", skip_serializing_if = "Option::is_none")]
1928 pub plc_of_trad: Option<MarketIdentification80>,
1929 #[serde(rename = "OrgnlOrdrdQty")]
1930 pub orgnl_ordrd_qty: QuantityOrAmount1Choice,
1931 #[serde(rename = "PrevslyExctdQty")]
1932 pub prevsly_exctd_qty: QuantityOrAmount1Choice,
1933 #[serde(rename = "RmngQty")]
1934 pub rmng_qty: QuantityOrAmount1Choice,
1935 #[serde(rename = "MtchIncrmtQty", skip_serializing_if = "Option::is_none")]
1936 pub mtch_incrmt_qty: Option<QuantityOrAmount1Choice>,
1937}
1938#[derive(
1939 Debug,
1940 Default,
1941 Clone,
1942 PartialEq,
1943 ::serde::Serialize,
1944 ::serde::Deserialize,
1945 ::derive_builder::Builder,
1946 ::validator::Validate,
1947)]
1948pub struct CountryCode {
1949 #[validate(regex = "COUNTRY_CODE_REGEX")]
1950 #[serde(rename = "$text")]
1951 pub value: String,
1952}
1953#[derive(
1954 Debug,
1955 Default,
1956 Clone,
1957 PartialEq,
1958 ::serde::Serialize,
1959 ::serde::Deserialize,
1960 ::derive_builder::Builder,
1961 ::validator::Validate,
1962)]
1963pub struct AmountOrRate2ChoiceEnum {
1964 #[serde(rename = "Amt", skip_serializing_if = "Option::is_none")]
1965 pub amt: Option<ActiveCurrencyAndAmount>,
1966 #[serde(rename = "Rate", skip_serializing_if = "Option::is_none")]
1967 pub rate: Option<PercentageRate>,
1968}
1969#[derive(
1970 Debug,
1971 Default,
1972 Clone,
1973 PartialEq,
1974 ::serde::Serialize,
1975 ::serde::Deserialize,
1976 ::derive_builder::Builder,
1977 ::validator::Validate,
1978)]
1979pub struct AmountOrRate2Choice {
1980 #[serde(flatten)]
1981 pub value: AmountOrRate2ChoiceEnum,
1982}
1983#[derive(
1984 Debug,
1985 Default,
1986 Clone,
1987 PartialEq,
1988 ::serde::Serialize,
1989 ::serde::Deserialize,
1990 ::derive_builder::Builder,
1991 ::validator::Validate,
1992)]
1993pub struct IbanIdentifier {
1994 #[validate(regex = "IBAN_IDENTIFIER_REGEX")]
1995 #[serde(rename = "$text")]
1996 pub value: String,
1997}
1998#[derive(
1999 Debug,
2000 Default,
2001 Clone,
2002 PartialEq,
2003 ::serde::Serialize,
2004 ::serde::Deserialize,
2005 ::derive_builder::Builder,
2006 ::validator::Validate,
2007)]
2008pub struct Max256Text {
2009 #[validate(length(min = 1, max = 256,))]
2010 #[serde(rename = "$text")]
2011 pub value: String,
2012}
2013#[derive(
2014 Debug,
2015 Default,
2016 Clone,
2017 PartialEq,
2018 ::serde::Serialize,
2019 ::serde::Deserialize,
2020 ::derive_builder::Builder,
2021 ::validator::Validate,
2022)]
2023pub struct BorrowingReason1ChoiceEnum {
2024 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
2025 pub cd: Option<BorrowingReason1Code>,
2026 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
2027 pub prtry: Option<GenericIdentification38>,
2028}
2029#[derive(
2030 Debug,
2031 Default,
2032 Clone,
2033 PartialEq,
2034 ::serde::Serialize,
2035 ::serde::Deserialize,
2036 ::derive_builder::Builder,
2037 ::validator::Validate,
2038)]
2039pub struct BorrowingReason1Choice {
2040 #[serde(flatten)]
2041 pub value: BorrowingReason1ChoiceEnum,
2042}
2043#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2044pub enum FutureAndOptionContractType1Code {
2045 #[serde(rename = "ORDY")]
2046 Ordy,
2047 #[serde(rename = "INDX")]
2048 Indx,
2049 #[serde(rename = "EXFU")]
2050 Exfu,
2051 #[default]
2052 Unknown,
2053}
2054#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2055pub enum SettlingCapacity1Code {
2056 #[serde(rename = "CUST")]
2057 Cust,
2058 #[serde(rename = "SAGE")]
2059 Sage,
2060 #[serde(rename = "SPRI")]
2061 Spri,
2062 #[default]
2063 Unknown,
2064}
2065#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2066pub enum TradingCapacity4Code {
2067 #[serde(rename = "PRIN")]
2068 Prin,
2069 #[serde(rename = "CPRN")]
2070 Cprn,
2071 #[serde(rename = "RISP")]
2072 Risp,
2073 #[serde(rename = "PROP")]
2074 Prop,
2075 #[serde(rename = "AGEN")]
2076 Agen,
2077 #[serde(rename = "CAGN")]
2078 Cagn,
2079 #[serde(rename = "OAGN")]
2080 Oagn,
2081 #[serde(rename = "PRAG")]
2082 Prag,
2083 #[serde(rename = "BAGN")]
2084 Bagn,
2085 #[serde(rename = "INFI")]
2086 Infi,
2087 #[serde(rename = "MKTM")]
2088 Mktm,
2089 #[serde(rename = "MLTF")]
2090 Mltf,
2091 #[serde(rename = "RMKT")]
2092 Rmkt,
2093 #[serde(rename = "SINT")]
2094 Sint,
2095 #[serde(rename = "TAGT")]
2096 Tagt,
2097 #[default]
2098 Unknown,
2099}
2100#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2101pub enum TradingCapacity6Code {
2102 #[serde(rename = "AGEN")]
2103 Agen,
2104 #[serde(rename = "BAGN")]
2105 Bagn,
2106 #[serde(rename = "CAGN")]
2107 Cagn,
2108 #[serde(rename = "CPRN")]
2109 Cprn,
2110 #[serde(rename = "OAGN")]
2111 Oagn,
2112 #[serde(rename = "PRAG")]
2113 Prag,
2114 #[serde(rename = "PRIN")]
2115 Prin,
2116 #[default]
2117 Unknown,
2118}
2119#[derive(
2120 Debug,
2121 Default,
2122 Clone,
2123 PartialEq,
2124 ::serde::Serialize,
2125 ::serde::Deserialize,
2126 ::derive_builder::Builder,
2127 ::validator::Validate,
2128)]
2129pub struct SecuritiesCertificate3 {
2130 #[validate]
2131 #[serde(rename = "Nb")]
2132 pub nb: Max35Text,
2133 #[serde(rename = "Issr", skip_serializing_if = "Option::is_none")]
2134 pub issr: Option<Max35Text>,
2135 #[serde(rename = "SchmeNm", skip_serializing_if = "Option::is_none")]
2136 pub schme_nm: Option<Max35Text>,
2137}
2138#[derive(
2139 Debug,
2140 Default,
2141 Clone,
2142 PartialEq,
2143 ::serde::Serialize,
2144 ::serde::Deserialize,
2145 ::derive_builder::Builder,
2146 ::validator::Validate,
2147)]
2148pub struct IdentificationType40ChoiceEnum {
2149 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
2150 pub prtry: Option<GenericIdentification29>,
2151 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
2152 pub cd: Option<TypeOfIdentification2Code>,
2153}
2154#[derive(
2155 Debug,
2156 Default,
2157 Clone,
2158 PartialEq,
2159 ::serde::Serialize,
2160 ::serde::Deserialize,
2161 ::derive_builder::Builder,
2162 ::validator::Validate,
2163)]
2164pub struct IdentificationType40Choice {
2165 #[serde(flatten)]
2166 pub value: IdentificationType40ChoiceEnum,
2167}
2168#[derive(
2169 Debug,
2170 Default,
2171 Clone,
2172 PartialEq,
2173 ::serde::Serialize,
2174 ::serde::Deserialize,
2175 ::derive_builder::Builder,
2176 ::validator::Validate,
2177)]
2178pub struct TypeOfPrice10ChoiceEnum {
2179 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
2180 pub prtry: Option<GenericIdentification38>,
2181 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
2182 pub cd: Option<TypeOfPrice3Code>,
2183}
2184#[derive(
2185 Debug,
2186 Default,
2187 Clone,
2188 PartialEq,
2189 ::serde::Serialize,
2190 ::serde::Deserialize,
2191 ::derive_builder::Builder,
2192 ::validator::Validate,
2193)]
2194pub struct TypeOfPrice10Choice {
2195 #[serde(flatten)]
2196 pub value: TypeOfPrice10ChoiceEnum,
2197}
2198#[derive(
2199 Debug,
2200 Default,
2201 Clone,
2202 PartialEq,
2203 ::serde::Serialize,
2204 ::serde::Deserialize,
2205 ::derive_builder::Builder,
2206 ::validator::Validate,
2207)]
2208pub struct MarketIdentification3ChoiceEnum {
2209 #[serde(rename = "MktIdrCd", skip_serializing_if = "Option::is_none")]
2210 pub mkt_idr_cd: Option<MicIdentifier>,
2211 #[serde(rename = "Desc", skip_serializing_if = "Option::is_none")]
2212 pub desc: Option<Max35Text>,
2213}
2214#[derive(
2215 Debug,
2216 Default,
2217 Clone,
2218 PartialEq,
2219 ::serde::Serialize,
2220 ::serde::Deserialize,
2221 ::derive_builder::Builder,
2222 ::validator::Validate,
2223)]
2224pub struct MarketIdentification3Choice {
2225 #[serde(flatten)]
2226 pub value: MarketIdentification3ChoiceEnum,
2227}
2228#[derive(
2229 Debug,
2230 Default,
2231 Clone,
2232 PartialEq,
2233 ::serde::Serialize,
2234 ::serde::Deserialize,
2235 ::derive_builder::Builder,
2236 ::validator::Validate,
2237)]
2238pub struct TransactiontIdentification4 {
2239 #[validate]
2240 #[serde(rename = "TxId")]
2241 pub tx_id: Max35Text,
2242}
2243#[derive(
2244 Debug,
2245 Default,
2246 Clone,
2247 PartialEq,
2248 ::serde::Serialize,
2249 ::serde::Deserialize,
2250 ::derive_builder::Builder,
2251 ::validator::Validate,
2252)]
2253pub struct PartyIdentificationAndAccount87 {
2254 #[serde(rename = "Id")]
2255 pub id: PartyIdentification70Choice,
2256 #[serde(rename = "PrcgId", skip_serializing_if = "Option::is_none")]
2257 pub prcg_id: Option<Max35Text>,
2258 #[serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none")]
2259 pub addtl_inf: Option<PartyTextInformation1>,
2260 #[serde(rename = "AltrnId", skip_serializing_if = "Option::is_none")]
2261 pub altrn_id: Option<AlternatePartyIdentification6>,
2262}
2263#[derive(
2264 Debug,
2265 Default,
2266 Clone,
2267 PartialEq,
2268 ::serde::Serialize,
2269 ::serde::Deserialize,
2270 ::derive_builder::Builder,
2271 ::validator::Validate,
2272)]
2273pub struct Exact3NumericText {
2274 #[validate(regex = "EXACT_3_NUMERIC_TEXT_REGEX")]
2275 #[serde(rename = "$text")]
2276 pub value: String,
2277}
2278#[derive(
2279 Debug,
2280 Default,
2281 Clone,
2282 PartialEq,
2283 ::serde::Serialize,
2284 ::serde::Deserialize,
2285 ::derive_builder::Builder,
2286 ::validator::Validate,
2287)]
2288pub struct CurrencyCode {
2289 #[validate(regex = "CURRENCY_CODE_REGEX")]
2290 #[serde(rename = "$text")]
2291 pub value: String,
2292}
2293#[derive(
2294 Debug,
2295 Default,
2296 Clone,
2297 PartialEq,
2298 ::serde::Serialize,
2299 ::serde::Deserialize,
2300 ::derive_builder::Builder,
2301 ::validator::Validate,
2302)]
2303pub struct ConfirmationPartyDetails2 {
2304 #[serde(rename = "Id")]
2305 pub id: PartyIdentification32Choice,
2306 #[serde(rename = "AltrnId", skip_serializing_if = "Option::is_none")]
2307 pub altrn_id: Option<AlternatePartyIdentification5>,
2308 #[serde(rename = "PrcgId", skip_serializing_if = "Option::is_none")]
2309 pub prcg_id: Option<Max35Text>,
2310 #[serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none")]
2311 pub addtl_inf: Option<PartyTextInformation5>,
2312 #[serde(rename = "InvstrCpcty", skip_serializing_if = "Option::is_none")]
2313 pub invstr_cpcty: Option<InvestorCapacity3Choice>,
2314 #[serde(rename = "TradgPtyCpcty", skip_serializing_if = "Option::is_none")]
2315 pub tradg_pty_cpcty: Option<TradingPartyCapacity1Choice>,
2316}
2317#[derive(
2318 Debug,
2319 Default,
2320 Clone,
2321 PartialEq,
2322 ::serde::Serialize,
2323 ::serde::Deserialize,
2324 ::derive_builder::Builder,
2325 ::validator::Validate,
2326)]
2327pub struct AmountAndDirection29 {
2328 #[validate]
2329 #[serde(rename = "Amt")]
2330 pub amt: ActiveOrHistoricCurrencyAndAmount,
2331 #[serde(rename = "CdtDbtInd", skip_serializing_if = "Option::is_none")]
2332 pub cdt_dbt_ind: Option<CreditDebitCode>,
2333 #[serde(
2334 rename = "OrgnlCcyAndOrdrdAmt",
2335 skip_serializing_if = "Option::is_none"
2336 )]
2337 pub orgnl_ccy_and_ordrd_amt: Option<ActiveOrHistoricCurrencyAndAmount>,
2338 #[serde(rename = "FXDtls", skip_serializing_if = "Option::is_none")]
2339 pub fx_dtls: Option<ForeignExchangeTerms18>,
2340}
2341#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2342pub enum PriceValueType7Code {
2343 #[serde(rename = "DISC")]
2344 Disc,
2345 #[serde(rename = "PREM")]
2346 Prem,
2347 #[serde(rename = "PARV")]
2348 Parv,
2349 #[serde(rename = "YIEL")]
2350 Yiel,
2351 #[serde(rename = "SPRE")]
2352 Spre,
2353 #[serde(rename = "PEUN")]
2354 Peun,
2355 #[serde(rename = "ABSO")]
2356 Abso,
2357 #[serde(rename = "TEDP")]
2358 Tedp,
2359 #[serde(rename = "TEDY")]
2360 Tedy,
2361 #[serde(rename = "FICT")]
2362 Fict,
2363 #[serde(rename = "VACT")]
2364 Vact,
2365 #[serde(rename = "PRCT")]
2366 Prct,
2367 #[serde(rename = "ACTU")]
2368 Actu,
2369 #[default]
2370 Unknown,
2371}
2372#[derive(
2373 Debug,
2374 Default,
2375 Clone,
2376 PartialEq,
2377 ::serde::Serialize,
2378 ::serde::Deserialize,
2379 ::derive_builder::Builder,
2380 ::validator::Validate,
2381)]
2382pub struct Rate2 {
2383 #[serde(rename = "Sgn", skip_serializing_if = "Option::is_none")]
2384 pub sgn: Option<PlusOrMinusIndicator>,
2385 #[validate]
2386 #[serde(rename = "Rate")]
2387 pub rate: PercentageRate,
2388}
2389#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2390pub enum SettlementTransactionType7Code {
2391 #[serde(rename = "BSBK")]
2392 Bsbk,
2393 #[serde(rename = "COLI")]
2394 Coli,
2395 #[serde(rename = "COLO")]
2396 Colo,
2397 #[serde(rename = "CONV")]
2398 Conv,
2399 #[serde(rename = "FCTA")]
2400 Fcta,
2401 #[serde(rename = "INSP")]
2402 Insp,
2403 #[serde(rename = "ISSU")]
2404 Issu,
2405 #[serde(rename = "MKDW")]
2406 Mkdw,
2407 #[serde(rename = "MKUP")]
2408 Mkup,
2409 #[serde(rename = "NETT")]
2410 Nett,
2411 #[serde(rename = "NSYN")]
2412 Nsyn,
2413 #[serde(rename = "OWNE")]
2414 Owne,
2415 #[serde(rename = "OWNI")]
2416 Owni,
2417 #[serde(rename = "PAIR")]
2418 Pair,
2419 #[serde(rename = "PLAC")]
2420 Plac,
2421 #[serde(rename = "PORT")]
2422 Port,
2423 #[serde(rename = "REAL")]
2424 Real,
2425 #[serde(rename = "REDI")]
2426 Redi,
2427 #[serde(rename = "RELE")]
2428 Rele,
2429 #[serde(rename = "REPU")]
2430 Repu,
2431 #[serde(rename = "RODE")]
2432 Rode,
2433 #[serde(rename = "RPTO")]
2434 Rpto,
2435 #[serde(rename = "RVPO")]
2436 Rvpo,
2437 #[serde(rename = "SBBK")]
2438 Sbbk,
2439 #[serde(rename = "SECB")]
2440 Secb,
2441 #[serde(rename = "SECL")]
2442 Secl,
2443 #[serde(rename = "SYND")]
2444 Synd,
2445 #[serde(rename = "TBAC")]
2446 Tbac,
2447 #[serde(rename = "TRAD")]
2448 Trad,
2449 #[serde(rename = "TRPO")]
2450 Trpo,
2451 #[serde(rename = "TRVO")]
2452 Trvo,
2453 #[serde(rename = "TURN")]
2454 Turn,
2455 #[serde(rename = "GUAR")]
2456 Guar,
2457 #[serde(rename = "OFIT")]
2458 Ofit,
2459 #[default]
2460 Unknown,
2461}
2462#[derive(
2463 Debug,
2464 Default,
2465 Clone,
2466 PartialEq,
2467 ::serde::Serialize,
2468 ::serde::Deserialize,
2469 ::derive_builder::Builder,
2470 ::validator::Validate,
2471)]
2472pub struct ForeignExchangeTerms18 {
2473 #[serde(rename = "UnitCcy")]
2474 pub unit_ccy: ActiveCurrencyCode,
2475 #[serde(rename = "QtdCcy")]
2476 pub qtd_ccy: ActiveCurrencyCode,
2477 #[validate]
2478 #[serde(rename = "XchgRate")]
2479 pub xchg_rate: BaseOneRate,
2480 #[validate]
2481 #[serde(rename = "ConvtdAmt")]
2482 pub convtd_amt: ActiveCurrencyAndAmount,
2483}
2484#[derive(
2485 Debug,
2486 Default,
2487 Clone,
2488 PartialEq,
2489 ::serde::Serialize,
2490 ::serde::Deserialize,
2491 ::derive_builder::Builder,
2492 ::validator::Validate,
2493)]
2494pub struct ActiveOrHistoricCurrencyCode {
2495 #[validate(regex = "ACTIVE_OR_HISTORIC_CURRENCY_CODE_REGEX")]
2496 #[serde(rename = "$text")]
2497 pub value: String,
2498}
2499#[derive(
2500 Debug,
2501 Default,
2502 Clone,
2503 PartialEq,
2504 ::serde::Serialize,
2505 ::serde::Deserialize,
2506 ::derive_builder::Builder,
2507 ::validator::Validate,
2508)]
2509pub struct GenericIdentification1 {
2510 #[validate]
2511 #[serde(rename = "Id")]
2512 pub id: Max35Text,
2513 #[serde(rename = "SchmeNm", skip_serializing_if = "Option::is_none")]
2514 pub schme_nm: Option<Max35Text>,
2515 #[serde(rename = "Issr", skip_serializing_if = "Option::is_none")]
2516 pub issr: Option<Max35Text>,
2517}
2518#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2519pub enum CallIn1Code {
2520 #[serde(rename = "CFAV")]
2521 Cfav,
2522 #[serde(rename = "CFST")]
2523 Cfst,
2524 #[serde(rename = "CFCC")]
2525 Cfcc,
2526 #[default]
2527 Unknown,
2528}
2529#[derive(
2530 Debug,
2531 Default,
2532 Clone,
2533 PartialEq,
2534 ::serde::Serialize,
2535 ::serde::Deserialize,
2536 ::derive_builder::Builder,
2537 ::validator::Validate,
2538)]
2539pub struct GenericIdentification37 {
2540 #[validate]
2541 #[serde(rename = "Id")]
2542 pub id: Max35Text,
2543 #[serde(rename = "Issr", skip_serializing_if = "Option::is_none")]
2544 pub issr: Option<Max35Text>,
2545}
2546#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2547pub enum ClearingAccountType1Code {
2548 #[serde(rename = "HOUS")]
2549 Hous,
2550 #[serde(rename = "CLIE")]
2551 Clie,
2552 #[serde(rename = "LIPR")]
2553 Lipr,
2554 #[default]
2555 Unknown,
2556}
2557#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2558pub enum BlockTrade1Code {
2559 #[serde(rename = "BLPA")]
2560 Blpa,
2561 #[serde(rename = "BLCH")]
2562 Blch,
2563 #[default]
2564 Unknown,
2565}
2566#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2567pub enum InterestType2Code {
2568 #[serde(rename = "CINT")]
2569 Cint,
2570 #[serde(rename = "XINT")]
2571 Xint,
2572 #[default]
2573 Unknown,
2574}
2575#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2576pub enum CashSettlementSystem2Code {
2577 #[serde(rename = "GROS")]
2578 Gros,
2579 #[serde(rename = "NETS")]
2580 Nets,
2581 #[default]
2582 Unknown,
2583}
2584#[derive(
2585 Debug,
2586 Default,
2587 Clone,
2588 PartialEq,
2589 ::serde::Serialize,
2590 ::serde::Deserialize,
2591 ::derive_builder::Builder,
2592 ::validator::Validate,
2593)]
2594pub struct Max34Text {
2595 #[validate(length(min = 1, max = 34,))]
2596 #[serde(rename = "$text")]
2597 pub value: String,
2598}
2599#[derive(
2600 Debug,
2601 Default,
2602 Clone,
2603 PartialEq,
2604 ::serde::Serialize,
2605 ::serde::Deserialize,
2606 ::derive_builder::Builder,
2607 ::validator::Validate,
2608)]
2609pub struct ImpliedCurrencyAndAmount {
2610 #[validate(range(min = 0,))]
2611 #[serde(rename = "$text")]
2612 pub value: f64,
2613}
2614#[derive(
2615 Debug,
2616 Default,
2617 Clone,
2618 PartialEq,
2619 ::serde::Serialize,
2620 ::serde::Deserialize,
2621 ::derive_builder::Builder,
2622 ::validator::Validate,
2623)]
2624pub struct PostalAddress1 {
2625 #[serde(rename = "AdrTp", skip_serializing_if = "Option::is_none")]
2626 pub adr_tp: Option<AddressType2Code>,
2627 #[validate(length(min = 0, max = 5,))]
2628 #[serde(rename = "AdrLine", default)]
2629 pub adr_line: Vec<Max70Text>,
2630 #[serde(rename = "StrtNm", skip_serializing_if = "Option::is_none")]
2631 pub strt_nm: Option<Max70Text>,
2632 #[serde(rename = "BldgNb", skip_serializing_if = "Option::is_none")]
2633 pub bldg_nb: Option<Max16Text>,
2634 #[serde(rename = "PstCd", skip_serializing_if = "Option::is_none")]
2635 pub pst_cd: Option<Max16Text>,
2636 #[serde(rename = "TwnNm", skip_serializing_if = "Option::is_none")]
2637 pub twn_nm: Option<Max35Text>,
2638 #[serde(rename = "CtrySubDvsn", skip_serializing_if = "Option::is_none")]
2639 pub ctry_sub_dvsn: Option<Max35Text>,
2640 #[serde(rename = "Ctry")]
2641 pub ctry: CountryCode,
2642}
2643#[derive(
2644 Debug,
2645 Default,
2646 Clone,
2647 PartialEq,
2648 ::serde::Serialize,
2649 ::serde::Deserialize,
2650 ::derive_builder::Builder,
2651 ::validator::Validate,
2652)]
2653pub struct PartyIdentification32ChoiceEnum {
2654 #[serde(rename = "NmAndAdr", skip_serializing_if = "Option::is_none")]
2655 pub nm_and_adr: Option<NameAndAddress13>,
2656 #[serde(rename = "BIC", skip_serializing_if = "Option::is_none")]
2657 pub bic: Option<AnyBicIdentifier>,
2658 #[serde(rename = "PrtryId", skip_serializing_if = "Option::is_none")]
2659 pub prtry_id: Option<GenericIdentification29>,
2660}
2661#[derive(
2662 Debug,
2663 Default,
2664 Clone,
2665 PartialEq,
2666 ::serde::Serialize,
2667 ::serde::Deserialize,
2668 ::derive_builder::Builder,
2669 ::validator::Validate,
2670)]
2671pub struct PartyIdentification32Choice {
2672 #[serde(flatten)]
2673 pub value: PartyIdentification32ChoiceEnum,
2674}
2675#[derive(
2676 Debug,
2677 Default,
2678 Clone,
2679 PartialEq,
2680 ::serde::Serialize,
2681 ::serde::Deserialize,
2682 ::derive_builder::Builder,
2683 ::validator::Validate,
2684)]
2685pub struct BicNonFiIdentifier {
2686 #[validate(regex = "BIC_NON_FI_IDENTIFIER_REGEX")]
2687 #[serde(rename = "$text")]
2688 pub value: String,
2689}
2690#[derive(
2691 Debug,
2692 Default,
2693 Clone,
2694 PartialEq,
2695 ::serde::Serialize,
2696 ::serde::Deserialize,
2697 ::derive_builder::Builder,
2698 ::validator::Validate,
2699)]
2700pub struct MarketType11ChoiceEnum {
2701 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
2702 pub prtry: Option<GenericIdentification38>,
2703 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
2704 pub cd: Option<MarketType6Code>,
2705}
2706#[derive(
2707 Debug,
2708 Default,
2709 Clone,
2710 PartialEq,
2711 ::serde::Serialize,
2712 ::serde::Deserialize,
2713 ::derive_builder::Builder,
2714 ::validator::Validate,
2715)]
2716pub struct MarketType11Choice {
2717 #[serde(flatten)]
2718 pub value: MarketType11ChoiceEnum,
2719}
2720#[derive(
2721 Debug,
2722 Default,
2723 Clone,
2724 PartialEq,
2725 ::serde::Serialize,
2726 ::serde::Deserialize,
2727 ::derive_builder::Builder,
2728 ::validator::Validate,
2729)]
2730pub struct AmountOrRate1ChoiceEnum {
2731 #[serde(rename = "Rate", skip_serializing_if = "Option::is_none")]
2732 pub rate: Option<PercentageRate>,
2733 #[serde(rename = "Amt", skip_serializing_if = "Option::is_none")]
2734 pub amt: Option<ActiveCurrencyAndAmount>,
2735}
2736#[derive(
2737 Debug,
2738 Default,
2739 Clone,
2740 PartialEq,
2741 ::serde::Serialize,
2742 ::serde::Deserialize,
2743 ::derive_builder::Builder,
2744 ::validator::Validate,
2745)]
2746pub struct AmountOrRate1Choice {
2747 #[serde(flatten)]
2748 pub value: AmountOrRate1ChoiceEnum,
2749}
2750#[derive(
2751 Debug,
2752 Default,
2753 Clone,
2754 PartialEq,
2755 ::serde::Serialize,
2756 ::serde::Deserialize,
2757 ::derive_builder::Builder,
2758 ::validator::Validate,
2759)]
2760pub struct NettingEligibility3ChoiceEnum {
2761 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
2762 pub prtry: Option<GenericIdentification38>,
2763 #[serde(rename = "Ind", skip_serializing_if = "Option::is_none")]
2764 pub ind: Option<YesNoIndicator>,
2765}
2766#[derive(
2767 Debug,
2768 Default,
2769 Clone,
2770 PartialEq,
2771 ::serde::Serialize,
2772 ::serde::Deserialize,
2773 ::derive_builder::Builder,
2774 ::validator::Validate,
2775)]
2776pub struct NettingEligibility3Choice {
2777 #[serde(flatten)]
2778 pub value: NettingEligibility3ChoiceEnum,
2779}
2780#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2781pub enum CalculationType1Code {
2782 #[serde(rename = "AFTX")]
2783 Aftx,
2784 #[serde(rename = "ANNU")]
2785 Annu,
2786 #[serde(rename = "ISSU")]
2787 Issu,
2788 #[serde(rename = "AVMA")]
2789 Avma,
2790 #[serde(rename = "BOOK")]
2791 Book,
2792 #[serde(rename = "YTNC")]
2793 Ytnc,
2794 #[serde(rename = "CHCL")]
2795 Chcl,
2796 #[serde(rename = "CLOS")]
2797 Clos,
2798 #[serde(rename = "CMPD")]
2799 Cmpd,
2800 #[serde(rename = "CUYI")]
2801 Cuyi,
2802 #[serde(rename = "TRGR")]
2803 Trgr,
2804 #[serde(rename = "GVEQ")]
2805 Gveq,
2806 #[serde(rename = "FLAS")]
2807 Flas,
2808 #[serde(rename = "NVFL")]
2809 Nvfl,
2810 #[serde(rename = "LSCL")]
2811 Lscl,
2812 #[serde(rename = "LSMT")]
2813 Lsmt,
2814 #[serde(rename = "LSQR")]
2815 Lsqr,
2816 #[serde(rename = "LSYR")]
2817 Lsyr,
2818 #[serde(rename = "LGAL")]
2819 Lgal,
2820 #[serde(rename = "MARK")]
2821 Mark,
2822 #[serde(rename = "YTMA")]
2823 Ytma,
2824 #[serde(rename = "NXRF")]
2825 Nxrf,
2826 #[serde(rename = "PNAV")]
2827 Pnav,
2828 #[serde(rename = "NXPT")]
2829 Nxpt,
2830 #[serde(rename = "PRCL")]
2831 Prcl,
2832 #[serde(rename = "PRYL")]
2833 Pryl,
2834 #[serde(rename = "SEMI")]
2835 Semi,
2836 #[serde(rename = "SHLF")]
2837 Shlf,
2838 #[serde(rename = "SPLL")]
2839 Spll,
2840 #[serde(rename = "TXQV")]
2841 Txqv,
2842 #[serde(rename = "TTDT")]
2843 Ttdt,
2844 #[serde(rename = "TRYL")]
2845 Tryl,
2846 #[serde(rename = "WRST")]
2847 Wrst,
2848 #[default]
2849 Unknown,
2850}
2851#[derive(
2852 Debug,
2853 Default,
2854 Clone,
2855 PartialEq,
2856 ::serde::Serialize,
2857 ::serde::Deserialize,
2858 ::derive_builder::Builder,
2859 ::validator::Validate,
2860)]
2861pub struct RegistrationParameters3 {
2862 #[serde(rename = "CertfctnId", skip_serializing_if = "Option::is_none")]
2863 pub certfctn_id: Option<Max35Text>,
2864 #[serde(rename = "CertfctnDtTm", skip_serializing_if = "Option::is_none")]
2865 pub certfctn_dt_tm: Option<DateAndDateTime1Choice>,
2866 #[serde(rename = "RegarAcct", skip_serializing_if = "Option::is_none")]
2867 pub regar_acct: Option<Max35Text>,
2868 #[validate(length(min = 0,))]
2869 #[serde(rename = "CertNb", default)]
2870 pub cert_nb: Vec<SecuritiesCertificate3>,
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 Max3Number {
2883 #[serde(rename = "$text")]
2884 pub value: f64,
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 PartyIdentificationAndAccount79 {
2897 #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
2898 pub id: Option<PartyIdentification32Choice>,
2899 #[serde(rename = "SfkpgAcct", skip_serializing_if = "Option::is_none")]
2900 pub sfkpg_acct: Option<Max35Text>,
2901 #[serde(rename = "CshAcct", skip_serializing_if = "Option::is_none")]
2902 pub csh_acct: Option<CashAccountIdentification2Choice>,
2903 #[serde(rename = "PrcgId", skip_serializing_if = "Option::is_none")]
2904 pub prcg_id: Option<Max35Text>,
2905 #[serde(rename = "CtryOfRes", skip_serializing_if = "Option::is_none")]
2906 pub ctry_of_res: Option<CountryCode>,
2907 #[serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none")]
2908 pub addtl_inf: Option<PartyTextInformation1>,
2909 #[serde(rename = "AltrnId", skip_serializing_if = "Option::is_none")]
2910 pub altrn_id: Option<AlternatePartyIdentification5>,
2911}
2912#[derive(
2913 Debug,
2914 Default,
2915 Clone,
2916 PartialEq,
2917 ::serde::Serialize,
2918 ::serde::Deserialize,
2919 ::derive_builder::Builder,
2920 ::validator::Validate,
2921)]
2922pub struct IdentificationType41ChoiceEnum {
2923 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
2924 pub cd: Option<TypeOfIdentification1Code>,
2925 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
2926 pub prtry: Option<GenericIdentification38>,
2927}
2928#[derive(
2929 Debug,
2930 Default,
2931 Clone,
2932 PartialEq,
2933 ::serde::Serialize,
2934 ::serde::Deserialize,
2935 ::derive_builder::Builder,
2936 ::validator::Validate,
2937)]
2938pub struct IdentificationType41Choice {
2939 #[serde(flatten)]
2940 pub value: IdentificationType41ChoiceEnum,
2941}
2942#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2943pub enum TradeRegulatoryConditions1Code {
2944 #[serde(rename = "SOLI")]
2945 Soli,
2946 #[serde(rename = "USOL")]
2947 Usol,
2948 #[default]
2949 Unknown,
2950}
2951#[derive(
2952 Debug,
2953 Default,
2954 Clone,
2955 PartialEq,
2956 ::serde::Serialize,
2957 ::serde::Deserialize,
2958 ::derive_builder::Builder,
2959 ::validator::Validate,
2960)]
2961pub struct FinancialInstrumentQuantity1ChoiceEnum {
2962 #[serde(rename = "FaceAmt", skip_serializing_if = "Option::is_none")]
2963 pub face_amt: Option<ImpliedCurrencyAndAmount>,
2964 #[serde(rename = "Unit", skip_serializing_if = "Option::is_none")]
2965 pub unit: Option<DecimalNumber>,
2966 #[serde(rename = "AmtsdVal", skip_serializing_if = "Option::is_none")]
2967 pub amtsd_val: Option<ImpliedCurrencyAndAmount>,
2968}
2969#[derive(
2970 Debug,
2971 Default,
2972 Clone,
2973 PartialEq,
2974 ::serde::Serialize,
2975 ::serde::Deserialize,
2976 ::derive_builder::Builder,
2977 ::validator::Validate,
2978)]
2979pub struct FinancialInstrumentQuantity1Choice {
2980 #[serde(flatten)]
2981 pub value: FinancialInstrumentQuantity1ChoiceEnum,
2982}
2983#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2984pub enum ExposureType3Code {
2985 #[serde(rename = "CCIR")]
2986 Ccir,
2987 #[serde(rename = "COMM")]
2988 Comm,
2989 #[serde(rename = "CRDS")]
2990 Crds,
2991 #[serde(rename = "CRPR")]
2992 Crpr,
2993 #[serde(rename = "CRSP")]
2994 Crsp,
2995 #[serde(rename = "CRTL")]
2996 Crtl,
2997 #[serde(rename = "EQPT")]
2998 Eqpt,
2999 #[serde(rename = "EQUS")]
3000 Equs,
3001 #[serde(rename = "EXPT")]
3002 Expt,
3003 #[serde(rename = "EXTD")]
3004 Extd,
3005 #[serde(rename = "FIXI")]
3006 Fixi,
3007 #[serde(rename = "FORW")]
3008 Forw,
3009 #[serde(rename = "FORX")]
3010 Forx,
3011 #[serde(rename = "FUTR")]
3012 Futr,
3013 #[serde(rename = "LIQU")]
3014 Liqu,
3015 #[serde(rename = "OPTN")]
3016 Optn,
3017 #[serde(rename = "OTCD")]
3018 Otcd,
3019 #[serde(rename = "PAYM")]
3020 Paym,
3021 #[serde(rename = "REPO")]
3022 Repo,
3023 #[serde(rename = "SBSC")]
3024 Sbsc,
3025 #[serde(rename = "SCIE")]
3026 Scie,
3027 #[serde(rename = "SCIR")]
3028 Scir,
3029 #[serde(rename = "SCRP")]
3030 Scrp,
3031 #[serde(rename = "SLEB")]
3032 Sleb,
3033 #[serde(rename = "SLOA")]
3034 Sloa,
3035 #[serde(rename = "SWPT")]
3036 Swpt,
3037 #[serde(rename = "TRCP")]
3038 Trcp,
3039 #[serde(rename = "BFWD")]
3040 Bfwd,
3041 #[serde(rename = "RVPO")]
3042 Rvpo,
3043 #[serde(rename = "TBAS")]
3044 Tbas,
3045 #[default]
3046 Unknown,
3047}
3048#[derive(
3049 Debug,
3050 Default,
3051 Clone,
3052 PartialEq,
3053 ::serde::Serialize,
3054 ::serde::Deserialize,
3055 ::derive_builder::Builder,
3056 ::validator::Validate,
3057)]
3058pub struct Iban2007Identifier {
3059 #[validate(regex = "IBAN_2007_IDENTIFIER_REGEX")]
3060 #[serde(rename = "$text")]
3061 pub value: String,
3062}
3063#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3064pub enum DateType3Code {
3065 #[serde(rename = "VARI")]
3066 Vari,
3067 #[default]
3068 Unknown,
3069}
3070#[derive(
3071 Debug,
3072 Default,
3073 Clone,
3074 PartialEq,
3075 ::serde::Serialize,
3076 ::serde::Deserialize,
3077 ::derive_builder::Builder,
3078 ::validator::Validate,
3079)]
3080pub struct Term1 {
3081 #[serde(rename = "Oprtr")]
3082 pub oprtr: Operator1Code,
3083 #[serde(rename = "Val")]
3084 pub val: RateOrAbsoluteValue1Choice,
3085}
3086#[derive(
3087 Debug,
3088 Default,
3089 Clone,
3090 PartialEq,
3091 ::serde::Serialize,
3092 ::serde::Deserialize,
3093 ::derive_builder::Builder,
3094 ::validator::Validate,
3095)]
3096pub struct PartyTextInformation5 {
3097 #[serde(rename = "DclrtnDtls", skip_serializing_if = "Option::is_none")]
3098 pub dclrtn_dtls: Option<Max350Text>,
3099 #[serde(rename = "PtyCtctDtls", skip_serializing_if = "Option::is_none")]
3100 pub pty_ctct_dtls: Option<Max140Text>,
3101}
3102#[derive(
3103 Debug,
3104 Default,
3105 Clone,
3106 PartialEq,
3107 ::serde::Serialize,
3108 ::serde::Deserialize,
3109 ::derive_builder::Builder,
3110 ::validator::Validate,
3111)]
3112pub struct Clearing3 {
3113 #[validate(length(min = 1,))]
3114 #[serde(rename = "ClrMmb", default)]
3115 pub clr_mmb: Vec<PartyIdentificationAndAccount78>,
3116 #[serde(rename = "ClrSgmt", skip_serializing_if = "Option::is_none")]
3117 pub clr_sgmt: Option<PartyIdentification35Choice>,
3118}
3119#[derive(
3120 Debug,
3121 Default,
3122 Clone,
3123 PartialEq,
3124 ::serde::Serialize,
3125 ::serde::Deserialize,
3126 ::derive_builder::Builder,
3127 ::validator::Validate,
3128)]
3129pub struct CurrencyToBuyOrSell1ChoiceEnum {
3130 #[serde(rename = "CcyToBuy", skip_serializing_if = "Option::is_none")]
3131 pub ccy_to_buy: Option<ActiveCurrencyCode>,
3132 #[serde(rename = "CcyToSell", skip_serializing_if = "Option::is_none")]
3133 pub ccy_to_sell: Option<ActiveCurrencyCode>,
3134}
3135#[derive(
3136 Debug,
3137 Default,
3138 Clone,
3139 PartialEq,
3140 ::serde::Serialize,
3141 ::serde::Deserialize,
3142 ::derive_builder::Builder,
3143 ::validator::Validate,
3144)]
3145pub struct CurrencyToBuyOrSell1Choice {
3146 #[serde(flatten)]
3147 pub value: CurrencyToBuyOrSell1ChoiceEnum,
3148}
3149#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3150pub enum TradeTransactionCondition2Code {
3151 #[serde(rename = "SPCC")]
3152 Spcc,
3153 #[serde(rename = "SECN")]
3154 Secn,
3155 #[serde(rename = "SEBN")]
3156 Sebn,
3157 #[serde(rename = "SCBN")]
3158 Scbn,
3159 #[serde(rename = "SCRT")]
3160 Scrt,
3161 #[serde(rename = "SERT")]
3162 Sert,
3163 #[serde(rename = "SCCR")]
3164 Sccr,
3165 #[serde(rename = "SECR")]
3166 Secr,
3167 #[serde(rename = "CAST")]
3168 Cast,
3169 #[serde(rename = "SPPR")]
3170 Sppr,
3171 #[serde(rename = "SPCU")]
3172 Spcu,
3173 #[serde(rename = "SPEX")]
3174 Spex,
3175 #[serde(rename = "GTDL")]
3176 Gtdl,
3177 #[default]
3178 Unknown,
3179}
3180#[derive(
3181 Debug,
3182 Default,
3183 Clone,
3184 PartialEq,
3185 ::serde::Serialize,
3186 ::serde::Deserialize,
3187 ::derive_builder::Builder,
3188 ::validator::Validate,
3189)]
3190pub struct ChargeTaxBasisType1ChoiceEnum {
3191 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
3192 pub prtry: Option<GenericIdentification38>,
3193 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
3194 pub cd: Option<ChargeTaxBasis1Code>,
3195}
3196#[derive(
3197 Debug,
3198 Default,
3199 Clone,
3200 PartialEq,
3201 ::serde::Serialize,
3202 ::serde::Deserialize,
3203 ::derive_builder::Builder,
3204 ::validator::Validate,
3205)]
3206pub struct ChargeTaxBasisType1Choice {
3207 #[serde(flatten)]
3208 pub value: ChargeTaxBasisType1ChoiceEnum,
3209}
3210#[derive(
3211 Debug,
3212 Default,
3213 Clone,
3214 PartialEq,
3215 ::serde::Serialize,
3216 ::serde::Deserialize,
3217 ::derive_builder::Builder,
3218 ::validator::Validate,
3219)]
3220pub struct PartyIdentification55 {
3221 #[serde(rename = "Id")]
3222 pub id: PartyIdentification68Choice,
3223 #[serde(rename = "AltrnId", skip_serializing_if = "Option::is_none")]
3224 pub altrn_id: Option<AlternatePartyIdentification5>,
3225 #[serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none")]
3226 pub addtl_inf: Option<PartyTextInformation1>,
3227}
3228#[derive(
3229 Debug,
3230 Default,
3231 Clone,
3232 PartialEq,
3233 ::serde::Serialize,
3234 ::serde::Deserialize,
3235 ::derive_builder::Builder,
3236 ::validator::Validate,
3237)]
3238pub struct EuCapitalGainType2ChoiceEnum {
3239 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
3240 pub prtry: Option<GenericIdentification38>,
3241 #[serde(rename = "EUCptlGn", skip_serializing_if = "Option::is_none")]
3242 pub eu_cptl_gn: Option<EuCapitalGain2Code>,
3243}
3244#[derive(
3245 Debug,
3246 Default,
3247 Clone,
3248 PartialEq,
3249 ::serde::Serialize,
3250 ::serde::Deserialize,
3251 ::derive_builder::Builder,
3252 ::validator::Validate,
3253)]
3254pub struct EuCapitalGainType2Choice {
3255 #[serde(flatten)]
3256 pub value: EuCapitalGainType2ChoiceEnum,
3257}
3258#[derive(
3259 Debug,
3260 Default,
3261 Clone,
3262 PartialEq,
3263 ::serde::Serialize,
3264 ::serde::Deserialize,
3265 ::derive_builder::Builder,
3266 ::validator::Validate,
3267)]
3268pub struct PartyIdentification68ChoiceEnum {
3269 #[serde(rename = "BIC", skip_serializing_if = "Option::is_none")]
3270 pub bic: Option<AnyBicIdentifier>,
3271 #[serde(rename = "NmAndAdr", skip_serializing_if = "Option::is_none")]
3272 pub nm_and_adr: Option<NameAndAddress13>,
3273 #[serde(rename = "Ctry", skip_serializing_if = "Option::is_none")]
3274 pub ctry: Option<CountryCode>,
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 PartyIdentification68Choice {
3287 #[serde(flatten)]
3288 pub value: PartyIdentification68ChoiceEnum,
3289}
3290#[derive(
3291 Debug,
3292 Default,
3293 Clone,
3294 PartialEq,
3295 ::serde::Serialize,
3296 ::serde::Deserialize,
3297 ::derive_builder::Builder,
3298 ::validator::Validate,
3299)]
3300pub struct InterestComputationMethodFormat3ChoiceEnum {
3301 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
3302 pub cd: Option<InterestComputationMethod2Code>,
3303 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
3304 pub prtry: Option<GenericIdentification38>,
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 InterestComputationMethodFormat3Choice {
3317 #[serde(flatten)]
3318 pub value: InterestComputationMethodFormat3ChoiceEnum,
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 SettlementTransactionType1ChoiceEnum {
3331 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
3332 pub cd: Option<SettlementTransactionType7Code>,
3333 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
3334 pub prtry: Option<GenericIdentification38>,
3335}
3336#[derive(
3337 Debug,
3338 Default,
3339 Clone,
3340 PartialEq,
3341 ::serde::Serialize,
3342 ::serde::Deserialize,
3343 ::derive_builder::Builder,
3344 ::validator::Validate,
3345)]
3346pub struct SettlementTransactionType1Choice {
3347 #[serde(flatten)]
3348 pub value: SettlementTransactionType1ChoiceEnum,
3349}
3350#[derive(
3351 Debug,
3352 Default,
3353 Clone,
3354 PartialEq,
3355 ::serde::Serialize,
3356 ::serde::Deserialize,
3357 ::derive_builder::Builder,
3358 ::validator::Validate,
3359)]
3360pub struct DecimalNumber {
3361 #[serde(rename = "$text")]
3362 pub value: f64,
3363}
3364#[derive(
3365 Debug,
3366 Default,
3367 Clone,
3368 PartialEq,
3369 ::serde::Serialize,
3370 ::serde::Deserialize,
3371 ::derive_builder::Builder,
3372 ::validator::Validate,
3373)]
3374pub struct ActiveOrHistoricCurrencyAndAmountSimpleType {
3375 #[validate(range(min = 0,))]
3376 #[serde(rename = "$text")]
3377 pub value: f64,
3378}
3379#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3380pub enum TypeOfIdentification1Code {
3381 #[serde(rename = "ARNU")]
3382 Arnu,
3383 #[serde(rename = "CCPT")]
3384 Ccpt,
3385 #[serde(rename = "CHTY")]
3386 Chty,
3387 #[serde(rename = "CORP")]
3388 Corp,
3389 #[serde(rename = "DRLC")]
3390 Drlc,
3391 #[serde(rename = "FIIN")]
3392 Fiin,
3393 #[serde(rename = "TXID")]
3394 Txid,
3395 #[default]
3396 Unknown,
3397}
3398#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3399pub enum CashMarginOrder1Code {
3400 #[serde(rename = "CASH")]
3401 Cash,
3402 #[serde(rename = "MRGO")]
3403 Mrgo,
3404 #[serde(rename = "MRGC")]
3405 Mrgc,
3406 #[default]
3407 Unknown,
3408}
3409#[derive(
3410 Debug,
3411 Default,
3412 Clone,
3413 PartialEq,
3414 ::serde::Serialize,
3415 ::serde::Deserialize,
3416 ::derive_builder::Builder,
3417 ::validator::Validate,
3418)]
3419pub struct Max70Text {
3420 #[validate(length(min = 1, max = 70,))]
3421 #[serde(rename = "$text")]
3422 pub value: String,
3423}
3424#[derive(
3425 Debug,
3426 Default,
3427 Clone,
3428 PartialEq,
3429 ::serde::Serialize,
3430 ::serde::Deserialize,
3431 ::derive_builder::Builder,
3432 ::validator::Validate,
3433)]
3434pub struct QuantityOrAmount1ChoiceEnum {
3435 #[serde(rename = "Qty", skip_serializing_if = "Option::is_none")]
3436 pub qty: Option<FinancialInstrumentQuantityChoice>,
3437 #[serde(rename = "Amt", skip_serializing_if = "Option::is_none")]
3438 pub amt: Option<ActiveCurrencyAndAmount>,
3439}
3440#[derive(
3441 Debug,
3442 Default,
3443 Clone,
3444 PartialEq,
3445 ::serde::Serialize,
3446 ::serde::Deserialize,
3447 ::derive_builder::Builder,
3448 ::validator::Validate,
3449)]
3450pub struct QuantityOrAmount1Choice {
3451 #[serde(flatten)]
3452 pub value: QuantityOrAmount1ChoiceEnum,
3453}
3454#[derive(
3455 Debug,
3456 Default,
3457 Clone,
3458 PartialEq,
3459 ::serde::Serialize,
3460 ::serde::Deserialize,
3461 ::derive_builder::Builder,
3462 ::validator::Validate,
3463)]
3464pub struct MatchingStatus8ChoiceEnum {
3465 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
3466 pub cd: Option<MatchingStatus1Code>,
3467 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
3468 pub prtry: Option<GenericIdentification38>,
3469}
3470#[derive(
3471 Debug,
3472 Default,
3473 Clone,
3474 PartialEq,
3475 ::serde::Serialize,
3476 ::serde::Deserialize,
3477 ::derive_builder::Builder,
3478 ::validator::Validate,
3479)]
3480pub struct MatchingStatus8Choice {
3481 #[serde(flatten)]
3482 pub value: MatchingStatus8ChoiceEnum,
3483}
3484#[derive(
3485 Debug,
3486 Default,
3487 Clone,
3488 PartialEq,
3489 ::serde::Serialize,
3490 ::serde::Deserialize,
3491 ::derive_builder::Builder,
3492 ::validator::Validate,
3493)]
3494pub struct ExternalFinancialInstrumentIdentificationType1Code {
3495 #[validate(length(min = 1, max = 4,))]
3496 #[serde(rename = "$text")]
3497 pub value: String,
3498}
3499#[derive(
3500 Debug,
3501 Default,
3502 Clone,
3503 PartialEq,
3504 ::serde::Serialize,
3505 ::serde::Deserialize,
3506 ::derive_builder::Builder,
3507 ::validator::Validate,
3508)]
3509pub struct InterestComputationMethod2ChoiceEnum {
3510 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
3511 pub prtry: Option<GenericIdentification38>,
3512 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
3513 pub cd: Option<InterestComputationMethod1Code>,
3514}
3515#[derive(
3516 Debug,
3517 Default,
3518 Clone,
3519 PartialEq,
3520 ::serde::Serialize,
3521 ::serde::Deserialize,
3522 ::derive_builder::Builder,
3523 ::validator::Validate,
3524)]
3525pub struct InterestComputationMethod2Choice {
3526 #[serde(flatten)]
3527 pub value: InterestComputationMethod2ChoiceEnum,
3528}
3529#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3530pub enum Side3Code {
3531 #[serde(rename = "BUYI")]
3532 Buyi,
3533 #[serde(rename = "SELL")]
3534 Sell,
3535 #[serde(rename = "CROS")]
3536 Cros,
3537 #[serde(rename = "CRSH")]
3538 Crsh,
3539 #[serde(rename = "CSHE")]
3540 Cshe,
3541 #[serde(rename = "DEFI")]
3542 Defi,
3543 #[serde(rename = "OPPO")]
3544 Oppo,
3545 #[serde(rename = "UNDI")]
3546 Undi,
3547 #[serde(rename = "TWOS")]
3548 Twos,
3549 #[serde(rename = "BUMI")]
3550 Bumi,
3551 #[serde(rename = "SEPL")]
3552 Sepl,
3553 #[serde(rename = "SESH")]
3554 Sesh,
3555 #[serde(rename = "SSEX")]
3556 Ssex,
3557 #[serde(rename = "LEND")]
3558 Lend,
3559 #[serde(rename = "BORW")]
3560 Borw,
3561 #[serde(rename = "OPEX")]
3562 Opex,
3563 #[default]
3564 Unknown,
3565}
3566#[derive(
3567 Debug,
3568 Default,
3569 Clone,
3570 PartialEq,
3571 ::serde::Serialize,
3572 ::serde::Deserialize,
3573 ::derive_builder::Builder,
3574 ::validator::Validate,
3575)]
3576pub struct SecuritiesAccount20 {
3577 #[validate]
3578 #[serde(rename = "Id")]
3579 pub id: Max35Text,
3580 #[serde(rename = "Tp")]
3581 pub tp: ClearingAccountType1Code,
3582 #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
3583 pub nm: Option<Max70Text>,
3584}
3585#[derive(
3586 Debug,
3587 Default,
3588 Clone,
3589 PartialEq,
3590 ::serde::Serialize,
3591 ::serde::Deserialize,
3592 ::derive_builder::Builder,
3593 ::validator::Validate,
3594)]
3595pub struct Date2ChoiceEnum {
3596 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
3597 pub cd: Option<DateType2Code>,
3598 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
3599 pub prtry: Option<GenericIdentification38>,
3600}
3601#[derive(
3602 Debug,
3603 Default,
3604 Clone,
3605 PartialEq,
3606 ::serde::Serialize,
3607 ::serde::Deserialize,
3608 ::derive_builder::Builder,
3609 ::validator::Validate,
3610)]
3611pub struct Date2Choice {
3612 #[serde(flatten)]
3613 pub value: Date2ChoiceEnum,
3614}
3615#[derive(
3616 Debug,
3617 Default,
3618 Clone,
3619 PartialEq,
3620 ::serde::Serialize,
3621 ::serde::Deserialize,
3622 ::derive_builder::Builder,
3623 ::validator::Validate,
3624)]
3625pub struct TradingPartyCapacity2ChoiceEnum {
3626 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
3627 pub prtry: Option<GenericIdentification29>,
3628 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
3629 pub cd: Option<TradingCapacity6Code>,
3630}
3631#[derive(
3632 Debug,
3633 Default,
3634 Clone,
3635 PartialEq,
3636 ::serde::Serialize,
3637 ::serde::Deserialize,
3638 ::derive_builder::Builder,
3639 ::validator::Validate,
3640)]
3641pub struct TradingPartyCapacity2Choice {
3642 #[serde(flatten)]
3643 pub value: TradingPartyCapacity2ChoiceEnum,
3644}
3645#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3646pub enum MarketType2Code {
3647 #[serde(rename = "PRIM")]
3648 Prim,
3649 #[serde(rename = "SECM")]
3650 Secm,
3651 #[serde(rename = "OTCO")]
3652 Otco,
3653 #[serde(rename = "VARI")]
3654 Vari,
3655 #[serde(rename = "EXCH")]
3656 Exch,
3657 #[default]
3658 Unknown,
3659}
3660#[derive(
3661 Debug,
3662 Default,
3663 Clone,
3664 PartialEq,
3665 ::serde::Serialize,
3666 ::serde::Deserialize,
3667 ::derive_builder::Builder,
3668 ::validator::Validate,
3669)]
3670pub struct IsoDate {
3671 #[serde(rename = "$text")]
3672 pub value: ::chrono::NaiveDate,
3673}
3674#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3675pub enum InterestComputationMethod1Code {
3676 #[serde(rename = "A001")]
3677 A001,
3678 #[serde(rename = "A002")]
3679 A002,
3680 #[serde(rename = "A003")]
3681 A003,
3682 #[serde(rename = "A004")]
3683 A004,
3684 #[serde(rename = "A005")]
3685 A005,
3686 #[serde(rename = "A006")]
3687 A006,
3688 #[serde(rename = "A007")]
3689 A007,
3690 #[serde(rename = "A008")]
3691 A008,
3692 #[serde(rename = "A009")]
3693 A009,
3694 #[serde(rename = "A010")]
3695 A010,
3696 #[serde(rename = "A011")]
3697 A011,
3698 #[serde(rename = "A012")]
3699 A012,
3700 #[serde(rename = "A013")]
3701 A013,
3702 #[serde(rename = "A014")]
3703 A014,
3704 #[default]
3705 Unknown,
3706}
3707#[derive(
3708 Debug,
3709 Default,
3710 Clone,
3711 PartialEq,
3712 ::serde::Serialize,
3713 ::serde::Deserialize,
3714 ::derive_builder::Builder,
3715 ::validator::Validate,
3716)]
3717pub struct MarketIdentification79 {
3718 #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
3719 pub id: Option<MarketIdentification3Choice>,
3720 #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
3721 pub tp: Option<MarketType11Choice>,
3722}
3723#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3724pub enum TaxLiability1Code {
3725 #[serde(rename = "PRIN")]
3726 Prin,
3727 #[serde(rename = "AGEN")]
3728 Agen,
3729 #[default]
3730 Unknown,
3731}
3732#[derive(
3733 Debug,
3734 Default,
3735 Clone,
3736 PartialEq,
3737 ::serde::Serialize,
3738 ::serde::Deserialize,
3739 ::derive_builder::Builder,
3740 ::validator::Validate,
3741)]
3742pub struct RateOrAbsoluteValue1ChoiceEnum {
3743 #[serde(rename = "RateVal", skip_serializing_if = "Option::is_none")]
3744 pub rate_val: Option<PercentageRate>,
3745 #[serde(rename = "AbsVal", skip_serializing_if = "Option::is_none")]
3746 pub abs_val: Option<Number>,
3747}
3748#[derive(
3749 Debug,
3750 Default,
3751 Clone,
3752 PartialEq,
3753 ::serde::Serialize,
3754 ::serde::Deserialize,
3755 ::derive_builder::Builder,
3756 ::validator::Validate,
3757)]
3758pub struct RateOrAbsoluteValue1Choice {
3759 #[serde(flatten)]
3760 pub value: RateOrAbsoluteValue1ChoiceEnum,
3761}
3762#[derive(
3763 Debug,
3764 Default,
3765 Clone,
3766 PartialEq,
3767 ::serde::Serialize,
3768 ::serde::Deserialize,
3769 ::derive_builder::Builder,
3770 ::validator::Validate,
3771)]
3772pub struct YesNoIndicator {
3773 #[serde(rename = "$text")]
3774 pub value: bool,
3775}
3776#[derive(
3777 Debug,
3778 Default,
3779 Clone,
3780 PartialEq,
3781 ::serde::Serialize,
3782 ::serde::Deserialize,
3783 ::derive_builder::Builder,
3784 ::validator::Validate,
3785)]
3786pub struct DateTimePeriodDetails {
3787 #[validate]
3788 #[serde(rename = "FrDtTm")]
3789 pub fr_dt_tm: IsoDateTime,
3790 #[validate]
3791 #[serde(rename = "ToDtTm")]
3792 pub to_dt_tm: IsoDateTime,
3793}
3794#[derive(
3795 Debug,
3796 Default,
3797 Clone,
3798 PartialEq,
3799 ::serde::Serialize,
3800 ::serde::Deserialize,
3801 ::derive_builder::Builder,
3802 ::validator::Validate,
3803)]
3804pub struct FinancialInstrumentStipulations2 {
3805 #[serde(rename = "Geogcs", skip_serializing_if = "Option::is_none")]
3806 pub geogcs: Option<Max35Text>,
3807 #[serde(rename = "YldRg", skip_serializing_if = "Option::is_none")]
3808 pub yld_rg: Option<AmountOrPercentageRange>,
3809 #[serde(rename = "Ratg", skip_serializing_if = "Option::is_none")]
3810 pub ratg: Option<Rating1>,
3811 #[serde(rename = "CpnRg", skip_serializing_if = "Option::is_none")]
3812 pub cpn_rg: Option<AmountOrPercentageRange>,
3813 #[serde(rename = "AmtsblInd", skip_serializing_if = "Option::is_none")]
3814 pub amtsbl_ind: Option<YesNoIndicator>,
3815 #[serde(rename = "Purp", skip_serializing_if = "Option::is_none")]
3816 pub purp: Option<Max256Text>,
3817 #[serde(rename = "AltrntvMinTaxInd", skip_serializing_if = "Option::is_none")]
3818 pub altrntv_min_tax_ind: Option<YesNoIndicator>,
3819 #[serde(rename = "AutoRinvstmt", skip_serializing_if = "Option::is_none")]
3820 pub auto_rinvstmt: Option<PercentageRate>,
3821 #[serde(rename = "TxConds", skip_serializing_if = "Option::is_none")]
3822 pub tx_conds: Option<TradeTransactionCondition2Code>,
3823 #[serde(rename = "Ccy", skip_serializing_if = "Option::is_none")]
3824 pub ccy: Option<CurrencyCode>,
3825 #[serde(rename = "CstmDt", skip_serializing_if = "Option::is_none")]
3826 pub cstm_dt: Option<DateTimePeriodDetails1>,
3827 #[serde(rename = "Hrcut", skip_serializing_if = "Option::is_none")]
3828 pub hrcut: Option<PercentageRate>,
3829 #[serde(rename = "InsrdInd", skip_serializing_if = "Option::is_none")]
3830 pub insrd_ind: Option<YesNoIndicator>,
3831 #[serde(rename = "LookBck", skip_serializing_if = "Option::is_none")]
3832 pub look_bck: Option<Number>,
3833 #[serde(rename = "MtrtyDt", skip_serializing_if = "Option::is_none")]
3834 pub mtrty_dt: Option<IsoYearMonth>,
3835 #[serde(rename = "IsseDt", skip_serializing_if = "Option::is_none")]
3836 pub isse_dt: Option<IsoYearMonth>,
3837 #[serde(rename = "IssrId", skip_serializing_if = "Option::is_none")]
3838 pub issr_id: Option<BicNonFiIdentifier>,
3839 #[serde(rename = "IsseSz", skip_serializing_if = "Option::is_none")]
3840 pub isse_sz: Option<Number>,
3841 #[serde(rename = "MinDnmtn", skip_serializing_if = "Option::is_none")]
3842 pub min_dnmtn: Option<FinancialInstrumentQuantityChoice>,
3843 #[serde(rename = "MaxSbstitn", skip_serializing_if = "Option::is_none")]
3844 pub max_sbstitn: Option<Number>,
3845 #[serde(rename = "MinIncrmt", skip_serializing_if = "Option::is_none")]
3846 pub min_incrmt: Option<FinancialInstrumentQuantityChoice>,
3847 #[serde(rename = "PmtFrqcy", skip_serializing_if = "Option::is_none")]
3848 pub pmt_frqcy: Option<Frequency1Code>,
3849 #[serde(rename = "MinQty", skip_serializing_if = "Option::is_none")]
3850 pub min_qty: Option<FinancialInstrumentQuantityChoice>,
3851 #[serde(rename = "Pdctn", skip_serializing_if = "Option::is_none")]
3852 pub pdctn: Option<Max35Text>,
3853 #[serde(rename = "RstrctdInd", skip_serializing_if = "Option::is_none")]
3854 pub rstrctd_ind: Option<YesNoIndicator>,
3855 #[serde(rename = "PricFrqcy", skip_serializing_if = "Option::is_none")]
3856 pub pric_frqcy: Option<Frequency1Code>,
3857 #[serde(rename = "Sctr", skip_serializing_if = "Option::is_none")]
3858 pub sctr: Option<Max35Text>,
3859 #[serde(rename = "SbstitnFrqcy", skip_serializing_if = "Option::is_none")]
3860 pub sbstitn_frqcy: Option<Frequency1Code>,
3861 #[serde(rename = "SbstitnLft", skip_serializing_if = "Option::is_none")]
3862 pub sbstitn_lft: Option<Number>,
3863 #[serde(rename = "WhlPoolInd", skip_serializing_if = "Option::is_none")]
3864 pub whl_pool_ind: Option<YesNoIndicator>,
3865 #[serde(rename = "PricSrc", skip_serializing_if = "Option::is_none")]
3866 pub pric_src: Option<Max35Text>,
3867 #[serde(rename = "XprtnDt", skip_serializing_if = "Option::is_none")]
3868 pub xprtn_dt: Option<IsoDateTime>,
3869 #[serde(rename = "OverAlltmtAmt", skip_serializing_if = "Option::is_none")]
3870 pub over_alltmt_amt: Option<ActiveCurrencyAndAmount>,
3871 #[serde(rename = "OverAlltmtRate", skip_serializing_if = "Option::is_none")]
3872 pub over_alltmt_rate: Option<PercentageRate>,
3873 #[serde(rename = "PricRg", skip_serializing_if = "Option::is_none")]
3874 pub pric_rg: Option<AmountOrPercentageRange>,
3875 #[serde(rename = "CllblInd", skip_serializing_if = "Option::is_none")]
3876 pub cllbl_ind: Option<YesNoIndicator>,
3877 #[serde(rename = "ConvtblInd", skip_serializing_if = "Option::is_none")]
3878 pub convtbl_ind: Option<YesNoIndicator>,
3879 #[serde(rename = "PutblInd", skip_serializing_if = "Option::is_none")]
3880 pub putbl_ind: Option<YesNoIndicator>,
3881 #[serde(rename = "PreFnddInd", skip_serializing_if = "Option::is_none")]
3882 pub pre_fndd_ind: Option<YesNoIndicator>,
3883 #[serde(rename = "EscrwdInd", skip_serializing_if = "Option::is_none")]
3884 pub escrwd_ind: Option<YesNoIndicator>,
3885 #[serde(rename = "PerptlInd", skip_serializing_if = "Option::is_none")]
3886 pub perptl_ind: Option<YesNoIndicator>,
3887}
3888#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3889pub enum SecuritiesAccountPurposeType1Code {
3890 #[serde(rename = "MARG")]
3891 Marg,
3892 #[serde(rename = "SHOR")]
3893 Shor,
3894 #[serde(rename = "ABRD")]
3895 Abrd,
3896 #[serde(rename = "CEND")]
3897 Cend,
3898 #[serde(rename = "DVPA")]
3899 Dvpa,
3900 #[serde(rename = "PHYS")]
3901 Phys,
3902 #[default]
3903 Unknown,
3904}
3905#[derive(
3906 Debug,
3907 Default,
3908 Clone,
3909 PartialEq,
3910 ::serde::Serialize,
3911 ::serde::Deserialize,
3912 ::derive_builder::Builder,
3913 ::validator::Validate,
3914)]
3915pub struct RatingValueIdentifier {
3916 #[serde(rename = "$text")]
3917 pub value: String,
3918}
3919#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3920pub enum AutoBorrowing1Code {
3921 #[serde(rename = "LAMI")]
3922 Lami,
3923 #[serde(rename = "NBOR")]
3924 Nbor,
3925 #[serde(rename = "YBOR")]
3926 Ybor,
3927 #[default]
3928 Unknown,
3929}
3930#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3931pub enum RepurchaseType7Code {
3932 #[serde(rename = "CADJ")]
3933 Cadj,
3934 #[serde(rename = "CALL")]
3935 Call,
3936 #[serde(rename = "PAIR")]
3937 Pair,
3938 #[serde(rename = "RATE")]
3939 Rate,
3940 #[serde(rename = "ROLP")]
3941 Rolp,
3942 #[serde(rename = "TOPU")]
3943 Topu,
3944 #[serde(rename = "WTHD")]
3945 Wthd,
3946 #[serde(rename = "PADJ")]
3947 Padj,
3948 #[default]
3949 Unknown,
3950}
3951#[derive(
3952 Debug,
3953 Default,
3954 Clone,
3955 PartialEq,
3956 ::serde::Serialize,
3957 ::serde::Deserialize,
3958 ::derive_builder::Builder,
3959 ::validator::Validate,
3960)]
3961pub struct AmountOrPercentageRange {
3962 #[serde(rename = "Opr", skip_serializing_if = "Option::is_none")]
3963 pub opr: Option<Operation1Code>,
3964 #[validate(length(min = 0, max = 10,))]
3965 #[serde(rename = "Term", default)]
3966 pub term: Vec<Term1>,
3967}
3968#[derive(
3969 Debug,
3970 Default,
3971 Clone,
3972 PartialEq,
3973 ::serde::Serialize,
3974 ::serde::Deserialize,
3975 ::derive_builder::Builder,
3976 ::validator::Validate,
3977)]
3978pub struct BeneficialOwnership3ChoiceEnum {
3979 #[serde(rename = "Ind", skip_serializing_if = "Option::is_none")]
3980 pub ind: Option<YesNoIndicator>,
3981 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
3982 pub prtry: Option<GenericIdentification38>,
3983}
3984#[derive(
3985 Debug,
3986 Default,
3987 Clone,
3988 PartialEq,
3989 ::serde::Serialize,
3990 ::serde::Deserialize,
3991 ::derive_builder::Builder,
3992 ::validator::Validate,
3993)]
3994pub struct BeneficialOwnership3Choice {
3995 #[serde(flatten)]
3996 pub value: BeneficialOwnership3ChoiceEnum,
3997}
3998#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3999pub enum EuCapitalGain2Code {
4000 #[serde(rename = "EUSI")]
4001 Eusi,
4002 #[serde(rename = "EUSO")]
4003 Euso,
4004 #[serde(rename = "UKWN")]
4005 Ukwn,
4006 #[default]
4007 Unknown,
4008}
4009#[derive(
4010 Debug,
4011 Default,
4012 Clone,
4013 PartialEq,
4014 ::serde::Serialize,
4015 ::serde::Deserialize,
4016 ::derive_builder::Builder,
4017 ::validator::Validate,
4018)]
4019pub struct DateAndDateTimeChoiceEnum {
4020 #[serde(rename = "Dt", skip_serializing_if = "Option::is_none")]
4021 pub dt: Option<IsoDate>,
4022 #[serde(rename = "DtTm", skip_serializing_if = "Option::is_none")]
4023 pub dt_tm: Option<IsoDateTime>,
4024}
4025#[derive(
4026 Debug,
4027 Default,
4028 Clone,
4029 PartialEq,
4030 ::serde::Serialize,
4031 ::serde::Deserialize,
4032 ::derive_builder::Builder,
4033 ::validator::Validate,
4034)]
4035pub struct DateAndDateTimeChoice {
4036 #[serde(flatten)]
4037 pub value: DateAndDateTimeChoiceEnum,
4038}
4039#[derive(
4040 Debug,
4041 Default,
4042 Clone,
4043 PartialEq,
4044 ::serde::Serialize,
4045 ::serde::Deserialize,
4046 ::derive_builder::Builder,
4047 ::validator::Validate,
4048)]
4049pub struct Max140Text {
4050 #[validate(length(min = 1, max = 140,))]
4051 #[serde(rename = "$text")]
4052 pub value: String,
4053}
4054#[derive(
4055 Debug,
4056 Default,
4057 Clone,
4058 PartialEq,
4059 ::serde::Serialize,
4060 ::serde::Deserialize,
4061 ::derive_builder::Builder,
4062 ::validator::Validate,
4063)]
4064pub struct PercentageRate {
4065 #[serde(rename = "$text")]
4066 pub value: f64,
4067}
4068#[derive(
4069 Debug,
4070 Default,
4071 Clone,
4072 PartialEq,
4073 ::serde::Serialize,
4074 ::serde::Deserialize,
4075 ::derive_builder::Builder,
4076 ::validator::Validate,
4077)]
4078pub struct ActiveCurrencyAndAmount {
4079 #[serde(rename = "ActiveCurrencyAndAmount")]
4080 pub value: ActiveCurrencyAndAmountSimpleType,
4081 #[serde(rename = "@Ccy")]
4082 pub ccy: ActiveCurrencyCode,
4083}
4084#[derive(
4085 Debug,
4086 Default,
4087 Clone,
4088 PartialEq,
4089 ::serde::Serialize,
4090 ::serde::Deserialize,
4091 ::derive_builder::Builder,
4092 ::validator::Validate,
4093)]
4094pub struct PurposeCode5ChoiceEnum {
4095 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
4096 pub cd: Option<SecuritiesAccountPurposeType1Code>,
4097 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
4098 pub prtry: Option<GenericIdentification38>,
4099}
4100#[derive(
4101 Debug,
4102 Default,
4103 Clone,
4104 PartialEq,
4105 ::serde::Serialize,
4106 ::serde::Deserialize,
4107 ::derive_builder::Builder,
4108 ::validator::Validate,
4109)]
4110pub struct PurposeCode5Choice {
4111 #[serde(flatten)]
4112 pub value: PurposeCode5ChoiceEnum,
4113}
4114#[derive(
4115 Debug,
4116 Default,
4117 Clone,
4118 PartialEq,
4119 ::serde::Serialize,
4120 ::serde::Deserialize,
4121 ::derive_builder::Builder,
4122 ::validator::Validate,
4123)]
4124pub struct LendingTransactionMethod1ChoiceEnum {
4125 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
4126 pub cd: Option<LendingTransactionMethod1Code>,
4127 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
4128 pub prtry: Option<GenericIdentification38>,
4129}
4130#[derive(
4131 Debug,
4132 Default,
4133 Clone,
4134 PartialEq,
4135 ::serde::Serialize,
4136 ::serde::Deserialize,
4137 ::derive_builder::Builder,
4138 ::validator::Validate,
4139)]
4140pub struct LendingTransactionMethod1Choice {
4141 #[serde(flatten)]
4142 pub value: LendingTransactionMethod1ChoiceEnum,
4143}
4144#[derive(
4145 Debug,
4146 Default,
4147 Clone,
4148 PartialEq,
4149 ::serde::Serialize,
4150 ::serde::Deserialize,
4151 ::derive_builder::Builder,
4152 ::validator::Validate,
4153)]
4154pub struct RepurchaseType11ChoiceEnum {
4155 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
4156 pub cd: Option<RepurchaseType7Code>,
4157 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
4158 pub prtry: Option<GenericIdentification38>,
4159}
4160#[derive(
4161 Debug,
4162 Default,
4163 Clone,
4164 PartialEq,
4165 ::serde::Serialize,
4166 ::serde::Deserialize,
4167 ::derive_builder::Builder,
4168 ::validator::Validate,
4169)]
4170pub struct RepurchaseType11Choice {
4171 #[serde(flatten)]
4172 pub value: RepurchaseType11ChoiceEnum,
4173}
4174#[derive(
4175 Debug,
4176 Default,
4177 Clone,
4178 PartialEq,
4179 ::serde::Serialize,
4180 ::serde::Deserialize,
4181 ::derive_builder::Builder,
4182 ::validator::Validate,
4183)]
4184pub struct Max35Text {
4185 #[validate(length(min = 1, max = 35,))]
4186 #[serde(rename = "$text")]
4187 pub value: String,
4188}
4189#[derive(
4190 Debug,
4191 Default,
4192 Clone,
4193 PartialEq,
4194 ::serde::Serialize,
4195 ::serde::Deserialize,
4196 ::derive_builder::Builder,
4197 ::validator::Validate,
4198)]
4199pub struct FutureOrOptionDetails1 {
4200 #[serde(rename = "FutrAndOptnCtrctTp", skip_serializing_if = "Option::is_none")]
4201 pub futr_and_optn_ctrct_tp: Option<FutureAndOptionContractType1Code>,
4202 #[serde(rename = "LastDlvryDt", skip_serializing_if = "Option::is_none")]
4203 pub last_dlvry_dt: Option<IsoDateTime>,
4204 #[serde(rename = "UnitOfMeasr", skip_serializing_if = "Option::is_none")]
4205 pub unit_of_measr: Option<UnitOfMeasure1Code>,
4206 #[serde(rename = "FutrDt", skip_serializing_if = "Option::is_none")]
4207 pub futr_dt: Option<IsoDateTime>,
4208 #[serde(rename = "MinSz", skip_serializing_if = "Option::is_none")]
4209 pub min_sz: Option<ActiveCurrencyAndAmount>,
4210 #[serde(rename = "AnncmntDt", skip_serializing_if = "Option::is_none")]
4211 pub anncmnt_dt: Option<IsoDateTime>,
4212 #[serde(rename = "Apprnc", skip_serializing_if = "Option::is_none")]
4213 pub apprnc: Option<Appearance1Code>,
4214 #[serde(rename = "StrpblInd", skip_serializing_if = "Option::is_none")]
4215 pub strpbl_ind: Option<YesNoIndicator>,
4216 #[serde(rename = "PosLmt", skip_serializing_if = "Option::is_none")]
4217 pub pos_lmt: Option<Number>,
4218 #[serde(rename = "NearTermPosLmt", skip_serializing_if = "Option::is_none")]
4219 pub near_term_pos_lmt: Option<Number>,
4220 #[serde(
4221 rename = "MinTradgPricgIncrmt",
4222 skip_serializing_if = "Option::is_none"
4223 )]
4224 pub min_tradg_pricg_incrmt: Option<Number>,
4225 #[serde(rename = "Purp", skip_serializing_if = "Option::is_none")]
4226 pub purp: Option<Max256Text>,
4227 #[serde(rename = "CtrctSttlmMnth", skip_serializing_if = "Option::is_none")]
4228 pub ctrct_sttlm_mnth: Option<IsoYearMonth>,
4229 #[serde(rename = "FrstDealgDt", skip_serializing_if = "Option::is_none")]
4230 pub frst_dealg_dt: Option<DateAndDateTime1Choice>,
4231 #[validate(length(min = 0,))]
4232 #[serde(rename = "Ratio", default)]
4233 pub ratio: Vec<UnderlyingRatio1>,
4234 #[validate(length(min = 0,))]
4235 #[serde(rename = "Ratg", default)]
4236 pub ratg: Vec<Rating1>,
4237 #[serde(rename = "IssePric", skip_serializing_if = "Option::is_none")]
4238 pub isse_pric: Option<Price4>,
4239 #[serde(rename = "OptnRghts", skip_serializing_if = "Option::is_none")]
4240 pub optn_rghts: Option<OptionRight1Choice>,
4241 #[serde(rename = "LastTx", skip_serializing_if = "Option::is_none")]
4242 pub last_tx: Option<YesNoIndicator>,
4243 #[serde(rename = "SprdTx", skip_serializing_if = "Option::is_none")]
4244 pub sprd_tx: Option<YesNoIndicator>,
4245}
4246#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
4247pub enum BorrowingReason1Code {
4248 #[serde(rename = "SFCT")]
4249 Sfct,
4250 #[serde(rename = "TTTP")]
4251 Tttp,
4252 #[serde(rename = "MMPP")]
4253 Mmpp,
4254 #[default]
4255 Unknown,
4256}
4257#[derive(
4258 Debug,
4259 Default,
4260 Clone,
4261 PartialEq,
4262 ::serde::Serialize,
4263 ::serde::Deserialize,
4264 ::derive_builder::Builder,
4265 ::validator::Validate,
4266)]
4267pub struct Number {
4268 #[serde(rename = "$text")]
4269 pub value: f64,
4270}
4271#[derive(
4272 Debug,
4273 Default,
4274 Clone,
4275 PartialEq,
4276 ::serde::Serialize,
4277 ::serde::Deserialize,
4278 ::derive_builder::Builder,
4279 ::validator::Validate,
4280)]
4281pub struct Number21ChoiceEnum {
4282 #[serde(rename = "NbId", skip_serializing_if = "Option::is_none")]
4283 pub nb_id: Option<Max4NumericText>,
4284 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
4285 pub prtry: Option<GenericIdentification29>,
4286}
4287#[derive(
4288 Debug,
4289 Default,
4290 Clone,
4291 PartialEq,
4292 ::serde::Serialize,
4293 ::serde::Deserialize,
4294 ::derive_builder::Builder,
4295 ::validator::Validate,
4296)]
4297pub struct Number21Choice {
4298 #[serde(flatten)]
4299 pub value: Number21ChoiceEnum,
4300}
4301#[derive(
4302 Debug,
4303 Default,
4304 Clone,
4305 PartialEq,
4306 ::serde::Serialize,
4307 ::serde::Deserialize,
4308 ::derive_builder::Builder,
4309 ::validator::Validate,
4310)]
4311pub struct PriceInformation11 {
4312 #[validate]
4313 #[serde(rename = "Val")]
4314 pub val: Price4,
4315 #[serde(rename = "QtnDt", skip_serializing_if = "Option::is_none")]
4316 pub qtn_dt: Option<DateAndDateTime1Choice>,
4317 #[serde(rename = "PricClctnPrd", skip_serializing_if = "Option::is_none")]
4318 pub pric_clctn_prd: Option<DateTimePeriodChoice>,
4319 #[serde(rename = "SrcOfPric", skip_serializing_if = "Option::is_none")]
4320 pub src_of_pric: Option<MarketIdentification79>,
4321}
4322#[derive(
4323 Debug,
4324 Default,
4325 Clone,
4326 PartialEq,
4327 ::serde::Serialize,
4328 ::serde::Deserialize,
4329 ::derive_builder::Builder,
4330 ::validator::Validate,
4331)]
4332pub struct ConfirmationPartyDetails3 {
4333 #[serde(rename = "Id")]
4334 pub id: PartyIdentification32Choice,
4335 #[serde(rename = "SfkpgAcct", skip_serializing_if = "Option::is_none")]
4336 pub sfkpg_acct: Option<SecuritiesAccount3>,
4337 #[serde(rename = "CshDtls", skip_serializing_if = "Option::is_none")]
4338 pub csh_dtls: Option<AccountIdentification3Choice>,
4339 #[serde(rename = "AltrnId", skip_serializing_if = "Option::is_none")]
4340 pub altrn_id: Option<AlternatePartyIdentification5>,
4341 #[serde(rename = "PrcgId", skip_serializing_if = "Option::is_none")]
4342 pub prcg_id: Option<Max35Text>,
4343 #[serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none")]
4344 pub addtl_inf: Option<PartyTextInformation5>,
4345 #[serde(rename = "PtyCpcty", skip_serializing_if = "Option::is_none")]
4346 pub pty_cpcty: Option<TradingPartyCapacity2Choice>,
4347}
4348#[derive(
4349 Debug,
4350 Default,
4351 Clone,
4352 PartialEq,
4353 ::serde::Serialize,
4354 ::serde::Deserialize,
4355 ::derive_builder::Builder,
4356 ::validator::Validate,
4357)]
4358pub struct GenericIdentification29 {
4359 #[validate]
4360 #[serde(rename = "Id")]
4361 pub id: Max35Text,
4362 #[validate]
4363 #[serde(rename = "Issr")]
4364 pub issr: Max35Text,
4365 #[serde(rename = "SchmeNm", skip_serializing_if = "Option::is_none")]
4366 pub schme_nm: Option<Max35Text>,
4367}
4368#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
4369pub enum RateType1Code {
4370 #[serde(rename = "FIXE")]
4371 Fixe,
4372 #[serde(rename = "FORF")]
4373 Forf,
4374 #[serde(rename = "VARI")]
4375 Vari,
4376 #[default]
4377 Unknown,
4378}
4379#[derive(
4380 Debug,
4381 Default,
4382 Clone,
4383 PartialEq,
4384 ::serde::Serialize,
4385 ::serde::Deserialize,
4386 ::derive_builder::Builder,
4387 ::validator::Validate,
4388)]
4389pub struct FinancialInstrumentAttributes44 {
4390 #[serde(rename = "PlcOfListg", skip_serializing_if = "Option::is_none")]
4391 pub plc_of_listg: Option<MarketIdentification3Choice>,
4392 #[serde(rename = "Ratg", skip_serializing_if = "Option::is_none")]
4393 pub ratg: Option<Rating1>,
4394 #[serde(rename = "CertNb", skip_serializing_if = "Option::is_none")]
4395 pub cert_nb: Option<Max35Text>,
4396 #[serde(rename = "DayCntBsis", skip_serializing_if = "Option::is_none")]
4397 pub day_cnt_bsis: Option<InterestComputationMethodFormat3Choice>,
4398 #[serde(rename = "RegnForm", skip_serializing_if = "Option::is_none")]
4399 pub regn_form: Option<FormOfSecurity4Choice>,
4400 #[serde(rename = "PmtFrqcy", skip_serializing_if = "Option::is_none")]
4401 pub pmt_frqcy: Option<Frequency7Choice>,
4402 #[serde(rename = "VarblRateChngFrqcy", skip_serializing_if = "Option::is_none")]
4403 pub varbl_rate_chng_frqcy: Option<Frequency7Choice>,
4404 #[serde(rename = "ClssfctnTp", skip_serializing_if = "Option::is_none")]
4405 pub clssfctn_tp: Option<ClassificationType30Choice>,
4406 #[serde(rename = "OptnStyle", skip_serializing_if = "Option::is_none")]
4407 pub optn_style: Option<OptionStyle6Choice>,
4408 #[serde(rename = "OptnTp", skip_serializing_if = "Option::is_none")]
4409 pub optn_tp: Option<OptionType4Choice>,
4410 #[serde(rename = "DnmtnCcy", skip_serializing_if = "Option::is_none")]
4411 pub dnmtn_ccy: Option<ActiveOrHistoricCurrencyCode>,
4412 #[serde(rename = "CpnDt", skip_serializing_if = "Option::is_none")]
4413 pub cpn_dt: Option<IsoDate>,
4414 #[serde(rename = "XpryDt", skip_serializing_if = "Option::is_none")]
4415 pub xpry_dt: Option<IsoDate>,
4416 #[serde(rename = "FltgRateFxgDt", skip_serializing_if = "Option::is_none")]
4417 pub fltg_rate_fxg_dt: Option<IsoDate>,
4418 #[serde(rename = "MtrtyDt", skip_serializing_if = "Option::is_none")]
4419 pub mtrty_dt: Option<IsoDate>,
4420 #[serde(rename = "IsseDt", skip_serializing_if = "Option::is_none")]
4421 pub isse_dt: Option<IsoDate>,
4422 #[serde(rename = "NxtCllblDt", skip_serializing_if = "Option::is_none")]
4423 pub nxt_cllbl_dt: Option<IsoDate>,
4424 #[serde(rename = "ConvsDt", skip_serializing_if = "Option::is_none")]
4425 pub convs_dt: Option<IsoDate>,
4426 #[serde(rename = "PutblDt", skip_serializing_if = "Option::is_none")]
4427 pub putbl_dt: Option<IsoDate>,
4428 #[serde(rename = "DtdDt", skip_serializing_if = "Option::is_none")]
4429 pub dtd_dt: Option<IsoDate>,
4430 #[serde(rename = "FrstPmtDt", skip_serializing_if = "Option::is_none")]
4431 pub frst_pmt_dt: Option<IsoDate>,
4432 #[serde(rename = "NxtFctrDt", skip_serializing_if = "Option::is_none")]
4433 pub nxt_fctr_dt: Option<IsoDate>,
4434 #[serde(rename = "PrvsFctr", skip_serializing_if = "Option::is_none")]
4435 pub prvs_fctr: Option<BaseOneRate>,
4436 #[serde(rename = "CurFctr", skip_serializing_if = "Option::is_none")]
4437 pub cur_fctr: Option<BaseOneRate>,
4438 #[serde(rename = "NxtFctr", skip_serializing_if = "Option::is_none")]
4439 pub nxt_fctr: Option<BaseOneRate>,
4440 #[serde(rename = "EndFctr", skip_serializing_if = "Option::is_none")]
4441 pub end_fctr: Option<BaseOneRate>,
4442 #[serde(rename = "IntrstRate", skip_serializing_if = "Option::is_none")]
4443 pub intrst_rate: Option<PercentageRate>,
4444 #[serde(rename = "NxtIntrstRate", skip_serializing_if = "Option::is_none")]
4445 pub nxt_intrst_rate: Option<PercentageRate>,
4446 #[serde(rename = "IndxRateBsis", skip_serializing_if = "Option::is_none")]
4447 pub indx_rate_bsis: Option<PercentageRate>,
4448 #[serde(rename = "PctgOfDebtClms", skip_serializing_if = "Option::is_none")]
4449 pub pctg_of_debt_clms: Option<PercentageRate>,
4450 #[serde(rename = "CpnAttchdNb", skip_serializing_if = "Option::is_none")]
4451 pub cpn_attchd_nb: Option<Number1Choice>,
4452 #[serde(rename = "PoolNb", skip_serializing_if = "Option::is_none")]
4453 pub pool_nb: Option<GenericIdentification37>,
4454 #[serde(rename = "VrsnNb", skip_serializing_if = "Option::is_none")]
4455 pub vrsn_nb: Option<Number1Choice>,
4456 #[serde(rename = "ConvtblInd", skip_serializing_if = "Option::is_none")]
4457 pub convtbl_ind: Option<YesNoIndicator>,
4458 #[serde(rename = "VarblRateInd", skip_serializing_if = "Option::is_none")]
4459 pub varbl_rate_ind: Option<YesNoIndicator>,
4460 #[serde(rename = "CvrdInd", skip_serializing_if = "Option::is_none")]
4461 pub cvrd_ind: Option<YesNoIndicator>,
4462 #[serde(rename = "CllblInd", skip_serializing_if = "Option::is_none")]
4463 pub cllbl_ind: Option<YesNoIndicator>,
4464 #[serde(rename = "PutblInd", skip_serializing_if = "Option::is_none")]
4465 pub putbl_ind: Option<YesNoIndicator>,
4466 #[serde(rename = "WarrtAttchdOnDlvry", skip_serializing_if = "Option::is_none")]
4467 pub warrt_attchd_on_dlvry: Option<YesNoIndicator>,
4468 #[serde(rename = "OddCpnInd", skip_serializing_if = "Option::is_none")]
4469 pub odd_cpn_ind: Option<YesNoIndicator>,
4470 #[serde(rename = "RedYldImpct", skip_serializing_if = "Option::is_none")]
4471 pub red_yld_impct: Option<YesNoIndicator>,
4472 #[serde(rename = "YldVar", skip_serializing_if = "Option::is_none")]
4473 pub yld_var: Option<YesNoIndicator>,
4474 #[serde(rename = "ExrcPric", skip_serializing_if = "Option::is_none")]
4475 pub exrc_pric: Option<Price4>,
4476 #[serde(rename = "SbcptPric", skip_serializing_if = "Option::is_none")]
4477 pub sbcpt_pric: Option<Price4>,
4478 #[serde(rename = "ConvsPric", skip_serializing_if = "Option::is_none")]
4479 pub convs_pric: Option<Price4>,
4480 #[serde(rename = "TaxblIncmPerShr", skip_serializing_if = "Option::is_none")]
4481 pub taxbl_incm_per_shr: Option<Price4>,
4482 #[serde(rename = "MinNmnlQty", skip_serializing_if = "Option::is_none")]
4483 pub min_nmnl_qty: Option<FinancialInstrumentQuantity1Choice>,
4484 #[serde(rename = "MinExrcblQty", skip_serializing_if = "Option::is_none")]
4485 pub min_exrcbl_qty: Option<FinancialInstrumentQuantity1Choice>,
4486 #[serde(rename = "MinExrcblMltplQty", skip_serializing_if = "Option::is_none")]
4487 pub min_exrcbl_mltpl_qty: Option<FinancialInstrumentQuantity1Choice>,
4488 #[serde(rename = "FaceAmt", skip_serializing_if = "Option::is_none")]
4489 pub face_amt: Option<ImpliedCurrencyAndAmount>,
4490 #[serde(rename = "CtrctSz", skip_serializing_if = "Option::is_none")]
4491 pub ctrct_sz: Option<FinancialInstrumentQuantity18Choice>,
4492 #[serde(
4493 rename = "FinInstrmAttrAddtlDtls",
4494 skip_serializing_if = "Option::is_none"
4495 )]
4496 pub fin_instrm_attr_addtl_dtls: Option<Max350Text>,
4497}
4498#[derive(
4499 Debug,
4500 Default,
4501 Clone,
4502 PartialEq,
4503 ::serde::Serialize,
4504 ::serde::Deserialize,
4505 ::derive_builder::Builder,
4506 ::validator::Validate,
4507)]
4508pub struct BbanIdentifier {
4509 #[validate(regex = "BBAN_IDENTIFIER_REGEX")]
4510 #[serde(rename = "$text")]
4511 pub value: String,
4512}
4513#[derive(
4514 Debug,
4515 Default,
4516 Clone,
4517 PartialEq,
4518 ::serde::Serialize,
4519 ::serde::Deserialize,
4520 ::derive_builder::Builder,
4521 ::validator::Validate,
4522)]
4523pub struct DateAndDateTime1ChoiceEnum {
4524 #[serde(rename = "DtTm", skip_serializing_if = "Option::is_none")]
4525 pub dt_tm: Option<IsoDateTime>,
4526 #[serde(rename = "Dt", skip_serializing_if = "Option::is_none")]
4527 pub dt: Option<IsoDate>,
4528}
4529#[derive(
4530 Debug,
4531 Default,
4532 Clone,
4533 PartialEq,
4534 ::serde::Serialize,
4535 ::serde::Deserialize,
4536 ::derive_builder::Builder,
4537 ::validator::Validate,
4538)]
4539pub struct DateAndDateTime1Choice {
4540 #[serde(flatten)]
4541 pub value: DateAndDateTime1ChoiceEnum,
4542}
4543#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
4544pub enum Operator1Code {
4545 #[serde(rename = "SMAL")]
4546 Smal,
4547 #[serde(rename = "SMEQ")]
4548 Smeq,
4549 #[serde(rename = "GREA")]
4550 Grea,
4551 #[serde(rename = "GREQ")]
4552 Greq,
4553 #[serde(rename = "EQAL")]
4554 Eqal,
4555 #[default]
4556 Unknown,
4557}
4558#[derive(
4559 Debug,
4560 Default,
4561 Clone,
4562 PartialEq,
4563 ::serde::Serialize,
4564 ::serde::Deserialize,
4565 ::derive_builder::Builder,
4566 ::validator::Validate,
4567)]
4568pub struct CommissionType2ChoiceEnum {
4569 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
4570 pub cd: Option<CommissionType9Code>,
4571 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
4572 pub prtry: Option<GenericIdentification38>,
4573}
4574#[derive(
4575 Debug,
4576 Default,
4577 Clone,
4578 PartialEq,
4579 ::serde::Serialize,
4580 ::serde::Deserialize,
4581 ::derive_builder::Builder,
4582 ::validator::Validate,
4583)]
4584pub struct CommissionType2Choice {
4585 #[serde(flatten)]
4586 pub value: CommissionType2ChoiceEnum,
4587}
4588#[derive(
4589 Debug,
4590 Default,
4591 Clone,
4592 PartialEq,
4593 ::serde::Serialize,
4594 ::serde::Deserialize,
4595 ::derive_builder::Builder,
4596 ::validator::Validate,
4597)]
4598pub struct OptionType4ChoiceEnum {
4599 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
4600 pub prtry: Option<GenericIdentification38>,
4601 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
4602 pub cd: Option<OptionType1Code>,
4603}
4604#[derive(
4605 Debug,
4606 Default,
4607 Clone,
4608 PartialEq,
4609 ::serde::Serialize,
4610 ::serde::Deserialize,
4611 ::derive_builder::Builder,
4612 ::validator::Validate,
4613)]
4614pub struct OptionType4Choice {
4615 #[serde(flatten)]
4616 pub value: OptionType4ChoiceEnum,
4617}
4618#[derive(
4619 Debug,
4620 Default,
4621 Clone,
4622 PartialEq,
4623 ::serde::Serialize,
4624 ::serde::Deserialize,
4625 ::derive_builder::Builder,
4626 ::validator::Validate,
4627)]
4628pub struct AccountIdentification3ChoiceEnum {
4629 #[serde(rename = "BBAN", skip_serializing_if = "Option::is_none")]
4630 pub bban: Option<BbanIdentifier>,
4631 #[serde(rename = "PrtryAcct", skip_serializing_if = "Option::is_none")]
4632 pub prtry_acct: Option<SimpleIdentificationInformation2>,
4633 #[serde(rename = "IBAN", skip_serializing_if = "Option::is_none")]
4634 pub iban: Option<IbanIdentifier>,
4635 #[serde(rename = "UPIC", skip_serializing_if = "Option::is_none")]
4636 pub upic: Option<UpicIdentifier>,
4637}
4638#[derive(
4639 Debug,
4640 Default,
4641 Clone,
4642 PartialEq,
4643 ::serde::Serialize,
4644 ::serde::Deserialize,
4645 ::derive_builder::Builder,
4646 ::validator::Validate,
4647)]
4648pub struct AccountIdentification3Choice {
4649 #[serde(flatten)]
4650 pub value: AccountIdentification3ChoiceEnum,
4651}
4652#[derive(
4653 Debug,
4654 Default,
4655 Clone,
4656 PartialEq,
4657 ::serde::Serialize,
4658 ::serde::Deserialize,
4659 ::derive_builder::Builder,
4660 ::validator::Validate,
4661)]
4662pub struct PriceRateOrAmountChoiceEnum {
4663 #[serde(rename = "Rate", skip_serializing_if = "Option::is_none")]
4664 pub rate: Option<PercentageRate>,
4665 #[serde(rename = "Amt", skip_serializing_if = "Option::is_none")]
4666 pub amt: Option<ActiveOrHistoricCurrencyAnd13DecimalAmount>,
4667}
4668#[derive(
4669 Debug,
4670 Default,
4671 Clone,
4672 PartialEq,
4673 ::serde::Serialize,
4674 ::serde::Deserialize,
4675 ::derive_builder::Builder,
4676 ::validator::Validate,
4677)]
4678pub struct PriceRateOrAmountChoice {
4679 #[serde(flatten)]
4680 pub value: PriceRateOrAmountChoiceEnum,
4681}
4682#[derive(
4683 Debug,
4684 Default,
4685 Clone,
4686 PartialEq,
4687 ::serde::Serialize,
4688 ::serde::Deserialize,
4689 ::derive_builder::Builder,
4690 ::validator::Validate,
4691)]
4692pub struct SupplementaryDataEnvelope1<
4693 A: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
4694> {
4695 #[validate]
4696 #[serde(flatten)]
4697 pub value: A,
4698}
4699#[derive(
4700 Debug,
4701 Default,
4702 Clone,
4703 PartialEq,
4704 ::serde::Serialize,
4705 ::serde::Deserialize,
4706 ::derive_builder::Builder,
4707 ::validator::Validate,
4708)]
4709pub struct PartyIdentificationAndAccount78 {
4710 #[serde(rename = "Id")]
4711 pub id: PartyIdentification32Choice,
4712 #[serde(rename = "AltrnId", skip_serializing_if = "Option::is_none")]
4713 pub altrn_id: Option<AlternatePartyIdentification5>,
4714 #[serde(rename = "Sd", skip_serializing_if = "Option::is_none")]
4715 pub sd: Option<ClearingSide1Code>,
4716 #[serde(rename = "ClrAcct", skip_serializing_if = "Option::is_none")]
4717 pub clr_acct: Option<SecuritiesAccount20>,
4718 #[serde(rename = "PrcgId", skip_serializing_if = "Option::is_none")]
4719 pub prcg_id: Option<Max35Text>,
4720 #[serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none")]
4721 pub addtl_inf: Option<PartyTextInformation1>,
4722}
4723#[derive(
4724 Debug,
4725 Default,
4726 Clone,
4727 PartialEq,
4728 ::serde::Serialize,
4729 ::serde::Deserialize,
4730 ::derive_builder::Builder,
4731 ::validator::Validate,
4732)]
4733pub struct IsinIdentifier {
4734 #[validate(regex = "ISIN_IDENTIFIER_REGEX")]
4735 #[serde(rename = "$text")]
4736 pub value: String,
4737}
4738#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
4739pub enum OptionStyle4Code {
4740 #[serde(rename = "AMER")]
4741 Amer,
4742 #[serde(rename = "EURO")]
4743 Euro,
4744 #[serde(rename = "BERM")]
4745 Berm,
4746 #[default]
4747 Unknown,
4748}
4749#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
4750pub enum LendingTransactionMethod1Code {
4751 #[serde(rename = "ODTR")]
4752 Odtr,
4753 #[serde(rename = "EXTR")]
4754 Extr,
4755 #[default]
4756 Unknown,
4757}
4758#[derive(
4759 Debug,
4760 Default,
4761 Clone,
4762 PartialEq,
4763 ::serde::Serialize,
4764 ::serde::Deserialize,
4765 ::derive_builder::Builder,
4766 ::validator::Validate,
4767)]
4768pub struct TradeDate1ChoiceEnum {
4769 #[serde(rename = "Dt", skip_serializing_if = "Option::is_none")]
4770 pub dt: Option<DateAndDateTimeChoice>,
4771 #[serde(rename = "DtCd", skip_serializing_if = "Option::is_none")]
4772 pub dt_cd: Option<TradeDateCode1Choice>,
4773}
4774#[derive(
4775 Debug,
4776 Default,
4777 Clone,
4778 PartialEq,
4779 ::serde::Serialize,
4780 ::serde::Deserialize,
4781 ::derive_builder::Builder,
4782 ::validator::Validate,
4783)]
4784pub struct TradeDate1Choice {
4785 #[serde(flatten)]
4786 pub value: TradeDate1ChoiceEnum,
4787}
4788#[derive(
4789 Debug,
4790 Default,
4791 Clone,
4792 PartialEq,
4793 ::serde::Serialize,
4794 ::serde::Deserialize,
4795 ::derive_builder::Builder,
4796 ::validator::Validate,
4797)]
4798pub struct ModificationCancellationAllowed3ChoiceEnum {
4799 #[serde(rename = "Ind", skip_serializing_if = "Option::is_none")]
4800 pub ind: Option<YesNoIndicator>,
4801 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
4802 pub prtry: Option<GenericIdentification38>,
4803}
4804#[derive(
4805 Debug,
4806 Default,
4807 Clone,
4808 PartialEq,
4809 ::serde::Serialize,
4810 ::serde::Deserialize,
4811 ::derive_builder::Builder,
4812 ::validator::Validate,
4813)]
4814pub struct ModificationCancellationAllowed3Choice {
4815 #[serde(flatten)]
4816 pub value: ModificationCancellationAllowed3ChoiceEnum,
4817}
4818#[derive(
4819 Debug,
4820 Default,
4821 Clone,
4822 PartialEq,
4823 ::serde::Serialize,
4824 ::serde::Deserialize,
4825 ::derive_builder::Builder,
4826 ::validator::Validate,
4827)]
4828pub struct OptionStyle6ChoiceEnum {
4829 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
4830 pub prtry: Option<GenericIdentification38>,
4831 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
4832 pub cd: Option<OptionStyle4Code>,
4833}
4834#[derive(
4835 Debug,
4836 Default,
4837 Clone,
4838 PartialEq,
4839 ::serde::Serialize,
4840 ::serde::Deserialize,
4841 ::derive_builder::Builder,
4842 ::validator::Validate,
4843)]
4844pub struct OptionStyle6Choice {
4845 #[serde(flatten)]
4846 pub value: OptionStyle6ChoiceEnum,
4847}
4848#[derive(
4849 Debug,
4850 Default,
4851 Clone,
4852 PartialEq,
4853 ::serde::Serialize,
4854 ::serde::Deserialize,
4855 ::derive_builder::Builder,
4856 ::validator::Validate,
4857)]
4858pub struct Quantity6ChoiceEnum {
4859 #[serde(rename = "OrgnlAndCurFace", skip_serializing_if = "Option::is_none")]
4860 pub orgnl_and_cur_face: Option<OriginalAndCurrentQuantities1>,
4861 #[serde(rename = "Qty", skip_serializing_if = "Option::is_none")]
4862 pub qty: Option<FinancialInstrumentQuantity1Choice>,
4863}
4864#[derive(
4865 Debug,
4866 Default,
4867 Clone,
4868 PartialEq,
4869 ::serde::Serialize,
4870 ::serde::Deserialize,
4871 ::derive_builder::Builder,
4872 ::validator::Validate,
4873)]
4874pub struct Quantity6Choice {
4875 #[serde(flatten)]
4876 pub value: Quantity6ChoiceEnum,
4877}
4878#[derive(
4879 Debug,
4880 Default,
4881 Clone,
4882 PartialEq,
4883 ::serde::Serialize,
4884 ::serde::Deserialize,
4885 ::derive_builder::Builder,
4886 ::validator::Validate,
4887)]
4888pub struct PartyIdentificationAndAccount80 {
4889 #[serde(rename = "Id")]
4890 pub id: PartyIdentification32Choice,
4891 #[serde(rename = "AltrnId", skip_serializing_if = "Option::is_none")]
4892 pub altrn_id: Option<AlternatePartyIdentification5>,
4893 #[serde(rename = "CshAcct", skip_serializing_if = "Option::is_none")]
4894 pub csh_acct: Option<CashAccountIdentification5Choice>,
4895 #[serde(rename = "ChrgsAcct", skip_serializing_if = "Option::is_none")]
4896 pub chrgs_acct: Option<CashAccountIdentification5Choice>,
4897 #[serde(rename = "ComssnAcct", skip_serializing_if = "Option::is_none")]
4898 pub comssn_acct: Option<CashAccountIdentification5Choice>,
4899 #[serde(rename = "TaxAcct", skip_serializing_if = "Option::is_none")]
4900 pub tax_acct: Option<CashAccountIdentification5Choice>,
4901 #[serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none")]
4902 pub addtl_inf: Option<PartyTextInformation2>,
4903}
4904#[derive(
4905 Debug,
4906 Default,
4907 Clone,
4908 PartialEq,
4909 ::serde::Serialize,
4910 ::serde::Deserialize,
4911 ::derive_builder::Builder,
4912 ::validator::Validate,
4913)]
4914pub struct TradeDateCode1ChoiceEnum {
4915 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
4916 pub cd: Option<DateType3Code>,
4917 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
4918 pub prtry: Option<GenericIdentification20>,
4919}
4920#[derive(
4921 Debug,
4922 Default,
4923 Clone,
4924 PartialEq,
4925 ::serde::Serialize,
4926 ::serde::Deserialize,
4927 ::derive_builder::Builder,
4928 ::validator::Validate,
4929)]
4930pub struct TradeDateCode1Choice {
4931 #[serde(flatten)]
4932 pub value: TradeDateCode1ChoiceEnum,
4933}
4934#[derive(
4935 Debug,
4936 Default,
4937 Clone,
4938 PartialEq,
4939 ::serde::Serialize,
4940 ::serde::Deserialize,
4941 ::derive_builder::Builder,
4942 ::validator::Validate,
4943)]
4944pub struct CollateralType1ChoiceEnum {
4945 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
4946 pub prtry: Option<GenericIdentification38>,
4947 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
4948 pub cd: Option<CollateralType3Code>,
4949}
4950#[derive(
4951 Debug,
4952 Default,
4953 Clone,
4954 PartialEq,
4955 ::serde::Serialize,
4956 ::serde::Deserialize,
4957 ::derive_builder::Builder,
4958 ::validator::Validate,
4959)]
4960pub struct CollateralType1Choice {
4961 #[serde(flatten)]
4962 pub value: CollateralType1ChoiceEnum,
4963}
4964#[derive(
4965 Debug,
4966 Default,
4967 Clone,
4968 PartialEq,
4969 ::serde::Serialize,
4970 ::serde::Deserialize,
4971 ::derive_builder::Builder,
4972 ::validator::Validate,
4973)]
4974pub struct PlusOrMinusIndicator {
4975 #[serde(rename = "$text")]
4976 pub value: bool,
4977}
4978#[derive(
4979 Debug,
4980 Default,
4981 Clone,
4982 PartialEq,
4983 ::serde::Serialize,
4984 ::serde::Deserialize,
4985 ::derive_builder::Builder,
4986 ::validator::Validate,
4987)]
4988pub struct TradingPartyCapacity1ChoiceEnum {
4989 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
4990 pub prtry: Option<GenericIdentification38>,
4991 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
4992 pub cd: Option<TradingCapacity4Code>,
4993}
4994#[derive(
4995 Debug,
4996 Default,
4997 Clone,
4998 PartialEq,
4999 ::serde::Serialize,
5000 ::serde::Deserialize,
5001 ::derive_builder::Builder,
5002 ::validator::Validate,
5003)]
5004pub struct TradingPartyCapacity1Choice {
5005 #[serde(flatten)]
5006 pub value: TradingPartyCapacity1ChoiceEnum,
5007}
5008#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
5009pub enum Eligibility1Code {
5010 #[serde(rename = "ELIG")]
5011 Elig,
5012 #[serde(rename = "RETL")]
5013 Retl,
5014 #[serde(rename = "PROF")]
5015 Prof,
5016 #[default]
5017 Unknown,
5018}
5019#[derive(
5020 Debug,
5021 Default,
5022 Clone,
5023 PartialEq,
5024 ::serde::Serialize,
5025 ::serde::Deserialize,
5026 ::derive_builder::Builder,
5027 ::validator::Validate,
5028)]
5029pub struct Linkages15 {
5030 #[serde(rename = "MsgNb", skip_serializing_if = "Option::is_none")]
5031 pub msg_nb: Option<DocumentNumber4Choice>,
5032 #[serde(rename = "Ref")]
5033 pub r#ref: IdentificationReference8Choice,
5034}
5035#[derive(
5036 Debug,
5037 Default,
5038 Clone,
5039 PartialEq,
5040 ::serde::Serialize,
5041 ::serde::Deserialize,
5042 ::derive_builder::Builder,
5043 ::validator::Validate,
5044)]
5045pub struct Iso20022MessageIdentificationText {
5046 #[validate(regex = "ISO_20022_MESSAGE_IDENTIFICATION_TEXT_REGEX")]
5047 #[serde(rename = "$text")]
5048 pub value: String,
5049}
5050#[derive(
5051 Debug,
5052 Default,
5053 Clone,
5054 PartialEq,
5055 ::serde::Serialize,
5056 ::serde::Deserialize,
5057 ::derive_builder::Builder,
5058 ::validator::Validate,
5059)]
5060pub struct AmountAndDirection5 {
5061 #[validate]
5062 #[serde(rename = "Amt")]
5063 pub amt: ActiveCurrencyAndAmount,
5064 #[serde(rename = "CdtDbt", skip_serializing_if = "Option::is_none")]
5065 pub cdt_dbt: Option<CreditDebitCode>,
5066}
5067#[derive(
5068 Debug,
5069 Default,
5070 Clone,
5071 PartialEq,
5072 ::serde::Serialize,
5073 ::serde::Deserialize,
5074 ::derive_builder::Builder,
5075 ::validator::Validate,
5076)]
5077pub struct SecuritiesFinancing10 {
5078 #[serde(rename = "RateChngDt", skip_serializing_if = "Option::is_none")]
5079 pub rate_chng_dt: Option<IsoDateTime>,
5080 #[serde(rename = "RateTp", skip_serializing_if = "Option::is_none")]
5081 pub rate_tp: Option<RateType19Choice>,
5082 #[serde(rename = "Rvaltn", skip_serializing_if = "Option::is_none")]
5083 pub rvaltn: Option<Revaluation2Choice>,
5084 #[serde(rename = "LglFrmwk", skip_serializing_if = "Option::is_none")]
5085 pub lgl_frmwk: Option<LegalFramework1Code>,
5086 #[serde(rename = "IntrstCmptnMtd", skip_serializing_if = "Option::is_none")]
5087 pub intrst_cmptn_mtd: Option<InterestComputationMethod2Choice>,
5088 #[serde(rename = "VarblRateSpprt", skip_serializing_if = "Option::is_none")]
5089 pub varbl_rate_spprt: Option<RateName1>,
5090 #[serde(rename = "RpRate", skip_serializing_if = "Option::is_none")]
5091 pub rp_rate: Option<Rate2>,
5092 #[serde(rename = "StockLnMrgn", skip_serializing_if = "Option::is_none")]
5093 pub stock_ln_mrgn: Option<Rate2>,
5094 #[serde(rename = "SctiesHrcut", skip_serializing_if = "Option::is_none")]
5095 pub scties_hrcut: Option<Rate2>,
5096 #[serde(rename = "PricgRate", skip_serializing_if = "Option::is_none")]
5097 pub pricg_rate: Option<RateOrName1Choice>,
5098 #[serde(rename = "SprdRate", skip_serializing_if = "Option::is_none")]
5099 pub sprd_rate: Option<SpreadRate1>,
5100 #[serde(rename = "CllblTradInd", skip_serializing_if = "Option::is_none")]
5101 pub cllbl_trad_ind: Option<YesNoIndicator>,
5102 #[serde(rename = "TxCallDely", skip_serializing_if = "Option::is_none")]
5103 pub tx_call_dely: Option<Max3NumericText>,
5104 #[serde(rename = "AcrdIntrstAmt", skip_serializing_if = "Option::is_none")]
5105 pub acrd_intrst_amt: Option<AmountAndDirection5>,
5106 #[serde(rename = "AcrdIntrstPctg", skip_serializing_if = "Option::is_none")]
5107 pub acrd_intrst_pctg: Option<PercentageRate>,
5108 #[serde(rename = "FrftAmt", skip_serializing_if = "Option::is_none")]
5109 pub frft_amt: Option<AmountAndDirection5>,
5110 #[serde(rename = "PrmAmt", skip_serializing_if = "Option::is_none")]
5111 pub prm_amt: Option<AmountAndDirection5>,
5112 #[serde(
5113 rename = "ClsgAmtPerPcsOfColl",
5114 skip_serializing_if = "Option::is_none"
5115 )]
5116 pub clsg_amt_per_pcs_of_coll: Option<AmountAndDirection5>,
5117 #[serde(rename = "TtlNbOfCollInstrs", skip_serializing_if = "Option::is_none")]
5118 pub ttl_nb_of_coll_instrs: Option<Max3NumericText>,
5119 #[serde(rename = "FincgAgrmt", skip_serializing_if = "Option::is_none")]
5120 pub fincg_agrmt: Option<Agreement3>,
5121 #[serde(rename = "LndgTxMtd", skip_serializing_if = "Option::is_none")]
5122 pub lndg_tx_mtd: Option<LendingTransactionMethod1Choice>,
5123 #[serde(rename = "LndgWthColl", skip_serializing_if = "Option::is_none")]
5124 pub lndg_wth_coll: Option<YesNoIndicator>,
5125 #[serde(rename = "BrrwgRsn", skip_serializing_if = "Option::is_none")]
5126 pub brrwg_rsn: Option<BorrowingReason1Choice>,
5127 #[serde(rename = "CollTp", skip_serializing_if = "Option::is_none")]
5128 pub coll_tp: Option<CollateralType1Choice>,
5129 #[serde(rename = "CtrctTermsModChngd", skip_serializing_if = "Option::is_none")]
5130 pub ctrct_terms_mod_chngd: Option<YesNoIndicator>,
5131 #[serde(rename = "IntrstRate", skip_serializing_if = "Option::is_none")]
5132 pub intrst_rate: Option<Rate2>,
5133 #[serde(rename = "BrrwgRate", skip_serializing_if = "Option::is_none")]
5134 pub brrwg_rate: Option<Rate2>,
5135 #[serde(rename = "StdCollRatio", skip_serializing_if = "Option::is_none")]
5136 pub std_coll_ratio: Option<Rate2>,
5137 #[serde(rename = "DvddRatio", skip_serializing_if = "Option::is_none")]
5138 pub dvdd_ratio: Option<Rate2>,
5139 #[serde(rename = "NbOfDaysLndgBrrwg", skip_serializing_if = "Option::is_none")]
5140 pub nb_of_days_lndg_brrwg: Option<Number21Choice>,
5141 #[serde(rename = "StdCollAmt", skip_serializing_if = "Option::is_none")]
5142 pub std_coll_amt: Option<AmountAndDirection5>,
5143 #[serde(rename = "AcrdIntrstTax", skip_serializing_if = "Option::is_none")]
5144 pub acrd_intrst_tax: Option<YesNoIndicator>,
5145 #[serde(rename = "EndNbOfDaysAcrd", skip_serializing_if = "Option::is_none")]
5146 pub end_nb_of_days_acrd: Option<Max3Number>,
5147 #[serde(rename = "EndFctr", skip_serializing_if = "Option::is_none")]
5148 pub end_fctr: Option<BaseOneRate>,
5149 #[serde(rename = "SctiesLndgTp", skip_serializing_if = "Option::is_none")]
5150 pub scties_lndg_tp: Option<SecuritiesLendingType1Choice>,
5151 #[serde(rename = "Rvsbl", skip_serializing_if = "Option::is_none")]
5152 pub rvsbl: Option<Reversible1Choice>,
5153 #[serde(rename = "MinDtForCallBck", skip_serializing_if = "Option::is_none")]
5154 pub min_dt_for_call_bck: Option<IsoDate>,
5155 #[serde(rename = "RollOver", skip_serializing_if = "Option::is_none")]
5156 pub roll_over: Option<YesNoIndicator>,
5157 #[serde(rename = "PrdcPmt", skip_serializing_if = "Option::is_none")]
5158 pub prdc_pmt: Option<YesNoIndicator>,
5159 #[serde(rename = "ExCpn", skip_serializing_if = "Option::is_none")]
5160 pub ex_cpn: Option<YesNoIndicator>,
5161}
5162#[derive(
5163 Debug,
5164 Default,
5165 Clone,
5166 PartialEq,
5167 ::serde::Serialize,
5168 ::serde::Deserialize,
5169 ::derive_builder::Builder,
5170 ::validator::Validate,
5171)]
5172pub struct ConfirmationParties2 {
5173 #[serde(rename = "Buyr", skip_serializing_if = "Option::is_none")]
5174 pub buyr: Option<ConfirmationPartyDetails2>,
5175 #[serde(rename = "Brrwr", skip_serializing_if = "Option::is_none")]
5176 pub brrwr: Option<ConfirmationPartyDetails2>,
5177 #[serde(rename = "Sellr", skip_serializing_if = "Option::is_none")]
5178 pub sellr: Option<ConfirmationPartyDetails2>,
5179 #[serde(rename = "Lndr", skip_serializing_if = "Option::is_none")]
5180 pub lndr: Option<ConfirmationPartyDetails2>,
5181 #[serde(rename = "BrkrOfCdt", skip_serializing_if = "Option::is_none")]
5182 pub brkr_of_cdt: Option<ConfirmationPartyDetails1>,
5183 #[serde(rename = "IntrdcgFirm", skip_serializing_if = "Option::is_none")]
5184 pub intrdcg_firm: Option<ConfirmationPartyDetails1>,
5185 #[serde(rename = "StepInFirm", skip_serializing_if = "Option::is_none")]
5186 pub step_in_firm: Option<ConfirmationPartyDetails1>,
5187 #[serde(rename = "StepOutFirm", skip_serializing_if = "Option::is_none")]
5188 pub step_out_firm: Option<ConfirmationPartyDetails1>,
5189 #[serde(rename = "ClrFirm", skip_serializing_if = "Option::is_none")]
5190 pub clr_firm: Option<ConfirmationPartyDetails5>,
5191 #[serde(rename = "ExctgBrkr", skip_serializing_if = "Option::is_none")]
5192 pub exctg_brkr: Option<ConfirmationPartyDetails5>,
5193 #[serde(rename = "CMUPty", skip_serializing_if = "Option::is_none")]
5194 pub cmu_pty: Option<ConfirmationPartyDetails1>,
5195 #[serde(rename = "CMUCtrPty", skip_serializing_if = "Option::is_none")]
5196 pub cmu_ctr_pty: Option<ConfirmationPartyDetails1>,
5197 #[serde(rename = "AffrmgPty", skip_serializing_if = "Option::is_none")]
5198 pub affrmg_pty: Option<ConfirmationPartyDetails1>,
5199 #[serde(rename = "TradBnfcryPty", skip_serializing_if = "Option::is_none")]
5200 pub trad_bnfcry_pty: Option<ConfirmationPartyDetails3>,
5201}
5202#[derive(
5203 Debug,
5204 Default,
5205 Clone,
5206 PartialEq,
5207 ::serde::Serialize,
5208 ::serde::Deserialize,
5209 ::derive_builder::Builder,
5210 ::validator::Validate,
5211)]
5212pub struct PartyIdentification54 {
5213 #[validate]
5214 #[serde(rename = "BIC")]
5215 pub bic: AnyBicIdentifier,
5216 #[validate]
5217 #[serde(rename = "PrtryId")]
5218 pub prtry_id: GenericIdentification29,
5219 #[serde(rename = "NmAndAdr", skip_serializing_if = "Option::is_none")]
5220 pub nm_and_adr: Option<NameAndAddress13>,
5221}
5222#[derive(
5223 Debug,
5224 Default,
5225 Clone,
5226 PartialEq,
5227 ::serde::Serialize,
5228 ::serde::Deserialize,
5229 ::derive_builder::Builder,
5230 ::validator::Validate,
5231)]
5232pub struct SettlementParties23 {
5233 #[serde(rename = "Dpstry", skip_serializing_if = "Option::is_none")]
5234 pub dpstry: Option<PartyIdentification55>,
5235 #[serde(rename = "Pty1", skip_serializing_if = "Option::is_none")]
5236 pub pty_1: Option<PartyIdentificationAndAccount34>,
5237 #[serde(rename = "Pty2", skip_serializing_if = "Option::is_none")]
5238 pub pty_2: Option<PartyIdentificationAndAccount34>,
5239 #[serde(rename = "Pty3", skip_serializing_if = "Option::is_none")]
5240 pub pty_3: Option<PartyIdentificationAndAccount34>,
5241 #[serde(rename = "Pty4", skip_serializing_if = "Option::is_none")]
5242 pub pty_4: Option<PartyIdentificationAndAccount34>,
5243 #[serde(rename = "Pty5", skip_serializing_if = "Option::is_none")]
5244 pub pty_5: Option<PartyIdentificationAndAccount34>,
5245}
5246#[derive(
5247 Debug,
5248 Default,
5249 Clone,
5250 PartialEq,
5251 ::serde::Serialize,
5252 ::serde::Deserialize,
5253 ::derive_builder::Builder,
5254 ::validator::Validate,
5255)]
5256pub struct AlternatePartyIdentification6 {
5257 #[serde(rename = "TpOfId")]
5258 pub tp_of_id: IdentificationType41Choice,
5259 #[serde(rename = "Ctry")]
5260 pub ctry: CountryCode,
5261 #[validate]
5262 #[serde(rename = "AltrnId")]
5263 pub altrn_id: Max35Text,
5264}
5265#[derive(
5266 Debug,
5267 Default,
5268 Clone,
5269 PartialEq,
5270 ::serde::Serialize,
5271 ::serde::Deserialize,
5272 ::derive_builder::Builder,
5273 ::validator::Validate,
5274)]
5275pub struct Max8Text {
5276 #[validate(length(min = 1, max = 8,))]
5277 #[serde(rename = "$text")]
5278 pub value: String,
5279}
5280#[derive(
5281 Debug,
5282 Default,
5283 Clone,
5284 PartialEq,
5285 ::serde::Serialize,
5286 ::serde::Deserialize,
5287 ::derive_builder::Builder,
5288 ::validator::Validate,
5289)]
5290pub struct Revaluation2ChoiceEnum {
5291 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
5292 pub prtry: Option<GenericIdentification38>,
5293 #[serde(rename = "Ind", skip_serializing_if = "Option::is_none")]
5294 pub ind: Option<YesNoIndicator>,
5295}
5296#[derive(
5297 Debug,
5298 Default,
5299 Clone,
5300 PartialEq,
5301 ::serde::Serialize,
5302 ::serde::Deserialize,
5303 ::derive_builder::Builder,
5304 ::validator::Validate,
5305)]
5306pub struct Revaluation2Choice {
5307 #[serde(flatten)]
5308 pub value: Revaluation2ChoiceEnum,
5309}
5310#[derive(
5311 Debug,
5312 Default,
5313 Clone,
5314 PartialEq,
5315 ::serde::Serialize,
5316 ::serde::Deserialize,
5317 ::derive_builder::Builder,
5318 ::validator::Validate,
5319)]
5320pub struct SettlementSystemMethod3ChoiceEnum {
5321 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
5322 pub cd: Option<SettlementSystemMethod1Code>,
5323 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
5324 pub prtry: Option<GenericIdentification38>,
5325}
5326#[derive(
5327 Debug,
5328 Default,
5329 Clone,
5330 PartialEq,
5331 ::serde::Serialize,
5332 ::serde::Deserialize,
5333 ::derive_builder::Builder,
5334 ::validator::Validate,
5335)]
5336pub struct SettlementSystemMethod3Choice {
5337 #[serde(flatten)]
5338 pub value: SettlementSystemMethod3ChoiceEnum,
5339}
5340#[derive(
5341 Debug,
5342 Default,
5343 Clone,
5344 PartialEq,
5345 ::serde::Serialize,
5346 ::serde::Deserialize,
5347 ::derive_builder::Builder,
5348 ::validator::Validate,
5349)]
5350pub struct TradingDateCode1ChoiceEnum {
5351 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
5352 pub prtry: Option<GenericIdentification38>,
5353 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
5354 pub cd: Option<TradingDate1Code>,
5355}
5356#[derive(
5357 Debug,
5358 Default,
5359 Clone,
5360 PartialEq,
5361 ::serde::Serialize,
5362 ::serde::Deserialize,
5363 ::derive_builder::Builder,
5364 ::validator::Validate,
5365)]
5366pub struct TradingDateCode1Choice {
5367 #[serde(flatten)]
5368 pub value: TradingDateCode1ChoiceEnum,
5369}
5370#[derive(
5371 Debug,
5372 Default,
5373 Clone,
5374 PartialEq,
5375 ::serde::Serialize,
5376 ::serde::Deserialize,
5377 ::derive_builder::Builder,
5378 ::validator::Validate,
5379)]
5380pub struct CashAccountIdentification5ChoiceEnum {
5381 #[serde(rename = "IBAN", skip_serializing_if = "Option::is_none")]
5382 pub iban: Option<Iban2007Identifier>,
5383 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
5384 pub prtry: Option<Max34Text>,
5385}
5386#[derive(
5387 Debug,
5388 Default,
5389 Clone,
5390 PartialEq,
5391 ::serde::Serialize,
5392 ::serde::Deserialize,
5393 ::derive_builder::Builder,
5394 ::validator::Validate,
5395)]
5396pub struct CashAccountIdentification5Choice {
5397 #[serde(flatten)]
5398 pub value: CashAccountIdentification5ChoiceEnum,
5399}
5400#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
5401pub enum CommissionType9Code {
5402 #[serde(rename = "CLDI")]
5403 Cldi,
5404 #[serde(rename = "STEP")]
5405 Step,
5406 #[serde(rename = "SOFT")]
5407 Soft,
5408 #[serde(rename = "PERN")]
5409 Pern,
5410 #[serde(rename = "FLAT")]
5411 Flat,
5412 #[serde(rename = "PERU")]
5413 Peru,
5414 #[serde(rename = "PWCD")]
5415 Pwcd,
5416 #[serde(rename = "PWEU")]
5417 Pweu,
5418 #[serde(rename = "BRKR")]
5419 Brkr,
5420 #[serde(rename = "DFDP")]
5421 Dfdp,
5422 #[serde(rename = "PBOC")]
5423 Pboc,
5424 #[default]
5425 Unknown,
5426}
5427#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
5428pub enum DeliveryType2Code {
5429 #[serde(rename = "APMT")]
5430 Apmt,
5431 #[serde(rename = "FREE")]
5432 Free,
5433 #[serde(rename = "TRIP")]
5434 Trip,
5435 #[serde(rename = "HOIC")]
5436 Hoic,
5437 #[default]
5438 Unknown,
5439}
5440#[derive(
5441 Debug,
5442 Default,
5443 Clone,
5444 PartialEq,
5445 ::serde::Serialize,
5446 ::serde::Deserialize,
5447 ::derive_builder::Builder,
5448 ::validator::Validate,
5449)]
5450pub struct GenericIdentification38 {
5451 #[validate]
5452 #[serde(rename = "Id")]
5453 pub id: Exact4AlphaNumericText,
5454 #[validate]
5455 #[serde(rename = "Issr")]
5456 pub issr: Max35Text,
5457 #[serde(rename = "SchmeNm", skip_serializing_if = "Option::is_none")]
5458 pub schme_nm: Option<Max35Text>,
5459}
5460#[derive(
5461 Debug,
5462 Default,
5463 Clone,
5464 PartialEq,
5465 ::serde::Serialize,
5466 ::serde::Deserialize,
5467 ::derive_builder::Builder,
5468 ::validator::Validate,
5469)]
5470pub struct ActiveOrHistoricCurrencyAnd13DecimalAmount {
5471 #[serde(rename = "ActiveOrHistoricCurrencyAnd13DecimalAmount")]
5472 pub value: ActiveOrHistoricCurrencyAnd13DecimalAmountSimpleType,
5473 #[serde(rename = "@Ccy")]
5474 pub ccy: ActiveOrHistoricCurrencyCode,
5475}
5476#[derive(
5477 Debug,
5478 Default,
5479 Clone,
5480 PartialEq,
5481 ::serde::Serialize,
5482 ::serde::Deserialize,
5483 ::derive_builder::Builder,
5484 ::validator::Validate,
5485)]
5486pub struct SettlementTransactionCondition11ChoiceEnum {
5487 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
5488 pub cd: Option<SettlementTransactionCondition7Code>,
5489 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
5490 pub prtry: Option<GenericIdentification38>,
5491}
5492#[derive(
5493 Debug,
5494 Default,
5495 Clone,
5496 PartialEq,
5497 ::serde::Serialize,
5498 ::serde::Deserialize,
5499 ::derive_builder::Builder,
5500 ::validator::Validate,
5501)]
5502pub struct SettlementTransactionCondition11Choice {
5503 #[serde(flatten)]
5504 pub value: SettlementTransactionCondition11ChoiceEnum,
5505}
5506#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
5507pub enum CreditDebitCode {
5508 #[serde(rename = "CRDT")]
5509 Crdt,
5510 #[serde(rename = "DBIT")]
5511 Dbit,
5512 #[default]
5513 Unknown,
5514}
5515#[derive(
5516 Debug,
5517 Default,
5518 Clone,
5519 PartialEq,
5520 ::serde::Serialize,
5521 ::serde::Deserialize,
5522 ::derive_builder::Builder,
5523 ::validator::Validate,
5524)]
5525pub struct BlockTrade3ChoiceEnum {
5526 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
5527 pub cd: Option<BlockTrade1Code>,
5528 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
5529 pub prtry: Option<GenericIdentification38>,
5530}
5531#[derive(
5532 Debug,
5533 Default,
5534 Clone,
5535 PartialEq,
5536 ::serde::Serialize,
5537 ::serde::Deserialize,
5538 ::derive_builder::Builder,
5539 ::validator::Validate,
5540)]
5541pub struct BlockTrade3Choice {
5542 #[serde(flatten)]
5543 pub value: BlockTrade3ChoiceEnum,
5544}
5545#[derive(
5546 Debug,
5547 Default,
5548 Clone,
5549 PartialEq,
5550 ::serde::Serialize,
5551 ::serde::Deserialize,
5552 ::derive_builder::Builder,
5553 ::validator::Validate,
5554)]
5555pub struct CentralCounterPartyEligibility3ChoiceEnum {
5556 #[serde(rename = "Ind", skip_serializing_if = "Option::is_none")]
5557 pub ind: Option<YesNoIndicator>,
5558 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
5559 pub prtry: Option<GenericIdentification38>,
5560}
5561#[derive(
5562 Debug,
5563 Default,
5564 Clone,
5565 PartialEq,
5566 ::serde::Serialize,
5567 ::serde::Deserialize,
5568 ::derive_builder::Builder,
5569 ::validator::Validate,
5570)]
5571pub struct CentralCounterPartyEligibility3Choice {
5572 #[serde(flatten)]
5573 pub value: CentralCounterPartyEligibility3ChoiceEnum,
5574}
5575#[derive(
5576 Debug,
5577 Default,
5578 Clone,
5579 PartialEq,
5580 ::serde::Serialize,
5581 ::serde::Deserialize,
5582 ::derive_builder::Builder,
5583 ::validator::Validate,
5584)]
5585pub struct IsoYearMonth {
5586 #[validate(regex = "ISO_YEAR_MONTH_REGEX")]
5587 #[serde(rename = "$text")]
5588 pub value: String,
5589}
5590#[derive(
5591 Debug,
5592 Default,
5593 Clone,
5594 PartialEq,
5595 ::serde::Serialize,
5596 ::serde::Deserialize,
5597 ::derive_builder::Builder,
5598 ::validator::Validate,
5599)]
5600pub struct PartyIdentificationAndAccount34 {
5601 #[serde(rename = "Id")]
5602 pub id: PartyIdentification32Choice,
5603 #[serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none")]
5604 pub addtl_inf: Option<Max350Text>,
5605 #[serde(rename = "AltrnId", skip_serializing_if = "Option::is_none")]
5606 pub altrn_id: Option<AlternatePartyIdentification5>,
5607 #[serde(rename = "SfkpgAcct", skip_serializing_if = "Option::is_none")]
5608 pub sfkpg_acct: Option<Max35Text>,
5609}
5610#[derive(
5611 Debug,
5612 Default,
5613 Clone,
5614 PartialEq,
5615 ::serde::Serialize,
5616 ::serde::Deserialize,
5617 ::derive_builder::Builder,
5618 ::validator::Validate,
5619)]
5620pub struct QuantityBreakdown11 {
5621 #[serde(rename = "LotNb", skip_serializing_if = "Option::is_none")]
5622 pub lot_nb: Option<GenericIdentification37>,
5623 #[serde(rename = "LotQty", skip_serializing_if = "Option::is_none")]
5624 pub lot_qty: Option<FinancialInstrumentQuantity1Choice>,
5625 #[serde(rename = "LotDtTm", skip_serializing_if = "Option::is_none")]
5626 pub lot_dt_tm: Option<DateAndDateTime1Choice>,
5627 #[serde(rename = "LotPric", skip_serializing_if = "Option::is_none")]
5628 pub lot_pric: Option<Price4>,
5629}
5630#[derive(
5631 Debug,
5632 Default,
5633 Clone,
5634 PartialEq,
5635 ::serde::Serialize,
5636 ::serde::Deserialize,
5637 ::derive_builder::Builder,
5638 ::validator::Validate,
5639)]
5640pub struct TradeTransactionCondition4ChoiceEnum {
5641 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
5642 pub cd: Option<ExternalTradeTransactionCondition1Code>,
5643 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
5644 pub prtry: Option<GenericIdentification38>,
5645}
5646#[derive(
5647 Debug,
5648 Default,
5649 Clone,
5650 PartialEq,
5651 ::serde::Serialize,
5652 ::serde::Deserialize,
5653 ::derive_builder::Builder,
5654 ::validator::Validate,
5655)]
5656pub struct TradeTransactionCondition4Choice {
5657 #[serde(flatten)]
5658 pub value: TradeTransactionCondition4ChoiceEnum,
5659}
5660#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
5661pub enum TradingDate1Code {
5662 #[serde(rename = "VARI")]
5663 Vari,
5664 #[default]
5665 Unknown,
5666}
5667#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
5668pub enum TypeOfPrice3Code {
5669 #[serde(rename = "AVER")]
5670 Aver,
5671 #[serde(rename = "AVOV")]
5672 Avov,
5673 #[serde(rename = "GREX")]
5674 Grex,
5675 #[serde(rename = "NET2")]
5676 Net2,
5677 #[serde(rename = "NET1")]
5678 Net1,
5679 #[serde(rename = "PARV")]
5680 Parv,
5681 #[serde(rename = "RDAV")]
5682 Rdav,
5683 #[default]
5684 Unknown,
5685}
5686#[derive(
5687 Debug,
5688 Default,
5689 Clone,
5690 PartialEq,
5691 ::serde::Serialize,
5692 ::serde::Deserialize,
5693 ::derive_builder::Builder,
5694 ::validator::Validate,
5695)]
5696pub struct SettlementInstructionGeneration1ChoiceEnum {
5697 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
5698 pub prtry: Option<GenericIdentification38>,
5699 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
5700 pub cd: Option<SettlementInstructionGeneration1Code>,
5701}
5702#[derive(
5703 Debug,
5704 Default,
5705 Clone,
5706 PartialEq,
5707 ::serde::Serialize,
5708 ::serde::Deserialize,
5709 ::derive_builder::Builder,
5710 ::validator::Validate,
5711)]
5712pub struct SettlementInstructionGeneration1Choice {
5713 #[serde(flatten)]
5714 pub value: SettlementInstructionGeneration1ChoiceEnum,
5715}
5716#[derive(
5717 Debug,
5718 Default,
5719 Clone,
5720 PartialEq,
5721 ::serde::Serialize,
5722 ::serde::Deserialize,
5723 ::derive_builder::Builder,
5724 ::validator::Validate,
5725)]
5726pub struct PriorityNumeric3ChoiceEnum {
5727 #[serde(rename = "Nmrc", skip_serializing_if = "Option::is_none")]
5728 pub nmrc: Option<Exact4NumericText>,
5729 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
5730 pub prtry: Option<GenericIdentification38>,
5731}
5732#[derive(
5733 Debug,
5734 Default,
5735 Clone,
5736 PartialEq,
5737 ::serde::Serialize,
5738 ::serde::Deserialize,
5739 ::derive_builder::Builder,
5740 ::validator::Validate,
5741)]
5742pub struct PriorityNumeric3Choice {
5743 #[serde(flatten)]
5744 pub value: PriorityNumeric3ChoiceEnum,
5745}
5746#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
5747pub enum MatchingStatus1Code {
5748 #[serde(rename = "MACH")]
5749 Mach,
5750 #[serde(rename = "NMAT")]
5751 Nmat,
5752 #[default]
5753 Unknown,
5754}
5755#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
5756pub enum PositionEffect2Code {
5757 #[serde(rename = "OPEN")]
5758 Open,
5759 #[serde(rename = "CLOS")]
5760 Clos,
5761 #[serde(rename = "ROLL")]
5762 Roll,
5763 #[serde(rename = "FIFO")]
5764 Fifo,
5765 #[serde(rename = "CLOA")]
5766 Cloa,
5767 #[default]
5768 Unknown,
5769}
5770#[derive(
5771 Debug,
5772 Default,
5773 Clone,
5774 PartialEq,
5775 ::serde::Serialize,
5776 ::serde::Deserialize,
5777 ::derive_builder::Builder,
5778 ::validator::Validate,
5779)]
5780pub struct OtherAmounts16 {
5781 #[serde(rename = "ChrgsFees", skip_serializing_if = "Option::is_none")]
5782 pub chrgs_fees: Option<AmountAndDirection29>,
5783 #[serde(rename = "CtryNtlFdrlTax", skip_serializing_if = "Option::is_none")]
5784 pub ctry_ntl_fdrl_tax: Option<AmountAndDirection29>,
5785 #[serde(rename = "ExctgBrkrAmt", skip_serializing_if = "Option::is_none")]
5786 pub exctg_brkr_amt: Option<AmountAndDirection29>,
5787 #[serde(rename = "IsseDscntAllwnc", skip_serializing_if = "Option::is_none")]
5788 pub isse_dscnt_allwnc: Option<AmountAndDirection29>,
5789 #[serde(rename = "PmtLevyTax", skip_serializing_if = "Option::is_none")]
5790 pub pmt_levy_tax: Option<AmountAndDirection29>,
5791 #[serde(rename = "LclTax", skip_serializing_if = "Option::is_none")]
5792 pub lcl_tax: Option<AmountAndDirection29>,
5793 #[serde(rename = "LclBrkrComssn", skip_serializing_if = "Option::is_none")]
5794 pub lcl_brkr_comssn: Option<AmountAndDirection29>,
5795 #[serde(rename = "Mrgn", skip_serializing_if = "Option::is_none")]
5796 pub mrgn: Option<AmountAndDirection29>,
5797 #[serde(rename = "Othr", skip_serializing_if = "Option::is_none")]
5798 pub othr: Option<AmountAndDirection29>,
5799 #[serde(rename = "RgltryAmt", skip_serializing_if = "Option::is_none")]
5800 pub rgltry_amt: Option<AmountAndDirection29>,
5801 #[serde(rename = "SpclCncssn", skip_serializing_if = "Option::is_none")]
5802 pub spcl_cncssn: Option<AmountAndDirection29>,
5803 #[serde(rename = "StmpDty", skip_serializing_if = "Option::is_none")]
5804 pub stmp_dty: Option<AmountAndDirection29>,
5805 #[serde(rename = "StockXchgTax", skip_serializing_if = "Option::is_none")]
5806 pub stock_xchg_tax: Option<AmountAndDirection29>,
5807 #[serde(rename = "TrfTax", skip_serializing_if = "Option::is_none")]
5808 pub trf_tax: Option<AmountAndDirection29>,
5809 #[serde(rename = "TxTax", skip_serializing_if = "Option::is_none")]
5810 pub tx_tax: Option<AmountAndDirection29>,
5811 #[serde(rename = "ValAddedTax", skip_serializing_if = "Option::is_none")]
5812 pub val_added_tax: Option<AmountAndDirection29>,
5813 #[serde(rename = "WhldgTax", skip_serializing_if = "Option::is_none")]
5814 pub whldg_tax: Option<AmountAndDirection29>,
5815 #[serde(rename = "NetGnLoss", skip_serializing_if = "Option::is_none")]
5816 pub net_gn_loss: Option<AmountAndDirection29>,
5817 #[serde(rename = "CsmptnTax", skip_serializing_if = "Option::is_none")]
5818 pub csmptn_tax: Option<AmountAndDirection29>,
5819 #[serde(rename = "MtchgConfFee", skip_serializing_if = "Option::is_none")]
5820 pub mtchg_conf_fee: Option<AmountAndDirection29>,
5821 #[serde(rename = "ConvtdAmt", skip_serializing_if = "Option::is_none")]
5822 pub convtd_amt: Option<AmountAndDirection29>,
5823 #[serde(rename = "OrgnlCcyAmt", skip_serializing_if = "Option::is_none")]
5824 pub orgnl_ccy_amt: Option<AmountAndDirection29>,
5825 #[serde(rename = "BookVal", skip_serializing_if = "Option::is_none")]
5826 pub book_val: Option<AmountAndDirection29>,
5827 #[serde(rename = "AcrdCptlstnAmt", skip_serializing_if = "Option::is_none")]
5828 pub acrd_cptlstn_amt: Option<AmountAndDirection29>,
5829 #[serde(rename = "LclTaxCtrySpcfc1", skip_serializing_if = "Option::is_none")]
5830 pub lcl_tax_ctry_spcfc_1: Option<AmountAndDirection29>,
5831 #[serde(rename = "LclTaxCtrySpcfc2", skip_serializing_if = "Option::is_none")]
5832 pub lcl_tax_ctry_spcfc_2: Option<AmountAndDirection29>,
5833 #[serde(rename = "LclTaxCtrySpcfc3", skip_serializing_if = "Option::is_none")]
5834 pub lcl_tax_ctry_spcfc_3: Option<AmountAndDirection29>,
5835 #[serde(rename = "LclTaxCtrySpcfc4", skip_serializing_if = "Option::is_none")]
5836 pub lcl_tax_ctry_spcfc_4: Option<AmountAndDirection29>,
5837 #[serde(rename = "ShrdBrkrgAmt", skip_serializing_if = "Option::is_none")]
5838 pub shrd_brkrg_amt: Option<AmountAndDirection29>,
5839 #[serde(rename = "MktMmbFeeAmt", skip_serializing_if = "Option::is_none")]
5840 pub mkt_mmb_fee_amt: Option<AmountAndDirection29>,
5841 #[serde(rename = "RmnrtnAmtReq", skip_serializing_if = "Option::is_none")]
5842 pub rmnrtn_amt_req: Option<YesNoIndicator>,
5843 #[serde(rename = "RmnrtnAmt", skip_serializing_if = "Option::is_none")]
5844 pub rmnrtn_amt: Option<AmountAndDirection29>,
5845 #[serde(rename = "BrrwgIntrstAmt", skip_serializing_if = "Option::is_none")]
5846 pub brrwg_intrst_amt: Option<AmountAndDirection29>,
5847 #[serde(rename = "BrrwgFee", skip_serializing_if = "Option::is_none")]
5848 pub brrwg_fee: Option<AmountAndDirection29>,
5849 #[serde(rename = "NetMktVal", skip_serializing_if = "Option::is_none")]
5850 pub net_mkt_val: Option<AmountAndDirection29>,
5851 #[serde(rename = "RmngFaceVal", skip_serializing_if = "Option::is_none")]
5852 pub rmng_face_val: Option<AmountAndDirection29>,
5853 #[serde(rename = "RmngBookVal", skip_serializing_if = "Option::is_none")]
5854 pub rmng_book_val: Option<AmountAndDirection29>,
5855 #[serde(rename = "ClrBrkrComssn", skip_serializing_if = "Option::is_none")]
5856 pub clr_brkr_comssn: Option<AmountAndDirection29>,
5857 #[serde(rename = "DiffInPric", skip_serializing_if = "Option::is_none")]
5858 pub diff_in_pric: Option<AmountAndDirection29>,
5859 #[serde(rename = "OddLotFee", skip_serializing_if = "Option::is_none")]
5860 pub odd_lot_fee: Option<YesNoIndicator>,
5861}
5862#[derive(
5863 Debug,
5864 Default,
5865 Clone,
5866 PartialEq,
5867 ::serde::Serialize,
5868 ::serde::Deserialize,
5869 ::derive_builder::Builder,
5870 ::validator::Validate,
5871)]
5872pub struct Frequency7ChoiceEnum {
5873 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
5874 pub prtry: Option<GenericIdentification38>,
5875 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
5876 pub cd: Option<EventFrequency3Code>,
5877}
5878#[derive(
5879 Debug,
5880 Default,
5881 Clone,
5882 PartialEq,
5883 ::serde::Serialize,
5884 ::serde::Deserialize,
5885 ::derive_builder::Builder,
5886 ::validator::Validate,
5887)]
5888pub struct Frequency7Choice {
5889 #[serde(flatten)]
5890 pub value: Frequency7ChoiceEnum,
5891}
5892#[derive(
5893 Debug,
5894 Default,
5895 Clone,
5896 PartialEq,
5897 ::serde::Serialize,
5898 ::serde::Deserialize,
5899 ::derive_builder::Builder,
5900 ::validator::Validate,
5901)]
5902pub struct PartyIdentificationAndAccount83 {
5903 #[serde(rename = "Id")]
5904 pub id: PartyIdentification70Choice,
5905 #[serde(rename = "SfkpgAcct", skip_serializing_if = "Option::is_none")]
5906 pub sfkpg_acct: Option<Max35Text>,
5907 #[serde(rename = "CshAcct", skip_serializing_if = "Option::is_none")]
5908 pub csh_acct: Option<CashAccountIdentification2Choice>,
5909 #[serde(rename = "PrcgId", skip_serializing_if = "Option::is_none")]
5910 pub prcg_id: Option<Max35Text>,
5911 #[serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none")]
5912 pub addtl_inf: Option<PartyTextInformation1>,
5913 #[serde(rename = "AltrnId", skip_serializing_if = "Option::is_none")]
5914 pub altrn_id: Option<AlternatePartyIdentification6>,
5915}
5916#[derive(
5917 Debug,
5918 Default,
5919 Clone,
5920 PartialEq,
5921 ::serde::Serialize,
5922 ::serde::Deserialize,
5923 ::derive_builder::Builder,
5924 ::validator::Validate,
5925)]
5926pub struct Commission16 {
5927 #[serde(rename = "Tp")]
5928 pub tp: CommissionType2Choice,
5929 #[serde(rename = "Comssn")]
5930 pub comssn: AmountOrRate2Choice,
5931 #[serde(rename = "RcptId", skip_serializing_if = "Option::is_none")]
5932 pub rcpt_id: Option<PartyIdentification54>,
5933 #[serde(rename = "ClctnDt", skip_serializing_if = "Option::is_none")]
5934 pub clctn_dt: Option<IsoDate>,
5935 #[serde(rename = "TtlComssn", skip_serializing_if = "Option::is_none")]
5936 pub ttl_comssn: Option<AmountAndDirection29>,
5937 #[serde(rename = "TtlVATAmt", skip_serializing_if = "Option::is_none")]
5938 pub ttl_vat_amt: Option<ActiveCurrencyAndAmount>,
5939 #[serde(rename = "VATRate", skip_serializing_if = "Option::is_none")]
5940 pub vat_rate: Option<BaseOneRate>,
5941}
5942#[derive(
5943 Debug,
5944 Default,
5945 Clone,
5946 PartialEq,
5947 ::serde::Serialize,
5948 ::serde::Deserialize,
5949 ::derive_builder::Builder,
5950 ::validator::Validate,
5951)]
5952pub struct InvestorCapacity3ChoiceEnum {
5953 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
5954 pub cd: Option<Eligibility1Code>,
5955 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
5956 pub prtry: Option<GenericIdentification38>,
5957}
5958#[derive(
5959 Debug,
5960 Default,
5961 Clone,
5962 PartialEq,
5963 ::serde::Serialize,
5964 ::serde::Deserialize,
5965 ::derive_builder::Builder,
5966 ::validator::Validate,
5967)]
5968pub struct InvestorCapacity3Choice {
5969 #[serde(flatten)]
5970 pub value: InvestorCapacity3ChoiceEnum,
5971}
5972#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
5973pub enum BusinessProcessType1Code {
5974 #[serde(rename = "ISUP")]
5975 Isup,
5976 #[serde(rename = "NISP")]
5977 Nisp,
5978 #[serde(rename = "PRAC")]
5979 Prac,
5980 #[serde(rename = "RSAL")]
5981 Rsal,
5982 #[serde(rename = "PROP")]
5983 Prop,
5984 #[serde(rename = "THRU")]
5985 Thru,
5986 #[serde(rename = "IDEL")]
5987 Idel,
5988 #[serde(rename = "DPLX")]
5989 Dplx,
5990 #[default]
5991 Unknown,
5992}
5993#[derive(
5994 Debug,
5995 Default,
5996 Clone,
5997 PartialEq,
5998 ::serde::Serialize,
5999 ::serde::Deserialize,
6000 ::derive_builder::Builder,
6001 ::validator::Validate,
6002)]
6003pub struct OtherParties18 {
6004 #[validate(length(min = 0,))]
6005 #[serde(rename = "Invstr", default)]
6006 pub invstr: Vec<PartyIdentificationAndAccount79>,
6007 #[serde(rename = "StockXchg", skip_serializing_if = "Option::is_none")]
6008 pub stock_xchg: Option<PartyIdentificationAndAccount87>,
6009 #[serde(rename = "TradRgltr", skip_serializing_if = "Option::is_none")]
6010 pub trad_rgltr: Option<PartyIdentificationAndAccount87>,
6011 #[serde(rename = "TrptyAgt", skip_serializing_if = "Option::is_none")]
6012 pub trpty_agt: Option<PartyIdentificationAndAccount83>,
6013 #[serde(rename = "QlfdFrgnIntrmy", skip_serializing_if = "Option::is_none")]
6014 pub qlfd_frgn_intrmy: Option<PartyIdentificationAndAccount77>,
6015}
6016#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
6017pub enum OptionRight1Code {
6018 #[serde(rename = "EXER")]
6019 Exer,
6020 #[serde(rename = "ASGN")]
6021 Asgn,
6022 #[serde(rename = "RENO")]
6023 Reno,
6024 #[serde(rename = "EXPI")]
6025 Expi,
6026 #[default]
6027 Unknown,
6028}
6029#[derive(
6030 Debug,
6031 Default,
6032 Clone,
6033 PartialEq,
6034 ::serde::Serialize,
6035 ::serde::Deserialize,
6036 ::derive_builder::Builder,
6037 ::validator::Validate,
6038)]
6039pub struct StandingSettlementInstruction9 {
6040 #[serde(rename = "SttlmStgInstrDB")]
6041 pub sttlm_stg_instr_db: SettlementStandingInstructionDatabase3Choice,
6042 #[serde(rename = "Vndr", skip_serializing_if = "Option::is_none")]
6043 pub vndr: Option<PartyIdentification32Choice>,
6044 #[serde(
6045 rename = "OthrDlvrgSttlmPties",
6046 skip_serializing_if = "Option::is_none"
6047 )]
6048 pub othr_dlvrg_sttlm_pties: Option<SettlementParties23>,
6049 #[serde(rename = "OthrRcvgSttlmPties", skip_serializing_if = "Option::is_none")]
6050 pub othr_rcvg_sttlm_pties: Option<SettlementParties23>,
6051}
6052#[derive(
6053 Debug,
6054 Default,
6055 Clone,
6056 PartialEq,
6057 ::serde::Serialize,
6058 ::serde::Deserialize,
6059 ::derive_builder::Builder,
6060 ::validator::Validate,
6061)]
6062pub struct Price4 {
6063 #[serde(rename = "Val")]
6064 pub val: PriceRateOrAmountChoice,
6065 #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
6066 pub tp: Option<PriceValueType7Code>,
6067}
6068#[derive(
6069 Debug,
6070 Default,
6071 Clone,
6072 PartialEq,
6073 ::serde::Serialize,
6074 ::serde::Deserialize,
6075 ::derive_builder::Builder,
6076 ::validator::Validate,
6077)]
6078pub struct DocumentNumber4ChoiceEnum {
6079 #[serde(rename = "LngNb", skip_serializing_if = "Option::is_none")]
6080 pub lng_nb: Option<Iso20022MessageIdentificationText>,
6081 #[serde(rename = "ShrtNb", skip_serializing_if = "Option::is_none")]
6082 pub shrt_nb: Option<Exact3NumericText>,
6083 #[serde(rename = "PrtryNb", skip_serializing_if = "Option::is_none")]
6084 pub prtry_nb: Option<GenericIdentification38>,
6085}
6086#[derive(
6087 Debug,
6088 Default,
6089 Clone,
6090 PartialEq,
6091 ::serde::Serialize,
6092 ::serde::Deserialize,
6093 ::derive_builder::Builder,
6094 ::validator::Validate,
6095)]
6096pub struct DocumentNumber4Choice {
6097 #[serde(flatten)]
6098 pub value: DocumentNumber4ChoiceEnum,
6099}
6100#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
6101pub enum InterestComputationMethod2Code {
6102 #[serde(rename = "A001")]
6103 A001,
6104 #[serde(rename = "A002")]
6105 A002,
6106 #[serde(rename = "A003")]
6107 A003,
6108 #[serde(rename = "A004")]
6109 A004,
6110 #[serde(rename = "A005")]
6111 A005,
6112 #[serde(rename = "A006")]
6113 A006,
6114 #[serde(rename = "A007")]
6115 A007,
6116 #[serde(rename = "A008")]
6117 A008,
6118 #[serde(rename = "A009")]
6119 A009,
6120 #[serde(rename = "A010")]
6121 A010,
6122 #[serde(rename = "A011")]
6123 A011,
6124 #[serde(rename = "A012")]
6125 A012,
6126 #[serde(rename = "A013")]
6127 A013,
6128 #[serde(rename = "A014")]
6129 A014,
6130 #[serde(rename = "NARR")]
6131 Narr,
6132 #[default]
6133 Unknown,
6134}
6135#[derive(
6136 Debug,
6137 Default,
6138 Clone,
6139 PartialEq,
6140 ::serde::Serialize,
6141 ::serde::Deserialize,
6142 ::derive_builder::Builder,
6143 ::validator::Validate,
6144)]
6145pub struct NumberCount1ChoiceEnum {
6146 #[serde(rename = "CurInstrNb", skip_serializing_if = "Option::is_none")]
6147 pub cur_instr_nb: Option<Exact3NumericText>,
6148 #[serde(rename = "TtlNb", skip_serializing_if = "Option::is_none")]
6149 pub ttl_nb: Option<TotalNumber1>,
6150}
6151#[derive(
6152 Debug,
6153 Default,
6154 Clone,
6155 PartialEq,
6156 ::serde::Serialize,
6157 ::serde::Deserialize,
6158 ::derive_builder::Builder,
6159 ::validator::Validate,
6160)]
6161pub struct NumberCount1Choice {
6162 #[serde(flatten)]
6163 pub value: NumberCount1ChoiceEnum,
6164}
6165#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
6166pub enum Reversible1Code {
6167 #[serde(rename = "REVL")]
6168 Revl,
6169 #[serde(rename = "FIXD")]
6170 Fixd,
6171 #[serde(rename = "CABK")]
6172 Cabk,
6173 #[default]
6174 Unknown,
6175}
6176#[derive(
6177 Debug,
6178 Default,
6179 Clone,
6180 PartialEq,
6181 ::serde::Serialize,
6182 ::serde::Deserialize,
6183 ::derive_builder::Builder,
6184 ::validator::Validate,
6185)]
6186pub struct LetterOfGuarantee3ChoiceEnum {
6187 #[serde(rename = "Ind", skip_serializing_if = "Option::is_none")]
6188 pub ind: Option<YesNoIndicator>,
6189 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
6190 pub prtry: Option<GenericIdentification38>,
6191}
6192#[derive(
6193 Debug,
6194 Default,
6195 Clone,
6196 PartialEq,
6197 ::serde::Serialize,
6198 ::serde::Deserialize,
6199 ::derive_builder::Builder,
6200 ::validator::Validate,
6201)]
6202pub struct LetterOfGuarantee3Choice {
6203 #[serde(flatten)]
6204 pub value: LetterOfGuarantee3ChoiceEnum,
6205}
6206#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
6207pub enum FormOfSecurity1Code {
6208 #[serde(rename = "BEAR")]
6209 Bear,
6210 #[serde(rename = "REGD")]
6211 Regd,
6212 #[default]
6213 Unknown,
6214}
6215#[derive(
6216 Debug,
6217 Default,
6218 Clone,
6219 PartialEq,
6220 ::serde::Serialize,
6221 ::serde::Deserialize,
6222 ::derive_builder::Builder,
6223 ::validator::Validate,
6224)]
6225pub struct PartyTextInformation1 {
6226 #[serde(rename = "DclrtnDtls", skip_serializing_if = "Option::is_none")]
6227 pub dclrtn_dtls: Option<Max350Text>,
6228 #[serde(rename = "PtyCtctDtls", skip_serializing_if = "Option::is_none")]
6229 pub pty_ctct_dtls: Option<Max140Text>,
6230 #[serde(rename = "RegnDtls", skip_serializing_if = "Option::is_none")]
6231 pub regn_dtls: Option<Max350Text>,
6232}
6233#[derive(
6234 Debug,
6235 Default,
6236 Clone,
6237 PartialEq,
6238 ::serde::Serialize,
6239 ::serde::Deserialize,
6240 ::derive_builder::Builder,
6241 ::validator::Validate,
6242)]
6243pub struct Registration6ChoiceEnum {
6244 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
6245 pub prtry: Option<GenericIdentification38>,
6246 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
6247 pub cd: Option<Registration1Code>,
6248}
6249#[derive(
6250 Debug,
6251 Default,
6252 Clone,
6253 PartialEq,
6254 ::serde::Serialize,
6255 ::serde::Deserialize,
6256 ::derive_builder::Builder,
6257 ::validator::Validate,
6258)]
6259pub struct Registration6Choice {
6260 #[serde(flatten)]
6261 pub value: Registration6ChoiceEnum,
6262}
6263#[derive(
6264 Debug,
6265 Default,
6266 Clone,
6267 PartialEq,
6268 ::serde::Serialize,
6269 ::serde::Deserialize,
6270 ::derive_builder::Builder,
6271 ::validator::Validate,
6272)]
6273pub struct TwoLegTransactionType1ChoiceEnum {
6274 #[serde(rename = "FutrOrOptnDtls", skip_serializing_if = "Option::is_none")]
6275 pub futr_or_optn_dtls: Option<FutureOrOptionDetails1>,
6276 #[serde(rename = "SctiesFincgDtls", skip_serializing_if = "Option::is_none")]
6277 pub scties_fincg_dtls: Option<SecuritiesFinancing10>,
6278}
6279#[derive(
6280 Debug,
6281 Default,
6282 Clone,
6283 PartialEq,
6284 ::serde::Serialize,
6285 ::serde::Deserialize,
6286 ::derive_builder::Builder,
6287 ::validator::Validate,
6288)]
6289pub struct TwoLegTransactionType1Choice {
6290 #[serde(flatten)]
6291 pub value: TwoLegTransactionType1ChoiceEnum,
6292}
6293#[derive(
6294 Debug,
6295 Default,
6296 Clone,
6297 PartialEq,
6298 ::serde::Serialize,
6299 ::serde::Deserialize,
6300 ::derive_builder::Builder,
6301 ::validator::Validate,
6302)]
6303pub struct ConfirmationPartyDetails5 {
6304 #[serde(rename = "Id")]
6305 pub id: PartyIdentification32Choice,
6306 #[serde(rename = "AltrnId", skip_serializing_if = "Option::is_none")]
6307 pub altrn_id: Option<AlternatePartyIdentification5>,
6308 #[serde(rename = "PrcgId", skip_serializing_if = "Option::is_none")]
6309 pub prcg_id: Option<Max35Text>,
6310 #[serde(rename = "AddtlInf", skip_serializing_if = "Option::is_none")]
6311 pub addtl_inf: Option<PartyTextInformation5>,
6312 #[serde(
6313 rename = "InvstrPrtcnAssoctnMmbsh",
6314 skip_serializing_if = "Option::is_none"
6315 )]
6316 pub invstr_prtcn_assoctn_mmbsh: Option<YesNoIndicator>,
6317}
6318#[derive(
6319 Debug,
6320 Default,
6321 Clone,
6322 PartialEq,
6323 ::serde::Serialize,
6324 ::serde::Deserialize,
6325 ::derive_builder::Builder,
6326 ::validator::Validate,
6327)]
6328pub struct PartyTextInformation2 {
6329 #[serde(rename = "DclrtnDtls", skip_serializing_if = "Option::is_none")]
6330 pub dclrtn_dtls: Option<Max350Text>,
6331 #[serde(rename = "PtyCtctDtls", skip_serializing_if = "Option::is_none")]
6332 pub pty_ctct_dtls: Option<Max140Text>,
6333}
6334#[derive(
6335 Debug,
6336 Default,
6337 Clone,
6338 PartialEq,
6339 ::serde::Serialize,
6340 ::serde::Deserialize,
6341 ::derive_builder::Builder,
6342 ::validator::Validate,
6343)]
6344pub struct TradeDate4ChoiceEnum {
6345 #[serde(rename = "Dt", skip_serializing_if = "Option::is_none")]
6346 pub dt: Option<DateAndDateTime1Choice>,
6347 #[serde(rename = "Val", skip_serializing_if = "Option::is_none")]
6348 pub val: Option<TradingDateCode1Choice>,
6349}
6350#[derive(
6351 Debug,
6352 Default,
6353 Clone,
6354 PartialEq,
6355 ::serde::Serialize,
6356 ::serde::Deserialize,
6357 ::derive_builder::Builder,
6358 ::validator::Validate,
6359)]
6360pub struct TradeDate4Choice {
6361 #[serde(flatten)]
6362 pub value: TradeDate4ChoiceEnum,
6363}
6364#[derive(
6365 Debug,
6366 Default,
6367 Clone,
6368 PartialEq,
6369 ::serde::Serialize,
6370 ::serde::Deserialize,
6371 ::derive_builder::Builder,
6372 ::validator::Validate,
6373)]
6374pub struct CfiIdentifier {
6375 #[validate(regex = "CFI_IDENTIFIER_REGEX")]
6376 #[serde(rename = "$text")]
6377 pub value: String,
6378}
6379#[derive(
6380 Debug,
6381 Default,
6382 Clone,
6383 PartialEq,
6384 ::serde::Serialize,
6385 ::serde::Deserialize,
6386 ::derive_builder::Builder,
6387 ::validator::Validate,
6388)]
6389pub struct Max350Text {
6390 #[validate(length(min = 1, max = 350,))]
6391 #[serde(rename = "$text")]
6392 pub value: String,
6393}
6394#[derive(
6395 Debug,
6396 Default,
6397 Clone,
6398 PartialEq,
6399 ::serde::Serialize,
6400 ::serde::Deserialize,
6401 ::derive_builder::Builder,
6402 ::validator::Validate,
6403)]
6404pub struct OptionRight1ChoiceEnum {
6405 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
6406 pub cd: Option<OptionRight1Code>,
6407 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
6408 pub prtry: Option<GenericIdentification38>,
6409}
6410#[derive(
6411 Debug,
6412 Default,
6413 Clone,
6414 PartialEq,
6415 ::serde::Serialize,
6416 ::serde::Deserialize,
6417 ::derive_builder::Builder,
6418 ::validator::Validate,
6419)]
6420pub struct OptionRight1Choice {
6421 #[serde(flatten)]
6422 pub value: OptionRight1ChoiceEnum,
6423}
6424#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
6425pub enum UnitOfMeasure1Code {
6426 #[serde(rename = "PIEC")]
6427 Piec,
6428 #[serde(rename = "TONS")]
6429 Tons,
6430 #[serde(rename = "FOOT")]
6431 Foot,
6432 #[serde(rename = "GBGA")]
6433 Gbga,
6434 #[serde(rename = "USGA")]
6435 Usga,
6436 #[serde(rename = "GRAM")]
6437 Gram,
6438 #[serde(rename = "INCH")]
6439 Inch,
6440 #[serde(rename = "KILO")]
6441 Kilo,
6442 #[serde(rename = "PUND")]
6443 Pund,
6444 #[serde(rename = "METR")]
6445 Metr,
6446 #[serde(rename = "CMET")]
6447 Cmet,
6448 #[serde(rename = "MMET")]
6449 Mmet,
6450 #[serde(rename = "LITR")]
6451 Litr,
6452 #[serde(rename = "CELI")]
6453 Celi,
6454 #[serde(rename = "MILI")]
6455 Mili,
6456 #[serde(rename = "GBOU")]
6457 Gbou,
6458 #[serde(rename = "USOU")]
6459 Usou,
6460 #[serde(rename = "GBQA")]
6461 Gbqa,
6462 #[serde(rename = "USQA")]
6463 Usqa,
6464 #[serde(rename = "GBPI")]
6465 Gbpi,
6466 #[serde(rename = "USPI")]
6467 Uspi,
6468 #[serde(rename = "MILE")]
6469 Mile,
6470 #[serde(rename = "KMET")]
6471 Kmet,
6472 #[serde(rename = "YARD")]
6473 Yard,
6474 #[serde(rename = "SQKI")]
6475 Sqki,
6476 #[serde(rename = "HECT")]
6477 Hect,
6478 #[serde(rename = "ARES")]
6479 Ares,
6480 #[serde(rename = "SMET")]
6481 Smet,
6482 #[serde(rename = "SCMT")]
6483 Scmt,
6484 #[serde(rename = "SMIL")]
6485 Smil,
6486 #[serde(rename = "SQMI")]
6487 Sqmi,
6488 #[serde(rename = "SQYA")]
6489 Sqya,
6490 #[serde(rename = "SQFO")]
6491 Sqfo,
6492 #[serde(rename = "SQIN")]
6493 Sqin,
6494 #[serde(rename = "ACRE")]
6495 Acre,
6496 #[default]
6497 Unknown,
6498}
6499#[derive(
6500 Debug,
6501 Default,
6502 Clone,
6503 PartialEq,
6504 ::serde::Serialize,
6505 ::serde::Deserialize,
6506 ::derive_builder::Builder,
6507 ::validator::Validate,
6508)]
6509pub struct FxStandingInstruction3ChoiceEnum {
6510 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
6511 pub prtry: Option<GenericIdentification38>,
6512 #[serde(rename = "Ind", skip_serializing_if = "Option::is_none")]
6513 pub ind: Option<YesNoIndicator>,
6514}
6515#[derive(
6516 Debug,
6517 Default,
6518 Clone,
6519 PartialEq,
6520 ::serde::Serialize,
6521 ::serde::Deserialize,
6522 ::derive_builder::Builder,
6523 ::validator::Validate,
6524)]
6525pub struct FxStandingInstruction3Choice {
6526 #[serde(flatten)]
6527 pub value: FxStandingInstruction3ChoiceEnum,
6528}
6529#[derive(
6530 Debug,
6531 Default,
6532 Clone,
6533 PartialEq,
6534 ::serde::Serialize,
6535 ::serde::Deserialize,
6536 ::derive_builder::Builder,
6537 ::validator::Validate,
6538)]
6539pub struct FinancialInstrumentQuantityChoiceEnum {
6540 #[serde(rename = "FaceAmt", skip_serializing_if = "Option::is_none")]
6541 pub face_amt: Option<ImpliedCurrencyAndAmount>,
6542 #[serde(rename = "AmtsdVal", skip_serializing_if = "Option::is_none")]
6543 pub amtsd_val: Option<ImpliedCurrencyAndAmount>,
6544 #[serde(rename = "Unit", skip_serializing_if = "Option::is_none")]
6545 pub unit: Option<DecimalNumber>,
6546}
6547#[derive(
6548 Debug,
6549 Default,
6550 Clone,
6551 PartialEq,
6552 ::serde::Serialize,
6553 ::serde::Deserialize,
6554 ::derive_builder::Builder,
6555 ::validator::Validate,
6556)]
6557pub struct FinancialInstrumentQuantityChoice {
6558 #[serde(flatten)]
6559 pub value: FinancialInstrumentQuantityChoiceEnum,
6560}
6561#[derive(
6562 Debug,
6563 Default,
6564 Clone,
6565 PartialEq,
6566 ::serde::Serialize,
6567 ::serde::Deserialize,
6568 ::derive_builder::Builder,
6569 ::validator::Validate,
6570)]
6571pub struct RateType19ChoiceEnum {
6572 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
6573 pub cd: Option<RateType1Code>,
6574 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
6575 pub prtry: Option<GenericIdentification38>,
6576}
6577#[derive(
6578 Debug,
6579 Default,
6580 Clone,
6581 PartialEq,
6582 ::serde::Serialize,
6583 ::serde::Deserialize,
6584 ::derive_builder::Builder,
6585 ::validator::Validate,
6586)]
6587pub struct RateType19Choice {
6588 #[serde(flatten)]
6589 pub value: RateType19ChoiceEnum,
6590}
6591#[derive(
6592 Debug,
6593 Default,
6594 Clone,
6595 PartialEq,
6596 ::serde::Serialize,
6597 ::serde::Deserialize,
6598 ::derive_builder::Builder,
6599 ::validator::Validate,
6600)]
6601pub struct RegulatoryStipulations1 {
6602 #[serde(rename = "Ctry")]
6603 pub ctry: CountryCode,
6604 #[validate(length(min = 1,))]
6605 #[serde(rename = "Stiptns", default)]
6606 pub stiptns: Vec<Max350Text>,
6607}
6608#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
6609pub enum AddressType2Code {
6610 #[serde(rename = "ADDR")]
6611 Addr,
6612 #[serde(rename = "PBOX")]
6613 Pbox,
6614 #[serde(rename = "HOME")]
6615 Home,
6616 #[serde(rename = "BIZZ")]
6617 Bizz,
6618 #[serde(rename = "MLTO")]
6619 Mlto,
6620 #[serde(rename = "DLVY")]
6621 Dlvy,
6622 #[default]
6623 Unknown,
6624}
6625#[derive(
6626 Debug,
6627 Default,
6628 Clone,
6629 PartialEq,
6630 ::serde::Serialize,
6631 ::serde::Deserialize,
6632 ::derive_builder::Builder,
6633 ::validator::Validate,
6634)]
6635pub struct BaseOneRate {
6636 #[serde(rename = "$text")]
6637 pub value: f64,
6638}
6639#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
6640pub enum ChargeTaxBasis1Code {
6641 #[serde(rename = "FLAT")]
6642 Flat,
6643 #[serde(rename = "PERU")]
6644 Peru,
6645 #[default]
6646 Unknown,
6647}
6648#[derive(
6649 Debug,
6650 Default,
6651 Clone,
6652 PartialEq,
6653 ::serde::Serialize,
6654 ::serde::Deserialize,
6655 ::derive_builder::Builder,
6656 ::validator::Validate,
6657)]
6658pub struct MarketType12ChoiceEnum {
6659 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
6660 pub prtry: Option<GenericIdentification38>,
6661 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
6662 pub cd: Option<MarketType2Code>,
6663}
6664#[derive(
6665 Debug,
6666 Default,
6667 Clone,
6668 PartialEq,
6669 ::serde::Serialize,
6670 ::serde::Deserialize,
6671 ::derive_builder::Builder,
6672 ::validator::Validate,
6673)]
6674pub struct MarketType12Choice {
6675 #[serde(flatten)]
6676 pub value: MarketType12ChoiceEnum,
6677}
6678#[derive(
6679 Debug,
6680 Default,
6681 Clone,
6682 PartialEq,
6683 ::serde::Serialize,
6684 ::serde::Deserialize,
6685 ::derive_builder::Builder,
6686 ::validator::Validate,
6687)]
6688pub struct ClosingDate1ChoiceEnum {
6689 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
6690 pub cd: Option<Date2Choice>,
6691 #[serde(rename = "Dt", skip_serializing_if = "Option::is_none")]
6692 pub dt: Option<DateAndDateTimeChoice>,
6693}
6694#[derive(
6695 Debug,
6696 Default,
6697 Clone,
6698 PartialEq,
6699 ::serde::Serialize,
6700 ::serde::Deserialize,
6701 ::derive_builder::Builder,
6702 ::validator::Validate,
6703)]
6704pub struct ClosingDate1Choice {
6705 #[serde(flatten)]
6706 pub value: ClosingDate1ChoiceEnum,
6707}
6708#[derive(
6709 Debug,
6710 Default,
6711 Clone,
6712 PartialEq,
6713 ::serde::Serialize,
6714 ::serde::Deserialize,
6715 ::derive_builder::Builder,
6716 ::validator::Validate,
6717)]
6718pub struct Rating1 {
6719 #[validate]
6720 #[serde(rename = "RatgSchme")]
6721 pub ratg_schme: Max35Text,
6722 #[validate]
6723 #[serde(rename = "ValDt")]
6724 pub val_dt: IsoDateTime,
6725 #[validate]
6726 #[serde(rename = "ValId")]
6727 pub val_id: RatingValueIdentifier,
6728}
6729#[derive(
6730 Debug,
6731 Default,
6732 Clone,
6733 PartialEq,
6734 ::serde::Serialize,
6735 ::serde::Deserialize,
6736 ::derive_builder::Builder,
6737 ::validator::Validate,
6738)]
6739pub struct IsoDateTime {
6740 #[serde(rename = "$text")]
6741 pub value: ::chrono::DateTime<::chrono::Utc>,
6742}
6743#[derive(
6744 Debug,
6745 Default,
6746 Clone,
6747 PartialEq,
6748 ::serde::Serialize,
6749 ::serde::Deserialize,
6750 ::derive_builder::Builder,
6751 ::validator::Validate,
6752)]
6753pub struct SecuritiesLendingType1ChoiceEnum {
6754 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
6755 pub prtry: Option<GenericIdentification38>,
6756 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
6757 pub cd: Option<SecuritiesLendingType1Code>,
6758}
6759#[derive(
6760 Debug,
6761 Default,
6762 Clone,
6763 PartialEq,
6764 ::serde::Serialize,
6765 ::serde::Deserialize,
6766 ::derive_builder::Builder,
6767 ::validator::Validate,
6768)]
6769pub struct SecuritiesLendingType1Choice {
6770 #[serde(flatten)]
6771 pub value: SecuritiesLendingType1ChoiceEnum,
6772}
6773#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
6774pub enum MarketType6Code {
6775 #[serde(rename = "OTCO")]
6776 Otco,
6777 #[serde(rename = "VARI")]
6778 Vari,
6779 #[serde(rename = "EXCH")]
6780 Exch,
6781 #[default]
6782 Unknown,
6783}
6784#[derive(
6785 Debug,
6786 Default,
6787 Clone,
6788 PartialEq,
6789 ::serde::Serialize,
6790 ::serde::Deserialize,
6791 ::derive_builder::Builder,
6792 ::validator::Validate,
6793)]
6794pub struct Exact4NumericText {
6795 #[validate(regex = "EXACT_4_NUMERIC_TEXT_REGEX")]
6796 #[serde(rename = "$text")]
6797 pub value: String,
6798}
6799#[derive(
6800 Debug,
6801 Default,
6802 Clone,
6803 PartialEq,
6804 ::serde::Serialize,
6805 ::serde::Deserialize,
6806 ::derive_builder::Builder,
6807 ::validator::Validate,
6808)]
6809pub struct SecuritiesAccount3 {
6810 #[validate]
6811 #[serde(rename = "Id")]
6812 pub id: Max35Text,
6813 #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
6814 pub tp: Option<PurposeCode5Choice>,
6815 #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
6816 pub nm: Option<Max70Text>,
6817}
6818#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
6819pub enum Reporting2Code {
6820 #[serde(rename = "STEX")]
6821 Stex,
6822 #[serde(rename = "REGU")]
6823 Regu,
6824 #[serde(rename = "DEFR")]
6825 Defr,
6826 #[default]
6827 Unknown,
6828}
6829#[derive(
6830 Debug,
6831 Default,
6832 Clone,
6833 PartialEq,
6834 ::serde::Serialize,
6835 ::serde::Deserialize,
6836 ::derive_builder::Builder,
6837 ::validator::Validate,
6838)]
6839pub struct AlternatePartyIdentification5 {
6840 #[serde(rename = "IdTp")]
6841 pub id_tp: IdentificationType40Choice,
6842 #[serde(rename = "Ctry")]
6843 pub ctry: CountryCode,
6844 #[validate]
6845 #[serde(rename = "AltrnId")]
6846 pub altrn_id: Max35Text,
6847}
6848#[derive(
6849 Debug,
6850 Default,
6851 Clone,
6852 PartialEq,
6853 ::serde::Serialize,
6854 ::serde::Deserialize,
6855 ::derive_builder::Builder,
6856 ::validator::Validate,
6857)]
6858pub struct Max4NumericText {
6859 #[validate(regex = "MAX_4_NUMERIC_TEXT_REGEX")]
6860 #[serde(rename = "$text")]
6861 pub value: String,
6862}
6863#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
6864pub enum CollateralType3Code {
6865 #[serde(rename = "CASH")]
6866 Cash,
6867 #[serde(rename = "SECU")]
6868 Secu,
6869 #[serde(rename = "PHYS")]
6870 Phys,
6871 #[serde(rename = "INSU")]
6872 Insu,
6873 #[serde(rename = "STCF")]
6874 Stcf,
6875 #[serde(rename = "BOND")]
6876 Bond,
6877 #[serde(rename = "GBBK")]
6878 Gbbk,
6879 #[serde(rename = "OTHR")]
6880 Othr,
6881 #[default]
6882 Unknown,
6883}
6884#[derive(
6885 Debug,
6886 Default,
6887 Clone,
6888 PartialEq,
6889 ::serde::Serialize,
6890 ::serde::Deserialize,
6891 ::derive_builder::Builder,
6892 ::validator::Validate,
6893)]
6894pub struct UpicIdentifier {
6895 #[validate(regex = "UPIC_IDENTIFIER_REGEX")]
6896 #[serde(rename = "$text")]
6897 pub value: String,
6898}
6899#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
6900pub enum TradeType3Code {
6901 #[serde(rename = "BSKT")]
6902 Bskt,
6903 #[serde(rename = "INDX")]
6904 Indx,
6905 #[serde(rename = "IPOO")]
6906 Ipoo,
6907 #[serde(rename = "LIST")]
6908 List,
6909 #[serde(rename = "PRAL")]
6910 Pral,
6911 #[serde(rename = "PROG")]
6912 Prog,
6913 #[serde(rename = "TRAD")]
6914 Trad,
6915 #[serde(rename = "BRBR")]
6916 Brbr,
6917 #[serde(rename = "RISK")]
6918 Risk,
6919 #[serde(rename = "VWAP")]
6920 Vwap,
6921 #[serde(rename = "AGEN")]
6922 Agen,
6923 #[serde(rename = "GUAR")]
6924 Guar,
6925 #[serde(rename = "EMTR")]
6926 Emtr,
6927 #[serde(rename = "ISSU")]
6928 Issu,
6929 #[serde(rename = "BOST")]
6930 Bost,
6931 #[serde(rename = "BOEN")]
6932 Boen,
6933 #[serde(rename = "LABO")]
6934 Labo,
6935 #[serde(rename = "BORE")]
6936 Bore,
6937 #[serde(rename = "OFIT")]
6938 Ofit,
6939 #[serde(rename = "BOSU")]
6940 Bosu,
6941 #[serde(rename = "FBBT")]
6942 Fbbt,
6943 #[serde(rename = "OPTN")]
6944 Optn,
6945 #[serde(rename = "FUOP")]
6946 Fuop,
6947 #[serde(rename = "FUTR")]
6948 Futr,
6949 #[default]
6950 Unknown,
6951}
6952#[derive(
6953 Debug,
6954 Default,
6955 Clone,
6956 PartialEq,
6957 ::serde::Serialize,
6958 ::serde::Deserialize,
6959 ::derive_builder::Builder,
6960 ::validator::Validate,
6961)]
6962pub struct Agreement3 {
6963 #[serde(rename = "Desc", skip_serializing_if = "Option::is_none")]
6964 pub desc: Option<Max350Text>,
6965 #[serde(rename = "Dt", skip_serializing_if = "Option::is_none")]
6966 pub dt: Option<IsoDateTime>,
6967 #[serde(rename = "Ccy", skip_serializing_if = "Option::is_none")]
6968 pub ccy: Option<CurrencyCode>,
6969 #[serde(rename = "ClsgTp", skip_serializing_if = "Option::is_none")]
6970 pub clsg_tp: Option<ClosingType1Code>,
6971 #[serde(rename = "StartDt", skip_serializing_if = "Option::is_none")]
6972 pub start_dt: Option<IsoDateTime>,
6973 #[serde(rename = "DlvryTp", skip_serializing_if = "Option::is_none")]
6974 pub dlvry_tp: Option<DeliveryType2Code>,
6975 #[serde(rename = "MrgnRatio", skip_serializing_if = "Option::is_none")]
6976 pub mrgn_ratio: Option<PercentageRate>,
6977}
6978#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
6979pub enum DateType2Code {
6980 #[serde(rename = "OPEN")]
6981 Open,
6982 #[default]
6983 Unknown,
6984}
6985#[derive(
6986 Debug,
6987 Default,
6988 Clone,
6989 PartialEq,
6990 ::serde::Serialize,
6991 ::serde::Deserialize,
6992 ::derive_builder::Builder,
6993 ::validator::Validate,
6994)]
6995pub struct ClassificationType30ChoiceEnum {
6996 #[serde(rename = "ClssfctnFinInstrm", skip_serializing_if = "Option::is_none")]
6997 pub clssfctn_fin_instrm: Option<CfiIdentifier>,
6998 #[serde(rename = "AltrnClssfctn", skip_serializing_if = "Option::is_none")]
6999 pub altrn_clssfctn: Option<GenericIdentification36>,
7000}
7001#[derive(
7002 Debug,
7003 Default,
7004 Clone,
7005 PartialEq,
7006 ::serde::Serialize,
7007 ::serde::Deserialize,
7008 ::derive_builder::Builder,
7009 ::validator::Validate,
7010)]
7011pub struct ClassificationType30Choice {
7012 #[serde(flatten)]
7013 pub value: ClassificationType30ChoiceEnum,
7014}
7015#[derive(
7016 Debug,
7017 Default,
7018 Clone,
7019 PartialEq,
7020 ::serde::Serialize,
7021 ::serde::Deserialize,
7022 ::derive_builder::Builder,
7023 ::validator::Validate,
7024)]
7025pub struct NameAndAddress13 {
7026 #[validate]
7027 #[serde(rename = "Nm")]
7028 pub nm: Max350Text,
7029 #[serde(rename = "Adr", skip_serializing_if = "Option::is_none")]
7030 pub adr: Option<PostalAddress8>,
7031}
7032#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
7033pub enum SettlementStandingInstructionDatabase1Code {
7034 #[serde(rename = "INTE")]
7035 Inte,
7036 #[serde(rename = "BRKR")]
7037 Brkr,
7038 #[serde(rename = "VEND")]
7039 Vend,
7040 #[default]
7041 Unknown,
7042}
7043#[derive(
7044 Debug,
7045 Default,
7046 Clone,
7047 PartialEq,
7048 ::serde::Serialize,
7049 ::serde::Deserialize,
7050 ::derive_builder::Builder,
7051 ::validator::Validate,
7052)]
7053pub struct SecuritiesTradeConfirmationV03<
7054 A: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
7055> {
7056 #[validate]
7057 #[serde(rename = "Id")]
7058 pub id: TransactiontIdentification4,
7059 #[serde(rename = "NbCnt", skip_serializing_if = "Option::is_none")]
7060 pub nb_cnt: Option<NumberCount1Choice>,
7061 #[validate(length(min = 0,))]
7062 #[serde(rename = "Refs", default)]
7063 pub refs: Vec<Linkages15>,
7064 #[validate]
7065 #[serde(rename = "TradDtls")]
7066 pub trad_dtls: Order17,
7067 #[validate]
7068 #[serde(rename = "FinInstrmId")]
7069 pub fin_instrm_id: SecurityIdentification14,
7070 #[serde(rename = "FinInstrmAttrbts", skip_serializing_if = "Option::is_none")]
7071 pub fin_instrm_attrbts: Option<FinancialInstrumentAttributes44>,
7072 #[validate(length(min = 0,))]
7073 #[serde(rename = "UndrlygFinInstrm", default)]
7074 pub undrlyg_fin_instrm: Vec<UnderlyingFinancialInstrument2>,
7075 #[serde(rename = "Stiptns", skip_serializing_if = "Option::is_none")]
7076 pub stiptns: Option<FinancialInstrumentStipulations2>,
7077 #[validate(length(min = 1,))]
7078 #[serde(rename = "ConfPties", default)]
7079 pub conf_pties: Vec<ConfirmationParties2>,
7080 #[serde(rename = "SttlmParams", skip_serializing_if = "Option::is_none")]
7081 pub sttlm_params: Option<SettlementDetails43>,
7082 #[serde(rename = "StgSttlmInstr", skip_serializing_if = "Option::is_none")]
7083 pub stg_sttlm_instr: Option<StandingSettlementInstruction9>,
7084 #[serde(rename = "DlvrgSttlmPties", skip_serializing_if = "Option::is_none")]
7085 pub dlvrg_sttlm_pties: Option<SettlementParties23>,
7086 #[serde(rename = "RcvgSttlmPties", skip_serializing_if = "Option::is_none")]
7087 pub rcvg_sttlm_pties: Option<SettlementParties23>,
7088 #[serde(rename = "CshPties", skip_serializing_if = "Option::is_none")]
7089 pub csh_pties: Option<CashParties18>,
7090 #[serde(rename = "ClrDtls", skip_serializing_if = "Option::is_none")]
7091 pub clr_dtls: Option<Clearing3>,
7092 #[serde(rename = "SttlmAmt", skip_serializing_if = "Option::is_none")]
7093 pub sttlm_amt: Option<AmountAndDirection28>,
7094 #[validate(length(min = 0,))]
7095 #[serde(rename = "OthrAmts", default)]
7096 pub othr_amts: Vec<OtherAmounts16>,
7097 #[validate(length(min = 0,))]
7098 #[serde(rename = "OthrPrics", default)]
7099 pub othr_prics: Vec<OtherPrices2>,
7100 #[serde(rename = "OthrBizPties", skip_serializing_if = "Option::is_none")]
7101 pub othr_biz_pties: Option<OtherParties18>,
7102 #[serde(rename = "TwoLegTxDtls", skip_serializing_if = "Option::is_none")]
7103 pub two_leg_tx_dtls: Option<TwoLegTransactionDetails1>,
7104 #[serde(rename = "RgltryStiptns", skip_serializing_if = "Option::is_none")]
7105 pub rgltry_stiptns: Option<RegulatoryStipulations1>,
7106 #[validate(length(min = 0,))]
7107 #[serde(rename = "SplmtryData", default)]
7108 pub splmtry_data: Vec<SupplementaryData1<A>>,
7109}
7110#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
7111pub enum SecuritiesLendingType1Code {
7112 #[serde(rename = "NWRG")]
7113 Nwrg,
7114 #[serde(rename = "RENW")]
7115 Renw,
7116 #[serde(rename = "CABK")]
7117 Cabk,
7118 #[default]
7119 Unknown,
7120}
7121#[derive(
7122 Debug,
7123 Default,
7124 Clone,
7125 PartialEq,
7126 ::serde::Serialize,
7127 ::serde::Deserialize,
7128 ::derive_builder::Builder,
7129 ::validator::Validate,
7130)]
7131pub struct SettlingCapacity3ChoiceEnum {
7132 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
7133 pub cd: Option<SettlingCapacity1Code>,
7134 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
7135 pub prtry: Option<GenericIdentification38>,
7136}
7137#[derive(
7138 Debug,
7139 Default,
7140 Clone,
7141 PartialEq,
7142 ::serde::Serialize,
7143 ::serde::Deserialize,
7144 ::derive_builder::Builder,
7145 ::validator::Validate,
7146)]
7147pub struct SettlingCapacity3Choice {
7148 #[serde(flatten)]
7149 pub value: SettlingCapacity3ChoiceEnum,
7150}
7151#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
7152pub enum EventFrequency3Code {
7153 #[serde(rename = "YEAR")]
7154 Year,
7155 #[serde(rename = "MNTH")]
7156 Mnth,
7157 #[serde(rename = "QUTR")]
7158 Qutr,
7159 #[serde(rename = "SEMI")]
7160 Semi,
7161 #[serde(rename = "WEEK")]
7162 Week,
7163 #[default]
7164 Unknown,
7165}
7166#[derive(
7167 Debug,
7168 Default,
7169 Clone,
7170 PartialEq,
7171 ::serde::Serialize,
7172 ::serde::Deserialize,
7173 ::derive_builder::Builder,
7174 ::validator::Validate,
7175)]
7176pub struct UnderlyingFinancialInstrument2 {
7177 #[validate]
7178 #[serde(rename = "Id")]
7179 pub id: SecurityIdentification14,
7180 #[serde(rename = "Attrbts", skip_serializing_if = "Option::is_none")]
7181 pub attrbts: Option<FinancialInstrumentAttributes44>,
7182}
7183#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
7184pub enum OptionType1Code {
7185 #[serde(rename = "CALL")]
7186 Call,
7187 #[serde(rename = "PUTO")]
7188 Puto,
7189 #[default]
7190 Unknown,
7191}
7192#[derive(
7193 Debug,
7194 Default,
7195 Clone,
7196 PartialEq,
7197 ::serde::Serialize,
7198 ::serde::Deserialize,
7199 ::derive_builder::Builder,
7200 ::validator::Validate,
7201)]
7202pub struct BusinessProcessType1ChoiceEnum {
7203 #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
7204 pub prtry: Option<GenericIdentification38>,
7205 #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
7206 pub cd: Option<BusinessProcessType1Code>,
7207}
7208#[derive(
7209 Debug,
7210 Default,
7211 Clone,
7212 PartialEq,
7213 ::serde::Serialize,
7214 ::serde::Deserialize,
7215 ::derive_builder::Builder,
7216 ::validator::Validate,
7217)]
7218pub struct BusinessProcessType1Choice {
7219 #[serde(flatten)]
7220 pub value: BusinessProcessType1ChoiceEnum,
7221}
7222#[derive(
7223 Debug,
7224 Default,
7225 Clone,
7226 PartialEq,
7227 ::serde::Serialize,
7228 ::serde::Deserialize,
7229 ::derive_builder::Builder,
7230 ::validator::Validate,
7231)]
7232pub struct RateName1 {
7233 #[serde(rename = "Issr", skip_serializing_if = "Option::is_none")]
7234 pub issr: Option<Max8Text>,
7235 #[validate]
7236 #[serde(rename = "RateNm")]
7237 pub rate_nm: Max35Text,
7238}