iso_20022_reda/
reda_007_001_01.rs

1// Copyright 2023 Emergent Financial, LLC - All Rights Reserved
2//
3//
4// This software is licensed under the Emergent Financial Limited Public License Version 1.0
5// (EF-LPLv1). You may use, copy, modify, and distribute this software under the terms and
6// conditions of the EF-LPL. For more information, please refer to the full text of the license
7// at https://github.com/emergentfinancial/ef-lpl.
8//
9//
10// THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS
11// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
12// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
13// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
14// WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
15// CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
16//
17// See ISO-20022 Intellectual Property Rights Policy at
18// <https://www.iso20022.org/intellectual-property-rights>
19// for more information.
20
21use validator::Validate;
22
23::lazy_static::lazy_static! {
24    static ref LEI_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Z0-9]{18,18}[0-9]{2,2}"#).unwrap();
25}
26
27::lazy_static::lazy_static! {
28    static ref ACTIVE_OR_HISTORIC_CURRENCY_CODE_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Z]{3,3}"#).unwrap();
29}
30
31::lazy_static::lazy_static! {
32    static ref CFI_OCT_2015_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Z]{6,6}"#).unwrap();
33}
34
35::lazy_static::lazy_static! {
36    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();
37}
38
39::lazy_static::lazy_static! {
40    static ref MAX_15_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,15}"#).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 ANY_BIC_DEC_2014_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Z0-9]{4,4}[A-Z]{2,2}[A-Z0-9]{2,2}([A-Z0-9]{3,3}){0,1}"#).unwrap();
49}
50
51::lazy_static::lazy_static! {
52    static ref MAX_4_ALPHA_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[a-zA-Z0-9]{1,4}"#).unwrap();
53}
54
55::lazy_static::lazy_static! {
56    static ref ACTIVE_CURRENCY_CODE_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Z]{3,3}"#).unwrap();
57}
58
59::lazy_static::lazy_static! {
60    static ref PHONE_NUMBER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"\+[0-9]{1,3}-[0-9()+\-]{1,30}"#).unwrap();
61}
62
63::lazy_static::lazy_static! {
64    static ref MAX_3_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[0-9]{1,3}"#).unwrap();
65}
66
67::lazy_static::lazy_static! {
68    static ref ISIN_2021_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Z]{2,2}[A-Z0-9]{9,9}[0-9]{1,1}"#).unwrap();
69}
70
71::lazy_static::lazy_static! {
72    static ref MIC_IDENTIFIER_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[A-Z0-9]{4,4}"#).unwrap();
73}
74
75::lazy_static::lazy_static! {
76    static ref EXACT_4_ALPHA_NUMERIC_TEXT_REGEX: ::regex::Regex = ::regex::Regex::new(r#"[a-zA-Z0-9]{4}"#).unwrap();
77}
78
79/// Returns the namespace of the schema
80pub fn namespace() -> String {
81    "urn:iso:std:iso:20022:tech:xsd:reda.007.001.01".to_string()
82}
83
84#[derive(
85    Debug,
86    Default,
87    Clone,
88    PartialEq,
89    ::serde::Serialize,
90    ::serde::Deserialize,
91    ::derive_builder::Builder,
92    ::validator::Validate,
93)]
94pub struct SecurityRestriction3 {
95    #[serde(rename = "FctvPrd", skip_serializing_if = "Option::is_none")]
96    pub fctv_prd: Option<DateTimePeriod2>,
97    #[serde(rename = "RstrctnTp", skip_serializing_if = "Option::is_none")]
98    pub rstrctn_tp: Option<SecurityRestrictionType2Choice>,
99    #[serde(rename = "LglRstrctnTp", skip_serializing_if = "Option::is_none")]
100    pub lgl_rstrctn_tp: Option<LegalRestrictions5Choice>,
101    #[validate(length(min = 0,))]
102    #[serde(rename = "InvstrRstrctnTp", default)]
103    pub invstr_rstrctn_tp: Vec<InvestorRestrictionType3Choice>,
104    #[validate(length(min = 0,))]
105    #[serde(rename = "InvstrTp", default)]
106    pub invstr_tp: Vec<InvestorType3Choice>,
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 Equity3 {
119    #[serde(rename = "PrefToIncm")]
120    pub pref_to_incm: PreferenceToIncome5Choice,
121    #[serde(rename = "MtrtyDt", skip_serializing_if = "Option::is_none")]
122    pub mtrty_dt: Option<IsoDateTime>,
123    #[serde(rename = "NonPdAmt", skip_serializing_if = "Option::is_none")]
124    pub non_pd_amt: Option<ActiveCurrencyAndAmount>,
125    #[serde(rename = "ParVal", skip_serializing_if = "Option::is_none")]
126    pub par_val: Option<ActiveCurrencyAndAmount>,
127    #[serde(rename = "VtngRghtsPerShr", skip_serializing_if = "Option::is_none")]
128    pub vtng_rghts_per_shr: Option<Number>,
129}
130#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
131pub enum InterestType3Code {
132    #[serde(rename = "ZCPN")]
133    Zcpn,
134    #[serde(rename = "FIXD")]
135    Fixd,
136    #[serde(rename = "FLRN")]
137    Flrn,
138    #[serde(rename = "DUAL")]
139    Dual,
140    #[serde(rename = "INDE")]
141    Inde,
142    #[serde(rename = "DSCO")]
143    Dsco,
144    #[default]
145    Unknown,
146}
147#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
148pub enum Operator1Code {
149    #[serde(rename = "SMAL")]
150    Smal,
151    #[serde(rename = "SMEQ")]
152    Smeq,
153    #[serde(rename = "GREA")]
154    Grea,
155    #[serde(rename = "GREQ")]
156    Greq,
157    #[serde(rename = "EQAL")]
158    Eqal,
159    #[default]
160    Unknown,
161}
162#[derive(
163    Debug,
164    Default,
165    Clone,
166    PartialEq,
167    ::serde::Serialize,
168    ::serde::Deserialize,
169    ::derive_builder::Builder,
170    ::validator::Validate,
171)]
172pub struct UpdateType35ChoiceEnum<
173    A: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
174    B: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
175    C: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
176> {
177    #[serde(rename = "Modfy", skip_serializing_if = "Option::is_none")]
178    pub modfy: Option<SecurityAttributes12<A>>,
179    #[serde(rename = "Add", skip_serializing_if = "Option::is_none")]
180    pub add: Option<SecurityAttributes12<B>>,
181    #[serde(rename = "Del", skip_serializing_if = "Option::is_none")]
182    pub del: Option<SecurityAttributes12<C>>,
183}
184#[derive(
185    Debug,
186    Default,
187    Clone,
188    PartialEq,
189    ::serde::Serialize,
190    ::serde::Deserialize,
191    ::derive_builder::Builder,
192    ::validator::Validate,
193)]
194pub struct UpdateType35Choice<
195    A: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
196    B: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
197    C: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
198> {
199    #[serde(flatten)]
200    pub value: UpdateType35ChoiceEnum<A, B, C>,
201}
202#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
203pub enum SecurityStatus2Code {
204    #[serde(rename = "ACTV")]
205    Actv,
206    #[serde(rename = "INAC")]
207    Inac,
208    #[serde(rename = "SUSP")]
209    Susp,
210    #[default]
211    Unknown,
212}
213#[derive(
214    Debug,
215    Default,
216    Clone,
217    PartialEq,
218    ::serde::Serialize,
219    ::serde::Deserialize,
220    ::derive_builder::Builder,
221    ::validator::Validate,
222)]
223pub struct PartyIdentification136 {
224    #[serde(rename = "Id")]
225    pub id: PartyIdentification120Choice,
226    #[serde(rename = "LEI", skip_serializing_if = "Option::is_none")]
227    pub lei: Option<LeiIdentifier>,
228}
229#[derive(
230    Debug,
231    Default,
232    Clone,
233    PartialEq,
234    ::serde::Serialize,
235    ::serde::Deserialize,
236    ::derive_builder::Builder,
237    ::validator::Validate,
238)]
239pub struct NameAndAddress5 {
240    #[validate]
241    #[serde(rename = "Nm")]
242    pub nm: Max350Text,
243    #[serde(rename = "Adr", skip_serializing_if = "Option::is_none")]
244    pub adr: Option<PostalAddress1>,
245}
246#[derive(
247    Debug,
248    Default,
249    Clone,
250    PartialEq,
251    ::serde::Serialize,
252    ::serde::Deserialize,
253    ::derive_builder::Builder,
254    ::validator::Validate,
255)]
256pub struct YieldCalculation6 {
257    #[validate]
258    #[serde(rename = "Val")]
259    pub val: PercentageRate,
260    #[serde(rename = "ClctnTp", skip_serializing_if = "Option::is_none")]
261    pub clctn_tp: Option<CalculationType3Choice>,
262    #[serde(rename = "RedPric", skip_serializing_if = "Option::is_none")]
263    pub red_pric: Option<Price8>,
264    #[validate]
265    #[serde(rename = "ValDt")]
266    pub val_dt: IsoDate,
267    #[serde(rename = "ValPrd")]
268    pub val_prd: DateTimePeriod1Choice,
269    #[validate]
270    #[serde(rename = "ClctnDt")]
271    pub clctn_dt: IsoDateTime,
272}
273#[derive(
274    Debug,
275    Default,
276    Clone,
277    PartialEq,
278    ::serde::Serialize,
279    ::serde::Deserialize,
280    ::derive_builder::Builder,
281    ::validator::Validate,
282)]
283pub struct ActiveCurrencyAndAmountSimpleType {
284    #[validate(range(min = 0,))]
285    #[serde(rename = "$text")]
286    pub value: f64,
287}
288#[derive(
289    Debug,
290    Default,
291    Clone,
292    PartialEq,
293    ::serde::Serialize,
294    ::serde::Deserialize,
295    ::derive_builder::Builder,
296    ::validator::Validate,
297)]
298pub struct OtherIdentification1 {
299    #[validate]
300    #[serde(rename = "Id")]
301    pub id: Max35Text,
302    #[serde(rename = "Sfx", skip_serializing_if = "Option::is_none")]
303    pub sfx: Option<Max16Text>,
304    #[serde(rename = "Tp")]
305    pub tp: IdentificationSource3Choice,
306}
307#[derive(
308    Debug,
309    Default,
310    Clone,
311    PartialEq,
312    ::serde::Serialize,
313    ::serde::Deserialize,
314    ::derive_builder::Builder,
315    ::validator::Validate,
316)]
317pub struct IsoDateTime {
318    #[serde(rename = "$text")]
319    pub value: ::chrono::DateTime<::chrono::Utc>,
320}
321#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
322pub enum SettleStyle1Code {
323    #[serde(rename = "SETC")]
324    Setc,
325    #[serde(rename = "SETO")]
326    Seto,
327    #[default]
328    Unknown,
329}
330#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
331pub enum WarrantStyle1Code {
332    #[serde(rename = "AMER")]
333    Amer,
334    #[serde(rename = "EURO")]
335    Euro,
336    #[serde(rename = "BERM")]
337    Berm,
338    #[default]
339    Unknown,
340}
341#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
342pub enum InvestorType1Code {
343    #[serde(rename = "RETL")]
344    Retl,
345    #[serde(rename = "PROF")]
346    Prof,
347    #[serde(rename = "STAF")]
348    Staf,
349    #[serde(rename = "PPER")]
350    Pper,
351    #[default]
352    Unknown,
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 Issuance5 {
365    #[serde(rename = "IssePlc", skip_serializing_if = "Option::is_none")]
366    pub isse_plc: Option<MicIdentifier>,
367    #[serde(rename = "CtryOfIsse", skip_serializing_if = "Option::is_none")]
368    pub ctry_of_isse: Option<CountryCode>,
369    #[serde(rename = "IsseDt", skip_serializing_if = "Option::is_none")]
370    pub isse_dt: Option<IsoDate>,
371    #[serde(rename = "AnncmntDt", skip_serializing_if = "Option::is_none")]
372    pub anncmnt_dt: Option<IsoDateTime>,
373    #[serde(rename = "ISINVldFr", skip_serializing_if = "Option::is_none")]
374    pub isin_vld_fr: Option<IsoDate>,
375    #[serde(rename = "IssrOrg", skip_serializing_if = "Option::is_none")]
376    pub issr_org: Option<Organisation38>,
377    #[serde(rename = "IsseNmnlAmt", skip_serializing_if = "Option::is_none")]
378    pub isse_nmnl_amt: Option<FinancialInstrumentQuantity1Choice>,
379    #[serde(rename = "FullIssdAmt", skip_serializing_if = "Option::is_none")]
380    pub full_issd_amt: Option<ActiveCurrencyAndAmount>,
381    #[serde(rename = "IsseSz", skip_serializing_if = "Option::is_none")]
382    pub isse_sz: Option<Number>,
383    #[serde(rename = "IssePric", skip_serializing_if = "Option::is_none")]
384    pub isse_pric: Option<PriceValue1>,
385    #[serde(rename = "IssncDstrbtn", skip_serializing_if = "Option::is_none")]
386    pub issnc_dstrbtn: Option<SecuritiesTransactionType31Choice>,
387    #[validate(length(min = 0,))]
388    #[serde(rename = "GovngLaw", default)]
389    pub govng_law: Vec<Jurisdiction1>,
390}
391#[derive(
392    Debug,
393    Default,
394    Clone,
395    PartialEq,
396    ::serde::Serialize,
397    ::serde::Deserialize,
398    ::derive_builder::Builder,
399    ::validator::Validate,
400)]
401pub struct CommunicationAddress3 {
402    #[serde(rename = "Email", skip_serializing_if = "Option::is_none")]
403    pub email: Option<Max256Text>,
404    #[serde(rename = "Phne", skip_serializing_if = "Option::is_none")]
405    pub phne: Option<PhoneNumber>,
406    #[serde(rename = "Mob", skip_serializing_if = "Option::is_none")]
407    pub mob: Option<PhoneNumber>,
408    #[serde(rename = "FaxNb", skip_serializing_if = "Option::is_none")]
409    pub fax_nb: Option<PhoneNumber>,
410    #[serde(rename = "TlxAdr", skip_serializing_if = "Option::is_none")]
411    pub tlx_adr: Option<Max35Text>,
412    #[serde(rename = "URLAdr", skip_serializing_if = "Option::is_none")]
413    pub url_adr: Option<Max256Text>,
414}
415#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
416pub enum FormOfSecurity1Code {
417    #[serde(rename = "BEAR")]
418    Bear,
419    #[serde(rename = "REGD")]
420    Regd,
421    #[default]
422    Unknown,
423}
424#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
425pub enum Operation1Code {
426    #[serde(rename = "TILL")]
427    Till,
428    #[serde(rename = "ORRR")]
429    Orrr,
430    #[serde(rename = "ANDD")]
431    Andd,
432    #[default]
433    Unknown,
434}
435#[derive(
436    Debug,
437    Default,
438    Clone,
439    PartialEq,
440    ::serde::Serialize,
441    ::serde::Deserialize,
442    ::derive_builder::Builder,
443    ::validator::Validate,
444)]
445pub struct SecurityIdentification39 {
446    #[serde(rename = "ISIN", skip_serializing_if = "Option::is_none")]
447    pub isin: Option<Isin2021Identifier>,
448    #[validate(length(min = 0,))]
449    #[serde(rename = "OthrId", default)]
450    pub othr_id: Vec<OtherIdentification1>,
451    #[serde(rename = "Desc", skip_serializing_if = "Option::is_none")]
452    pub desc: Option<Max140Text>,
453}
454#[derive(
455    Debug,
456    Default,
457    Clone,
458    PartialEq,
459    ::serde::Serialize,
460    ::serde::Deserialize,
461    ::derive_builder::Builder,
462    ::validator::Validate,
463)]
464pub struct ActiveOrHistoricCurrencyAnd13DecimalAmount {
465    #[serde(rename = "ActiveOrHistoricCurrencyAnd13DecimalAmount")]
466    pub value: ActiveOrHistoricCurrencyAnd13DecimalAmountSimpleType,
467    #[serde(rename = "@Ccy")]
468    pub ccy: ActiveOrHistoricCurrencyCode,
469}
470#[derive(
471    Debug,
472    Default,
473    Clone,
474    PartialEq,
475    ::serde::Serialize,
476    ::serde::Deserialize,
477    ::derive_builder::Builder,
478    ::validator::Validate,
479)]
480pub struct CallType3ChoiceEnum {
481    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
482    pub prtry: Option<GenericIdentification30>,
483    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
484    pub cd: Option<CallType1Code>,
485}
486#[derive(
487    Debug,
488    Default,
489    Clone,
490    PartialEq,
491    ::serde::Serialize,
492    ::serde::Deserialize,
493    ::derive_builder::Builder,
494    ::validator::Validate,
495)]
496pub struct CallType3Choice {
497    #[serde(flatten)]
498    pub value: CallType3ChoiceEnum,
499}
500#[derive(
501    Debug,
502    Default,
503    Clone,
504    PartialEq,
505    ::serde::Serialize,
506    ::serde::Deserialize,
507    ::derive_builder::Builder,
508    ::validator::Validate,
509)]
510pub struct DecimalNumber {
511    #[serde(rename = "$text")]
512    pub value: f64,
513}
514#[derive(
515    Debug,
516    Default,
517    Clone,
518    PartialEq,
519    ::serde::Serialize,
520    ::serde::Deserialize,
521    ::derive_builder::Builder,
522    ::validator::Validate,
523)]
524pub struct GenericIdentification36 {
525    #[validate]
526    #[serde(rename = "Id")]
527    pub id: Max35Text,
528    #[validate]
529    #[serde(rename = "Issr")]
530    pub issr: Max35Text,
531    #[serde(rename = "SchmeNm", skip_serializing_if = "Option::is_none")]
532    pub schme_nm: Option<Max35Text>,
533}
534#[derive(
535    Debug,
536    Default,
537    Clone,
538    PartialEq,
539    ::serde::Serialize,
540    ::serde::Deserialize,
541    ::derive_builder::Builder,
542    ::validator::Validate,
543)]
544pub struct Option15 {
545    #[serde(rename = "OptnSttlmStyle", skip_serializing_if = "Option::is_none")]
546    pub optn_sttlm_style: Option<SettleStyle2Choice>,
547    #[serde(rename = "ConvsDt", skip_serializing_if = "Option::is_none")]
548    pub convs_dt: Option<IsoDateTime>,
549    #[serde(rename = "StrkPric", skip_serializing_if = "Option::is_none")]
550    pub strk_pric: Option<Price8>,
551    #[serde(rename = "MinExrcblQty", skip_serializing_if = "Option::is_none")]
552    pub min_exrcbl_qty: Option<FinancialInstrumentQuantity1Choice>,
553    #[serde(rename = "ConvsPrd", skip_serializing_if = "Option::is_none")]
554    pub convs_prd: Option<DateTimePeriod1Choice>,
555    #[serde(rename = "OptnStyle", skip_serializing_if = "Option::is_none")]
556    pub optn_style: Option<OptionStyle1Choice>,
557    #[serde(rename = "OptnTp", skip_serializing_if = "Option::is_none")]
558    pub optn_tp: Option<OptionType8Choice>,
559    #[serde(rename = "StrkVal", skip_serializing_if = "Option::is_none")]
560    pub strk_val: Option<Number>,
561    #[serde(rename = "StrkMltplr", skip_serializing_if = "Option::is_none")]
562    pub strk_mltplr: Option<Number>,
563    #[serde(rename = "InstrmAssgnmtMtd", skip_serializing_if = "Option::is_none")]
564    pub instrm_assgnmt_mtd: Option<AssignmentMethod2Choice>,
565    #[serde(rename = "VrsnNb", skip_serializing_if = "Option::is_none")]
566    pub vrsn_nb: Option<Number>,
567    #[serde(rename = "XpryLctn", skip_serializing_if = "Option::is_none")]
568    pub xpry_lctn: Option<Max4AlphaNumericText>,
569    #[serde(rename = "Stdstn", skip_serializing_if = "Option::is_none")]
570    pub stdstn: Option<Standardisation3Choice>,
571    #[serde(rename = "TradgPtyRole", skip_serializing_if = "Option::is_none")]
572    pub tradg_pty_role: Option<OptionParty3Choice>,
573    #[serde(rename = "CtrctSz", skip_serializing_if = "Option::is_none")]
574    pub ctrct_sz: Option<BaseOneRate>,
575    #[validate(length(min = 0,))]
576    #[serde(rename = "AddtlUndrlygAttrbts", default)]
577    pub addtl_undrlyg_attrbts: Vec<UnderlyingAttributes4>,
578}
579#[derive(
580    Debug,
581    Default,
582    Clone,
583    PartialEq,
584    ::serde::Serialize,
585    ::serde::Deserialize,
586    ::derive_builder::Builder,
587    ::validator::Validate,
588)]
589pub struct PostalAddress1 {
590    #[serde(rename = "AdrTp", skip_serializing_if = "Option::is_none")]
591    pub adr_tp: Option<AddressType2Code>,
592    #[validate(length(min = 0, max = 5,))]
593    #[serde(rename = "AdrLine", default)]
594    pub adr_line: Vec<Max70Text>,
595    #[serde(rename = "StrtNm", skip_serializing_if = "Option::is_none")]
596    pub strt_nm: Option<Max70Text>,
597    #[serde(rename = "BldgNb", skip_serializing_if = "Option::is_none")]
598    pub bldg_nb: Option<Max16Text>,
599    #[serde(rename = "PstCd", skip_serializing_if = "Option::is_none")]
600    pub pst_cd: Option<Max16Text>,
601    #[serde(rename = "TwnNm", skip_serializing_if = "Option::is_none")]
602    pub twn_nm: Option<Max35Text>,
603    #[serde(rename = "CtrySubDvsn", skip_serializing_if = "Option::is_none")]
604    pub ctry_sub_dvsn: Option<Max35Text>,
605    #[serde(rename = "Ctry")]
606    pub ctry: CountryCode,
607}
608#[derive(
609    Debug,
610    Default,
611    Clone,
612    PartialEq,
613    ::serde::Serialize,
614    ::serde::Deserialize,
615    ::derive_builder::Builder,
616    ::validator::Validate,
617)]
618pub struct TimeUnit3ChoiceEnum {
619    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
620    pub cd: Option<TimeUnit1Code>,
621    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
622    pub prtry: Option<GenericIdentification30>,
623}
624#[derive(
625    Debug,
626    Default,
627    Clone,
628    PartialEq,
629    ::serde::Serialize,
630    ::serde::Deserialize,
631    ::derive_builder::Builder,
632    ::validator::Validate,
633)]
634pub struct TimeUnit3Choice {
635    #[serde(flatten)]
636    pub value: TimeUnit3ChoiceEnum,
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 PutType3ChoiceEnum {
649    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
650    pub cd: Option<PutType1Code>,
651    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
652    pub prtry: Option<GenericIdentification30>,
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 PutType3Choice {
665    #[serde(flatten)]
666    pub value: PutType3ChoiceEnum,
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 PriceValue1 {
679    #[validate]
680    #[serde(rename = "Amt")]
681    pub amt: ActiveCurrencyAnd13DecimalAmount,
682}
683#[derive(
684    Debug,
685    Default,
686    Clone,
687    PartialEq,
688    ::serde::Serialize,
689    ::serde::Deserialize,
690    ::derive_builder::Builder,
691    ::validator::Validate,
692)]
693pub struct Frequency35ChoiceEnum {
694    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
695    pub prtry: Option<GenericIdentification30>,
696    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
697    pub cd: Option<Frequency5Code>,
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 Frequency35Choice {
710    #[serde(flatten)]
711    pub value: Frequency35ChoiceEnum,
712}
713#[derive(
714    Debug,
715    Default,
716    Clone,
717    PartialEq,
718    ::serde::Serialize,
719    ::serde::Deserialize,
720    ::derive_builder::Builder,
721    ::validator::Validate,
722)]
723pub struct InvestorType3ChoiceEnum {
724    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
725    pub prtry: Option<GenericIdentification30>,
726    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
727    pub cd: Option<InvestorType1Code>,
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 InvestorType3Choice {
740    #[serde(flatten)]
741    pub value: InvestorType3ChoiceEnum,
742}
743#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
744pub enum TypeOfPrice1Code {
745    #[serde(rename = "AVER")]
746    Aver,
747    #[serde(rename = "AVOV")]
748    Avov,
749    #[serde(rename = "COMB")]
750    Comb,
751    #[serde(rename = "GREX")]
752    Grex,
753    #[serde(rename = "LIMI")]
754    Limi,
755    #[serde(rename = "NET2")]
756    Net2,
757    #[serde(rename = "NDIS")]
758    Ndis,
759    #[serde(rename = "NET1")]
760    Net1,
761    #[serde(rename = "NUND")]
762    Nund,
763    #[serde(rename = "NOGR")]
764    Nogr,
765    #[serde(rename = "PARV")]
766    Parv,
767    #[serde(rename = "RDAV")]
768    Rdav,
769    #[serde(rename = "STOP")]
770    Stop,
771    #[default]
772    Unknown,
773}
774#[derive(
775    Debug,
776    Default,
777    Clone,
778    PartialEq,
779    ::serde::Serialize,
780    ::serde::Deserialize,
781    ::derive_builder::Builder,
782    ::validator::Validate,
783)]
784pub struct PaymentDirectionIndicator {
785    #[serde(rename = "$text")]
786    pub value: bool,
787}
788#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
789pub enum AddressType1Code {
790    #[serde(rename = "HOME")]
791    Home,
792    #[serde(rename = "BIZZ")]
793    Bizz,
794    #[default]
795    Unknown,
796}
797#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
798pub enum GlobalNote1Code {
799    #[serde(rename = "NGNO")]
800    Ngno,
801    #[serde(rename = "CGNO")]
802    Cgno,
803    #[default]
804    Unknown,
805}
806#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
807pub enum SettlementType1Code {
808    #[serde(rename = "PRIN")]
809    Prin,
810    #[serde(rename = "NETO")]
811    Neto,
812    #[default]
813    Unknown,
814}
815#[derive(
816    Debug,
817    Default,
818    Clone,
819    PartialEq,
820    ::serde::Serialize,
821    ::serde::Deserialize,
822    ::derive_builder::Builder,
823    ::validator::Validate,
824)]
825pub struct AssignmentMethod2ChoiceEnum {
826    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
827    pub cd: Option<AssignmentMethod1Code>,
828    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
829    pub prtry: Option<GenericIdentification30>,
830}
831#[derive(
832    Debug,
833    Default,
834    Clone,
835    PartialEq,
836    ::serde::Serialize,
837    ::serde::Deserialize,
838    ::derive_builder::Builder,
839    ::validator::Validate,
840)]
841pub struct AssignmentMethod2Choice {
842    #[serde(flatten)]
843    pub value: AssignmentMethod2ChoiceEnum,
844}
845#[derive(
846    Debug,
847    Default,
848    Clone,
849    PartialEq,
850    ::serde::Serialize,
851    ::serde::Deserialize,
852    ::derive_builder::Builder,
853    ::validator::Validate,
854)]
855pub struct SettlementType3ChoiceEnum {
856    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
857    pub prtry: Option<GenericIdentification30>,
858    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
859    pub cd: Option<SettlementType1Code>,
860}
861#[derive(
862    Debug,
863    Default,
864    Clone,
865    PartialEq,
866    ::serde::Serialize,
867    ::serde::Deserialize,
868    ::derive_builder::Builder,
869    ::validator::Validate,
870)]
871pub struct SettlementType3Choice {
872    #[serde(flatten)]
873    pub value: SettlementType3ChoiceEnum,
874}
875#[derive(
876    Debug,
877    Default,
878    Clone,
879    PartialEq,
880    ::serde::Serialize,
881    ::serde::Deserialize,
882    ::derive_builder::Builder,
883    ::validator::Validate,
884)]
885pub struct YesNoIndicator {
886    #[serde(rename = "$text")]
887    pub value: bool,
888}
889#[derive(
890    Debug,
891    Default,
892    Clone,
893    PartialEq,
894    ::serde::Serialize,
895    ::serde::Deserialize,
896    ::derive_builder::Builder,
897    ::validator::Validate,
898)]
899pub struct TefraRules3ChoiceEnum {
900    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
901    pub cd: Option<TefraRules1Code>,
902    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
903    pub prtry: Option<GenericIdentification30>,
904}
905#[derive(
906    Debug,
907    Default,
908    Clone,
909    PartialEq,
910    ::serde::Serialize,
911    ::serde::Deserialize,
912    ::derive_builder::Builder,
913    ::validator::Validate,
914)]
915pub struct TefraRules3Choice {
916    #[serde(flatten)]
917    pub value: TefraRules3ChoiceEnum,
918}
919#[derive(
920    Debug,
921    Default,
922    Clone,
923    PartialEq,
924    ::serde::Serialize,
925    ::serde::Deserialize,
926    ::derive_builder::Builder,
927    ::validator::Validate,
928)]
929pub struct Future4 {
930    #[serde(rename = "CtrctSz", skip_serializing_if = "Option::is_none")]
931    pub ctrct_sz: Option<BaseOneRate>,
932    #[serde(rename = "ExrcPric", skip_serializing_if = "Option::is_none")]
933    pub exrc_pric: Option<Price8>,
934    #[serde(rename = "FutrDt", skip_serializing_if = "Option::is_none")]
935    pub futr_dt: Option<IsoDateTime>,
936    #[serde(rename = "MinSz", skip_serializing_if = "Option::is_none")]
937    pub min_sz: Option<ActiveCurrencyAndAmount>,
938    #[serde(rename = "UnitOfMeasr", skip_serializing_if = "Option::is_none")]
939    pub unit_of_measr: Option<UnitOfMeasure7Choice>,
940    #[serde(rename = "TmUnit", skip_serializing_if = "Option::is_none")]
941    pub tm_unit: Option<TimeUnit3Choice>,
942    #[validate(length(min = 0,))]
943    #[serde(rename = "AddtlUndrlygAttrbts", default)]
944    pub addtl_undrlyg_attrbts: Vec<UnderlyingAttributes4>,
945}
946#[derive(
947    Debug,
948    Default,
949    Clone,
950    PartialEq,
951    ::serde::Serialize,
952    ::serde::Deserialize,
953    ::derive_builder::Builder,
954    ::validator::Validate,
955)]
956pub struct TradeTransactionCondition7ChoiceEnum {
957    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
958    pub prtry: Option<GenericIdentification30>,
959    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
960    pub cd: Option<TradeTransactionCondition2Code>,
961}
962#[derive(
963    Debug,
964    Default,
965    Clone,
966    PartialEq,
967    ::serde::Serialize,
968    ::serde::Deserialize,
969    ::derive_builder::Builder,
970    ::validator::Validate,
971)]
972pub struct TradeTransactionCondition7Choice {
973    #[serde(flatten)]
974    pub value: TradeTransactionCondition7ChoiceEnum,
975}
976#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
977pub enum SecuritiesPaymentStatus1Code {
978    #[serde(rename = "FULL")]
979    Full,
980    #[serde(rename = "NILL")]
981    Nill,
982    #[serde(rename = "PART")]
983    Part,
984    #[default]
985    Unknown,
986}
987#[derive(
988    Debug,
989    Default,
990    Clone,
991    PartialEq,
992    ::serde::Serialize,
993    ::serde::Deserialize,
994    ::derive_builder::Builder,
995    ::validator::Validate,
996)]
997pub struct SettlementUnitType3ChoiceEnum {
998    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
999    pub prtry: Option<GenericIdentification30>,
1000    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
1001    pub cd: Option<SettlementUnitType1Code>,
1002}
1003#[derive(
1004    Debug,
1005    Default,
1006    Clone,
1007    PartialEq,
1008    ::serde::Serialize,
1009    ::serde::Deserialize,
1010    ::derive_builder::Builder,
1011    ::validator::Validate,
1012)]
1013pub struct SettlementUnitType3Choice {
1014    #[serde(flatten)]
1015    pub value: SettlementUnitType3ChoiceEnum,
1016}
1017#[derive(
1018    Debug,
1019    Default,
1020    Clone,
1021    PartialEq,
1022    ::serde::Serialize,
1023    ::serde::Deserialize,
1024    ::derive_builder::Builder,
1025    ::validator::Validate,
1026)]
1027pub struct GenericIdentification13 {
1028    #[validate]
1029    #[serde(rename = "Id")]
1030    pub id: Max4AlphaNumericText,
1031    #[serde(rename = "SchmeNm", skip_serializing_if = "Option::is_none")]
1032    pub schme_nm: Option<Max35Text>,
1033    #[validate]
1034    #[serde(rename = "Issr")]
1035    pub issr: Max35Text,
1036}
1037#[derive(
1038    Debug,
1039    Default,
1040    Clone,
1041    PartialEq,
1042    ::serde::Serialize,
1043    ::serde::Deserialize,
1044    ::derive_builder::Builder,
1045    ::validator::Validate,
1046)]
1047pub struct ActiveCurrencyAnd13DecimalAmountSimpleType {
1048    #[validate(range(min = 0,))]
1049    #[serde(rename = "$text")]
1050    pub value: f64,
1051}
1052#[derive(
1053    Debug,
1054    Default,
1055    Clone,
1056    PartialEq,
1057    ::serde::Serialize,
1058    ::serde::Deserialize,
1059    ::derive_builder::Builder,
1060    ::validator::Validate,
1061)]
1062pub struct SupplementaryData1<
1063    A: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
1064> {
1065    #[serde(rename = "PlcAndNm", skip_serializing_if = "Option::is_none")]
1066    pub plc_and_nm: Option<Max350Text>,
1067    #[validate]
1068    #[serde(rename = "Envlp")]
1069    pub envlp: SupplementaryDataEnvelope1<A>,
1070}
1071#[derive(
1072    Debug,
1073    Default,
1074    Clone,
1075    PartialEq,
1076    ::serde::Serialize,
1077    ::serde::Deserialize,
1078    ::derive_builder::Builder,
1079    ::validator::Validate,
1080)]
1081pub struct ClassificationType2 {
1082    #[serde(rename = "ClssfctnFinInstrm", skip_serializing_if = "Option::is_none")]
1083    pub clssfctn_fin_instrm: Option<CfiOct2015Identifier>,
1084    #[serde(rename = "FinInstrmPdctTpCd", skip_serializing_if = "Option::is_none")]
1085    pub fin_instrm_pdct_tp_cd: Option<ExternalFinancialInstrumentProductType1Code>,
1086    #[validate(length(min = 0,))]
1087    #[serde(rename = "AltrnClssfctn", default)]
1088    pub altrn_clssfctn: Vec<GenericIdentification36>,
1089}
1090#[derive(
1091    Debug,
1092    Default,
1093    Clone,
1094    PartialEq,
1095    ::serde::Serialize,
1096    ::serde::Deserialize,
1097    ::derive_builder::Builder,
1098    ::validator::Validate,
1099)]
1100pub struct ActiveCurrencyAndAmount {
1101    #[serde(rename = "ActiveCurrencyAndAmount")]
1102    pub value: ActiveCurrencyAndAmountSimpleType,
1103    #[serde(rename = "@Ccy")]
1104    pub ccy: ActiveCurrencyCode,
1105}
1106#[derive(
1107    Debug,
1108    Default,
1109    Clone,
1110    PartialEq,
1111    ::serde::Serialize,
1112    ::serde::Deserialize,
1113    ::derive_builder::Builder,
1114    ::validator::Validate,
1115)]
1116pub struct ExternalSecuritiesUpdateReason1Code {
1117    #[validate(length(min = 1, max = 4,))]
1118    #[serde(rename = "$text")]
1119    pub value: String,
1120}
1121#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1122pub enum TradeTransactionCondition2Code {
1123    #[serde(rename = "SPCC")]
1124    Spcc,
1125    #[serde(rename = "SECN")]
1126    Secn,
1127    #[serde(rename = "SEBN")]
1128    Sebn,
1129    #[serde(rename = "SCBN")]
1130    Scbn,
1131    #[serde(rename = "SCRT")]
1132    Scrt,
1133    #[serde(rename = "SERT")]
1134    Sert,
1135    #[serde(rename = "SCCR")]
1136    Sccr,
1137    #[serde(rename = "SECR")]
1138    Secr,
1139    #[serde(rename = "CAST")]
1140    Cast,
1141    #[serde(rename = "SPPR")]
1142    Sppr,
1143    #[serde(rename = "SPCU")]
1144    Spcu,
1145    #[serde(rename = "SPEX")]
1146    Spex,
1147    #[serde(rename = "GTDL")]
1148    Gtdl,
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 LeiIdentifier {
1163    #[validate(regex = "LEI_IDENTIFIER_REGEX")]
1164    #[serde(rename = "$text")]
1165    pub value: String,
1166}
1167#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1168pub enum CalculationType1Code {
1169    #[serde(rename = "AFTX")]
1170    Aftx,
1171    #[serde(rename = "ANNU")]
1172    Annu,
1173    #[serde(rename = "ISSU")]
1174    Issu,
1175    #[serde(rename = "AVMA")]
1176    Avma,
1177    #[serde(rename = "BOOK")]
1178    Book,
1179    #[serde(rename = "YTNC")]
1180    Ytnc,
1181    #[serde(rename = "CHCL")]
1182    Chcl,
1183    #[serde(rename = "CLOS")]
1184    Clos,
1185    #[serde(rename = "CMPD")]
1186    Cmpd,
1187    #[serde(rename = "CUYI")]
1188    Cuyi,
1189    #[serde(rename = "TRGR")]
1190    Trgr,
1191    #[serde(rename = "GVEQ")]
1192    Gveq,
1193    #[serde(rename = "FLAS")]
1194    Flas,
1195    #[serde(rename = "NVFL")]
1196    Nvfl,
1197    #[serde(rename = "LSCL")]
1198    Lscl,
1199    #[serde(rename = "LSMT")]
1200    Lsmt,
1201    #[serde(rename = "LSQR")]
1202    Lsqr,
1203    #[serde(rename = "LSYR")]
1204    Lsyr,
1205    #[serde(rename = "LGAL")]
1206    Lgal,
1207    #[serde(rename = "MARK")]
1208    Mark,
1209    #[serde(rename = "YTMA")]
1210    Ytma,
1211    #[serde(rename = "NXRF")]
1212    Nxrf,
1213    #[serde(rename = "PNAV")]
1214    Pnav,
1215    #[serde(rename = "NXPT")]
1216    Nxpt,
1217    #[serde(rename = "PRCL")]
1218    Prcl,
1219    #[serde(rename = "PRYL")]
1220    Pryl,
1221    #[serde(rename = "SEMI")]
1222    Semi,
1223    #[serde(rename = "SHLF")]
1224    Shlf,
1225    #[serde(rename = "SPLL")]
1226    Spll,
1227    #[serde(rename = "TXQV")]
1228    Txqv,
1229    #[serde(rename = "TTDT")]
1230    Ttdt,
1231    #[serde(rename = "TRYL")]
1232    Tryl,
1233    #[serde(rename = "WRST")]
1234    Wrst,
1235    #[default]
1236    Unknown,
1237}
1238#[derive(
1239    Debug,
1240    Default,
1241    Clone,
1242    PartialEq,
1243    ::serde::Serialize,
1244    ::serde::Deserialize,
1245    ::derive_builder::Builder,
1246    ::validator::Validate,
1247)]
1248pub struct InitialPhysicalForm4ChoiceEnum {
1249    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
1250    pub cd: Option<InitialPhysicalForm1Code>,
1251    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
1252    pub prtry: Option<GenericIdentification30>,
1253}
1254#[derive(
1255    Debug,
1256    Default,
1257    Clone,
1258    PartialEq,
1259    ::serde::Serialize,
1260    ::serde::Deserialize,
1261    ::derive_builder::Builder,
1262    ::validator::Validate,
1263)]
1264pub struct InitialPhysicalForm4Choice {
1265    #[serde(flatten)]
1266    pub value: InitialPhysicalForm4ChoiceEnum,
1267}
1268#[derive(
1269    Debug,
1270    Default,
1271    Clone,
1272    PartialEq,
1273    ::serde::Serialize,
1274    ::serde::Deserialize,
1275    ::derive_builder::Builder,
1276    ::validator::Validate,
1277)]
1278pub struct ActiveOrHistoricCurrencyCode {
1279    #[validate(regex = "ACTIVE_OR_HISTORIC_CURRENCY_CODE_REGEX")]
1280    #[serde(rename = "$text")]
1281    pub value: String,
1282}
1283#[derive(
1284    Debug,
1285    Default,
1286    Clone,
1287    PartialEq,
1288    ::serde::Serialize,
1289    ::serde::Deserialize,
1290    ::derive_builder::Builder,
1291    ::validator::Validate,
1292)]
1293pub struct FormOfSecurity8ChoiceEnum {
1294    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
1295    pub prtry: Option<GenericIdentification30>,
1296    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
1297    pub cd: Option<FormOfSecurity1Code>,
1298}
1299#[derive(
1300    Debug,
1301    Default,
1302    Clone,
1303    PartialEq,
1304    ::serde::Serialize,
1305    ::serde::Deserialize,
1306    ::derive_builder::Builder,
1307    ::validator::Validate,
1308)]
1309pub struct FormOfSecurity8Choice {
1310    #[serde(flatten)]
1311    pub value: FormOfSecurity8ChoiceEnum,
1312}
1313#[derive(
1314    Debug,
1315    Default,
1316    Clone,
1317    PartialEq,
1318    ::serde::Serialize,
1319    ::serde::Deserialize,
1320    ::derive_builder::Builder,
1321    ::validator::Validate,
1322)]
1323pub struct ActiveCurrencyAnd13DecimalAmount {
1324    #[serde(rename = "ActiveCurrencyAnd13DecimalAmount")]
1325    pub value: ActiveCurrencyAnd13DecimalAmountSimpleType,
1326    #[serde(rename = "@Ccy")]
1327    pub ccy: ActiveCurrencyCode,
1328}
1329#[derive(
1330    Debug,
1331    Default,
1332    Clone,
1333    PartialEq,
1334    ::serde::Serialize,
1335    ::serde::Deserialize,
1336    ::derive_builder::Builder,
1337    ::validator::Validate,
1338)]
1339pub struct WarrantStyle3ChoiceEnum {
1340    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
1341    pub prtry: Option<GenericIdentification30>,
1342    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
1343    pub cd: Option<WarrantStyle1Code>,
1344}
1345#[derive(
1346    Debug,
1347    Default,
1348    Clone,
1349    PartialEq,
1350    ::serde::Serialize,
1351    ::serde::Deserialize,
1352    ::derive_builder::Builder,
1353    ::validator::Validate,
1354)]
1355pub struct WarrantStyle3Choice {
1356    #[serde(flatten)]
1357    pub value: WarrantStyle3ChoiceEnum,
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 UnitOrFaceAmount1ChoiceEnum {
1370    #[serde(rename = "Unit", skip_serializing_if = "Option::is_none")]
1371    pub unit: Option<DecimalNumber>,
1372    #[serde(rename = "FaceAmt", skip_serializing_if = "Option::is_none")]
1373    pub face_amt: Option<ActiveCurrencyAndAmount>,
1374}
1375#[derive(
1376    Debug,
1377    Default,
1378    Clone,
1379    PartialEq,
1380    ::serde::Serialize,
1381    ::serde::Deserialize,
1382    ::derive_builder::Builder,
1383    ::validator::Validate,
1384)]
1385pub struct UnitOrFaceAmount1Choice {
1386    #[serde(flatten)]
1387    pub value: UnitOrFaceAmount1ChoiceEnum,
1388}
1389#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1390pub enum SecuritiesTransactionType11Code {
1391    #[serde(rename = "NSYN")]
1392    Nsyn,
1393    #[serde(rename = "SYND")]
1394    Synd,
1395    #[default]
1396    Unknown,
1397}
1398#[derive(
1399    Debug,
1400    Default,
1401    Clone,
1402    PartialEq,
1403    ::serde::Serialize,
1404    ::serde::Deserialize,
1405    ::derive_builder::Builder,
1406    ::validator::Validate,
1407)]
1408pub struct CfiOct2015Identifier {
1409    #[validate(regex = "CFI_OCT_2015_IDENTIFIER_REGEX")]
1410    #[serde(rename = "$text")]
1411    pub value: String,
1412}
1413#[derive(
1414    Debug,
1415    Default,
1416    Clone,
1417    PartialEq,
1418    ::serde::Serialize,
1419    ::serde::Deserialize,
1420    ::derive_builder::Builder,
1421    ::validator::Validate,
1422)]
1423pub struct IsoYearMonth {
1424    #[validate(regex = "ISO_YEAR_MONTH_REGEX")]
1425    #[serde(rename = "$text")]
1426    pub value: String,
1427}
1428#[derive(
1429    Debug,
1430    Default,
1431    Clone,
1432    PartialEq,
1433    ::serde::Serialize,
1434    ::serde::Deserialize,
1435    ::derive_builder::Builder,
1436    ::validator::Validate,
1437)]
1438pub struct PreferenceToIncome5ChoiceEnum {
1439    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
1440    pub prtry: Option<GenericIdentification30>,
1441    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
1442    pub cd: Option<PreferenceToIncome1Code>,
1443}
1444#[derive(
1445    Debug,
1446    Default,
1447    Clone,
1448    PartialEq,
1449    ::serde::Serialize,
1450    ::serde::Deserialize,
1451    ::derive_builder::Builder,
1452    ::validator::Validate,
1453)]
1454pub struct PreferenceToIncome5Choice {
1455    #[serde(flatten)]
1456    pub value: PreferenceToIncome5ChoiceEnum,
1457}
1458#[derive(
1459    Debug,
1460    Default,
1461    Clone,
1462    PartialEq,
1463    ::serde::Serialize,
1464    ::serde::Deserialize,
1465    ::derive_builder::Builder,
1466    ::validator::Validate,
1467)]
1468pub struct PercentageRate {
1469    #[serde(rename = "$text")]
1470    pub value: f64,
1471}
1472#[derive(
1473    Debug,
1474    Default,
1475    Clone,
1476    PartialEq,
1477    ::serde::Serialize,
1478    ::serde::Deserialize,
1479    ::derive_builder::Builder,
1480    ::validator::Validate,
1481)]
1482pub struct RateOrAbsoluteValue1ChoiceEnum {
1483    #[serde(rename = "AbsVal", skip_serializing_if = "Option::is_none")]
1484    pub abs_val: Option<Number>,
1485    #[serde(rename = "RateVal", skip_serializing_if = "Option::is_none")]
1486    pub rate_val: Option<PercentageRate>,
1487}
1488#[derive(
1489    Debug,
1490    Default,
1491    Clone,
1492    PartialEq,
1493    ::serde::Serialize,
1494    ::serde::Deserialize,
1495    ::derive_builder::Builder,
1496    ::validator::Validate,
1497)]
1498pub struct RateOrAbsoluteValue1Choice {
1499    #[serde(flatten)]
1500    pub value: RateOrAbsoluteValue1ChoiceEnum,
1501}
1502#[derive(
1503    Debug,
1504    Default,
1505    Clone,
1506    PartialEq,
1507    ::serde::Serialize,
1508    ::serde::Deserialize,
1509    ::derive_builder::Builder,
1510    ::validator::Validate,
1511)]
1512pub struct AmountOrPercentageRange1 {
1513    #[serde(rename = "Opr", skip_serializing_if = "Option::is_none")]
1514    pub opr: Option<Operation1Code>,
1515    #[validate(length(min = 0, max = 10,))]
1516    #[serde(rename = "Term", default)]
1517    pub term: Vec<Term1>,
1518}
1519#[derive(
1520    Debug,
1521    Default,
1522    Clone,
1523    PartialEq,
1524    ::serde::Serialize,
1525    ::serde::Deserialize,
1526    ::derive_builder::Builder,
1527    ::validator::Validate,
1528)]
1529pub struct DistributionPolicy2ChoiceEnum {
1530    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
1531    pub cd: Option<DistributionPolicy1Code>,
1532    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
1533    pub prtry: Option<GenericIdentification30>,
1534}
1535#[derive(
1536    Debug,
1537    Default,
1538    Clone,
1539    PartialEq,
1540    ::serde::Serialize,
1541    ::serde::Deserialize,
1542    ::derive_builder::Builder,
1543    ::validator::Validate,
1544)]
1545pub struct DistributionPolicy2Choice {
1546    #[serde(flatten)]
1547    pub value: DistributionPolicy2ChoiceEnum,
1548}
1549#[derive(
1550    Debug,
1551    Default,
1552    Clone,
1553    PartialEq,
1554    ::serde::Serialize,
1555    ::serde::Deserialize,
1556    ::derive_builder::Builder,
1557    ::validator::Validate,
1558)]
1559#[serde(rename = "Document")]
1560pub struct Document<
1561    A: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
1562    B: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
1563    C: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
1564    D: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
1565    E: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
1566> {
1567    #[validate]
1568    #[serde(rename = "SctyMntncReq")]
1569    pub scty_mntnc_req: SecurityMaintenanceRequestV01<A, B, C, D, E>,
1570    #[serde(rename = "@xmlns", default = "namespace")]
1571    pub xmlns: String,
1572}
1573#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1574pub enum RestrictionType1Code {
1575    #[serde(rename = "SELR")]
1576    Selr,
1577    #[serde(rename = "BUYR")]
1578    Buyr,
1579    #[serde(rename = "PLAR")]
1580    Plar,
1581    #[serde(rename = "HOLR")]
1582    Holr,
1583    #[serde(rename = "VOTR")]
1584    Votr,
1585    #[default]
1586    Unknown,
1587}
1588#[derive(
1589    Debug,
1590    Default,
1591    Clone,
1592    PartialEq,
1593    ::serde::Serialize,
1594    ::serde::Deserialize,
1595    ::derive_builder::Builder,
1596    ::validator::Validate,
1597)]
1598pub struct ExternalFinancialInstrumentIdentificationType1Code {
1599    #[validate(length(min = 1, max = 4,))]
1600    #[serde(rename = "$text")]
1601    pub value: String,
1602}
1603#[derive(
1604    Debug,
1605    Default,
1606    Clone,
1607    PartialEq,
1608    ::serde::Serialize,
1609    ::serde::Deserialize,
1610    ::derive_builder::Builder,
1611    ::validator::Validate,
1612)]
1613pub struct Max256Text {
1614    #[validate(length(min = 1, max = 256,))]
1615    #[serde(rename = "$text")]
1616    pub value: String,
1617}
1618#[derive(
1619    Debug,
1620    Default,
1621    Clone,
1622    PartialEq,
1623    ::serde::Serialize,
1624    ::serde::Deserialize,
1625    ::derive_builder::Builder,
1626    ::validator::Validate,
1627)]
1628pub struct FinancialInstrumentQuantity1ChoiceEnum {
1629    #[serde(rename = "AmtsdVal", skip_serializing_if = "Option::is_none")]
1630    pub amtsd_val: Option<ImpliedCurrencyAndAmount>,
1631    #[serde(rename = "Unit", skip_serializing_if = "Option::is_none")]
1632    pub unit: Option<DecimalNumber>,
1633    #[serde(rename = "FaceAmt", skip_serializing_if = "Option::is_none")]
1634    pub face_amt: Option<ImpliedCurrencyAndAmount>,
1635}
1636#[derive(
1637    Debug,
1638    Default,
1639    Clone,
1640    PartialEq,
1641    ::serde::Serialize,
1642    ::serde::Deserialize,
1643    ::derive_builder::Builder,
1644    ::validator::Validate,
1645)]
1646pub struct FinancialInstrumentQuantity1Choice {
1647    #[serde(flatten)]
1648    pub value: FinancialInstrumentQuantity1ChoiceEnum,
1649}
1650#[derive(
1651    Debug,
1652    Default,
1653    Clone,
1654    PartialEq,
1655    ::serde::Serialize,
1656    ::serde::Deserialize,
1657    ::derive_builder::Builder,
1658    ::validator::Validate,
1659)]
1660pub struct LegalRestrictions4ChoiceEnum {
1661    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
1662    pub cd: Option<LegalRestrictions1Code>,
1663    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
1664    pub prtry: Option<GenericIdentification30>,
1665}
1666#[derive(
1667    Debug,
1668    Default,
1669    Clone,
1670    PartialEq,
1671    ::serde::Serialize,
1672    ::serde::Deserialize,
1673    ::derive_builder::Builder,
1674    ::validator::Validate,
1675)]
1676pub struct LegalRestrictions4Choice {
1677    #[serde(flatten)]
1678    pub value: LegalRestrictions4ChoiceEnum,
1679}
1680#[derive(
1681    Debug,
1682    Default,
1683    Clone,
1684    PartialEq,
1685    ::serde::Serialize,
1686    ::serde::Deserialize,
1687    ::derive_builder::Builder,
1688    ::validator::Validate,
1689)]
1690pub struct SecuritiesTransactionType31ChoiceEnum {
1691    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
1692    pub cd: Option<SecuritiesTransactionType11Code>,
1693    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
1694    pub prtry: Option<GenericIdentification30>,
1695}
1696#[derive(
1697    Debug,
1698    Default,
1699    Clone,
1700    PartialEq,
1701    ::serde::Serialize,
1702    ::serde::Deserialize,
1703    ::derive_builder::Builder,
1704    ::validator::Validate,
1705)]
1706pub struct SecuritiesTransactionType31Choice {
1707    #[serde(flatten)]
1708    pub value: SecuritiesTransactionType31ChoiceEnum,
1709}
1710#[derive(
1711    Debug,
1712    Default,
1713    Clone,
1714    PartialEq,
1715    ::serde::Serialize,
1716    ::serde::Deserialize,
1717    ::derive_builder::Builder,
1718    ::validator::Validate,
1719)]
1720pub struct RateAndAmountFormat1ChoiceEnum {
1721    #[serde(rename = "NotSpcfdRate", skip_serializing_if = "Option::is_none")]
1722    pub not_spcfd_rate: Option<RateType12FormatChoice>,
1723    #[serde(rename = "Rate", skip_serializing_if = "Option::is_none")]
1724    pub rate: Option<PercentageRate>,
1725    #[serde(rename = "Amt", skip_serializing_if = "Option::is_none")]
1726    pub amt: Option<ActiveCurrencyAndAmount>,
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 RateAndAmountFormat1Choice {
1739    #[serde(flatten)]
1740    pub value: RateAndAmountFormat1ChoiceEnum,
1741}
1742#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1743pub enum InitialPhysicalForm2Code {
1744    #[serde(rename = "GPGP")]
1745    Gpgp,
1746    #[serde(rename = "DERN")]
1747    Dern,
1748    #[default]
1749    Unknown,
1750}
1751#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1752pub enum UnitOfMeasure9Code {
1753    #[serde(rename = "BAGG")]
1754    Bagg,
1755    #[serde(rename = "BALE")]
1756    Bale,
1757    #[serde(rename = "BOTL")]
1758    Botl,
1759    #[serde(rename = "BOXX")]
1760    Boxx,
1761    #[serde(rename = "CRTN")]
1762    Crtn,
1763    #[serde(rename = "CELI")]
1764    Celi,
1765    #[serde(rename = "CMET")]
1766    Cmet,
1767    #[serde(rename = "CNTR")]
1768    Cntr,
1769    #[serde(rename = "CRAT")]
1770    Crat,
1771    #[serde(rename = "CBIN")]
1772    Cbin,
1773    #[serde(rename = "CBME")]
1774    Cbme,
1775    #[serde(rename = "CBML")]
1776    Cbml,
1777    #[serde(rename = "PIEC")]
1778    Piec,
1779    #[serde(rename = "FOOT")]
1780    Foot,
1781    #[serde(rename = "GBFO")]
1782    Gbfo,
1783    #[serde(rename = "GBGA")]
1784    Gbga,
1785    #[serde(rename = "GBPI")]
1786    Gbpi,
1787    #[serde(rename = "GBQA")]
1788    Gbqa,
1789    #[serde(rename = "GBTN")]
1790    Gbtn,
1791    #[serde(rename = "GRAM")]
1792    Gram,
1793    #[serde(rename = "INCH")]
1794    Inch,
1795    #[serde(rename = "KILO")]
1796    Kilo,
1797    #[serde(rename = "KMET")]
1798    Kmet,
1799    #[serde(rename = "LITR")]
1800    Litr,
1801    #[serde(rename = "METR")]
1802    Metr,
1803    #[serde(rename = "TONE")]
1804    Tone,
1805    #[serde(rename = "MILE")]
1806    Mile,
1807    #[serde(rename = "MMET")]
1808    Mmet,
1809    #[serde(rename = "MILI")]
1810    Mili,
1811    #[serde(rename = "PUND")]
1812    Pund,
1813    #[serde(rename = "USOU")]
1814    Usou,
1815    #[serde(rename = "SCMT")]
1816    Scmt,
1817    #[serde(rename = "SQFO")]
1818    Sqfo,
1819    #[serde(rename = "SQIN")]
1820    Sqin,
1821    #[serde(rename = "SQKI")]
1822    Sqki,
1823    #[serde(rename = "SMET")]
1824    Smet,
1825    #[serde(rename = "SQMI")]
1826    Sqmi,
1827    #[serde(rename = "SMIL")]
1828    Smil,
1829    #[serde(rename = "SQYA")]
1830    Sqya,
1831    #[serde(rename = "USBA")]
1832    Usba,
1833    #[serde(rename = "USFO")]
1834    Usfo,
1835    #[serde(rename = "USGA")]
1836    Usga,
1837    #[serde(rename = "USPI")]
1838    Uspi,
1839    #[serde(rename = "USQA")]
1840    Usqa,
1841    #[serde(rename = "USTN")]
1842    Ustn,
1843    #[serde(rename = "YARD")]
1844    Yard,
1845    #[serde(rename = "GBOU")]
1846    Gbou,
1847    #[serde(rename = "ACRE")]
1848    Acre,
1849    #[serde(rename = "ARES")]
1850    Ares,
1851    #[serde(rename = "HECT")]
1852    Hect,
1853    #[default]
1854    Unknown,
1855}
1856#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1857pub enum MaturityRedemptionType1Code {
1858    #[serde(rename = "FRED")]
1859    Fred,
1860    #[serde(rename = "PRNR")]
1861    Prnr,
1862    #[serde(rename = "PRWR")]
1863    Prwr,
1864    #[serde(rename = "RNDM")]
1865    Rndm,
1866    #[serde(rename = "PRRA")]
1867    Prra,
1868    #[serde(rename = "CALL")]
1869    Call,
1870    #[serde(rename = "PUUT")]
1871    Puut,
1872    #[default]
1873    Unknown,
1874}
1875#[derive(
1876    Debug,
1877    Default,
1878    Clone,
1879    PartialEq,
1880    ::serde::Serialize,
1881    ::serde::Deserialize,
1882    ::derive_builder::Builder,
1883    ::validator::Validate,
1884)]
1885pub struct Max35Text {
1886    #[validate(length(min = 1, max = 35,))]
1887    #[serde(rename = "$text")]
1888    pub value: String,
1889}
1890#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
1891pub enum RateType12Code {
1892    #[serde(rename = "OPEN")]
1893    Open,
1894    #[serde(rename = "UKWN")]
1895    Ukwn,
1896    #[serde(rename = "NILP")]
1897    Nilp,
1898    #[default]
1899    Unknown,
1900}
1901#[derive(
1902    Debug,
1903    Default,
1904    Clone,
1905    PartialEq,
1906    ::serde::Serialize,
1907    ::serde::Deserialize,
1908    ::derive_builder::Builder,
1909    ::validator::Validate,
1910)]
1911pub struct SettleStyle2ChoiceEnum {
1912    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
1913    pub prtry: Option<GenericIdentification30>,
1914    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
1915    pub cd: Option<SettleStyle1Code>,
1916}
1917#[derive(
1918    Debug,
1919    Default,
1920    Clone,
1921    PartialEq,
1922    ::serde::Serialize,
1923    ::serde::Deserialize,
1924    ::derive_builder::Builder,
1925    ::validator::Validate,
1926)]
1927pub struct SettleStyle2Choice {
1928    #[serde(flatten)]
1929    pub value: SettleStyle2ChoiceEnum,
1930}
1931#[derive(
1932    Debug,
1933    Default,
1934    Clone,
1935    PartialEq,
1936    ::serde::Serialize,
1937    ::serde::Deserialize,
1938    ::derive_builder::Builder,
1939    ::validator::Validate,
1940)]
1941pub struct InitialPhysicalForm3ChoiceEnum {
1942    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
1943    pub cd: Option<InitialPhysicalForm2Code>,
1944    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
1945    pub prtry: Option<GenericIdentification30>,
1946}
1947#[derive(
1948    Debug,
1949    Default,
1950    Clone,
1951    PartialEq,
1952    ::serde::Serialize,
1953    ::serde::Deserialize,
1954    ::derive_builder::Builder,
1955    ::validator::Validate,
1956)]
1957pub struct InitialPhysicalForm3Choice {
1958    #[serde(flatten)]
1959    pub value: InitialPhysicalForm3ChoiceEnum,
1960}
1961#[derive(
1962    Debug,
1963    Default,
1964    Clone,
1965    PartialEq,
1966    ::serde::Serialize,
1967    ::serde::Deserialize,
1968    ::derive_builder::Builder,
1969    ::validator::Validate,
1970)]
1971pub struct DateTimePeriod1ChoiceEnum {
1972    #[serde(rename = "ToDtTm", skip_serializing_if = "Option::is_none")]
1973    pub to_dt_tm: Option<IsoDateTime>,
1974    #[serde(rename = "FrDtTm", skip_serializing_if = "Option::is_none")]
1975    pub fr_dt_tm: Option<IsoDateTime>,
1976    #[serde(rename = "DtTmRg", skip_serializing_if = "Option::is_none")]
1977    pub dt_tm_rg: Option<DateTimePeriod1>,
1978}
1979#[derive(
1980    Debug,
1981    Default,
1982    Clone,
1983    PartialEq,
1984    ::serde::Serialize,
1985    ::serde::Deserialize,
1986    ::derive_builder::Builder,
1987    ::validator::Validate,
1988)]
1989pub struct DateTimePeriod1Choice {
1990    #[serde(flatten)]
1991    pub value: DateTimePeriod1ChoiceEnum,
1992}
1993#[derive(
1994    Debug,
1995    Default,
1996    Clone,
1997    PartialEq,
1998    ::serde::Serialize,
1999    ::serde::Deserialize,
2000    ::derive_builder::Builder,
2001    ::validator::Validate,
2002)]
2003pub struct PartyIdentification177ChoiceEnum {
2004    #[serde(rename = "PrtryId", skip_serializing_if = "Option::is_none")]
2005    pub prtry_id: Option<GenericIdentification1>,
2006    #[serde(rename = "AnyBIC", skip_serializing_if = "Option::is_none")]
2007    pub any_bic: Option<AnyBicDec2014Identifier>,
2008}
2009#[derive(
2010    Debug,
2011    Default,
2012    Clone,
2013    PartialEq,
2014    ::serde::Serialize,
2015    ::serde::Deserialize,
2016    ::derive_builder::Builder,
2017    ::validator::Validate,
2018)]
2019pub struct PartyIdentification177Choice {
2020    #[serde(flatten)]
2021    pub value: PartyIdentification177ChoiceEnum,
2022}
2023#[derive(
2024    Debug,
2025    Default,
2026    Clone,
2027    PartialEq,
2028    ::serde::Serialize,
2029    ::serde::Deserialize,
2030    ::derive_builder::Builder,
2031    ::validator::Validate,
2032)]
2033pub struct Appearance3ChoiceEnum {
2034    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
2035    pub cd: Option<Appearance1Code>,
2036    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
2037    pub prtry: Option<GenericIdentification30>,
2038}
2039#[derive(
2040    Debug,
2041    Default,
2042    Clone,
2043    PartialEq,
2044    ::serde::Serialize,
2045    ::serde::Deserialize,
2046    ::derive_builder::Builder,
2047    ::validator::Validate,
2048)]
2049pub struct Appearance3Choice {
2050    #[serde(flatten)]
2051    pub value: Appearance3ChoiceEnum,
2052}
2053#[derive(
2054    Debug,
2055    Default,
2056    Clone,
2057    PartialEq,
2058    ::serde::Serialize,
2059    ::serde::Deserialize,
2060    ::derive_builder::Builder,
2061    ::validator::Validate,
2062)]
2063pub struct GenericIdentification1 {
2064    #[validate]
2065    #[serde(rename = "Id")]
2066    pub id: Max35Text,
2067    #[serde(rename = "SchmeNm", skip_serializing_if = "Option::is_none")]
2068    pub schme_nm: Option<Max35Text>,
2069    #[serde(rename = "Issr", skip_serializing_if = "Option::is_none")]
2070    pub issr: Option<Max35Text>,
2071}
2072#[derive(
2073    Debug,
2074    Default,
2075    Clone,
2076    PartialEq,
2077    ::serde::Serialize,
2078    ::serde::Deserialize,
2079    ::derive_builder::Builder,
2080    ::validator::Validate,
2081)]
2082pub struct Jurisdiction1 {
2083    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
2084    pub id: Option<Max70Text>,
2085    #[serde(rename = "Ctry", skip_serializing_if = "Option::is_none")]
2086    pub ctry: Option<CountryCode>,
2087}
2088#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2089pub enum DistributionPolicy1Code {
2090    #[serde(rename = "DIST")]
2091    Dist,
2092    #[serde(rename = "ACCU")]
2093    Accu,
2094    #[default]
2095    Unknown,
2096}
2097#[derive(
2098    Debug,
2099    Default,
2100    Clone,
2101    PartialEq,
2102    ::serde::Serialize,
2103    ::serde::Deserialize,
2104    ::derive_builder::Builder,
2105    ::validator::Validate,
2106)]
2107pub struct Max15NumericText {
2108    #[validate(regex = "MAX_15_NUMERIC_TEXT_REGEX")]
2109    #[serde(rename = "$text")]
2110    pub value: String,
2111}
2112#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2113pub enum AssignmentMethod1Code {
2114    #[serde(rename = "RAND")]
2115    Rand,
2116    #[serde(rename = "PROR")]
2117    Pror,
2118    #[default]
2119    Unknown,
2120}
2121#[derive(
2122    Debug,
2123    Default,
2124    Clone,
2125    PartialEq,
2126    ::serde::Serialize,
2127    ::serde::Deserialize,
2128    ::derive_builder::Builder,
2129    ::validator::Validate,
2130)]
2131pub struct GenericIdentification30 {
2132    #[validate]
2133    #[serde(rename = "Id")]
2134    pub id: Exact4AlphaNumericText,
2135    #[validate]
2136    #[serde(rename = "Issr")]
2137    pub issr: Max35Text,
2138    #[serde(rename = "SchmeNm", skip_serializing_if = "Option::is_none")]
2139    pub schme_nm: Option<Max35Text>,
2140}
2141#[derive(
2142    Debug,
2143    Default,
2144    Clone,
2145    PartialEq,
2146    ::serde::Serialize,
2147    ::serde::Deserialize,
2148    ::derive_builder::Builder,
2149    ::validator::Validate,
2150)]
2151pub struct RateType12FormatChoiceEnum {
2152    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
2153    pub prtry: Option<GenericIdentification13>,
2154    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
2155    pub cd: Option<RateType12Code>,
2156}
2157#[derive(
2158    Debug,
2159    Default,
2160    Clone,
2161    PartialEq,
2162    ::serde::Serialize,
2163    ::serde::Deserialize,
2164    ::derive_builder::Builder,
2165    ::validator::Validate,
2166)]
2167pub struct RateType12FormatChoice {
2168    #[serde(flatten)]
2169    pub value: RateType12FormatChoiceEnum,
2170}
2171#[derive(
2172    Debug,
2173    Default,
2174    Clone,
2175    PartialEq,
2176    ::serde::Serialize,
2177    ::serde::Deserialize,
2178    ::derive_builder::Builder,
2179    ::validator::Validate,
2180)]
2181pub struct SecurityStatus3ChoiceEnum {
2182    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
2183    pub cd: Option<SecurityStatus2Code>,
2184    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
2185    pub prtry: Option<GenericIdentification30>,
2186}
2187#[derive(
2188    Debug,
2189    Default,
2190    Clone,
2191    PartialEq,
2192    ::serde::Serialize,
2193    ::serde::Deserialize,
2194    ::derive_builder::Builder,
2195    ::validator::Validate,
2196)]
2197pub struct SecurityStatus3Choice {
2198    #[serde(flatten)]
2199    pub value: SecurityStatus3ChoiceEnum,
2200}
2201#[derive(
2202    Debug,
2203    Default,
2204    Clone,
2205    PartialEq,
2206    ::serde::Serialize,
2207    ::serde::Deserialize,
2208    ::derive_builder::Builder,
2209    ::validator::Validate,
2210)]
2211pub struct CountryCode {
2212    #[validate(regex = "COUNTRY_CODE_REGEX")]
2213    #[serde(rename = "$text")]
2214    pub value: String,
2215}
2216#[derive(
2217    Debug,
2218    Default,
2219    Clone,
2220    PartialEq,
2221    ::serde::Serialize,
2222    ::serde::Deserialize,
2223    ::derive_builder::Builder,
2224    ::validator::Validate,
2225)]
2226pub struct DateTimePeriod1 {
2227    #[validate]
2228    #[serde(rename = "FrDtTm")]
2229    pub fr_dt_tm: IsoDateTime,
2230    #[validate]
2231    #[serde(rename = "ToDtTm")]
2232    pub to_dt_tm: IsoDateTime,
2233}
2234#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2235pub enum Standardisation1Code {
2236    #[serde(rename = "FLEX")]
2237    Flex,
2238    #[serde(rename = "NSTA")]
2239    Nsta,
2240    #[serde(rename = "STAN")]
2241    Stan,
2242    #[default]
2243    Unknown,
2244}
2245#[derive(
2246    Debug,
2247    Default,
2248    Clone,
2249    PartialEq,
2250    ::serde::Serialize,
2251    ::serde::Deserialize,
2252    ::derive_builder::Builder,
2253    ::validator::Validate,
2254)]
2255pub struct Standardisation3ChoiceEnum {
2256    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
2257    pub prtry: Option<GenericIdentification30>,
2258    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
2259    pub cd: Option<Standardisation1Code>,
2260}
2261#[derive(
2262    Debug,
2263    Default,
2264    Clone,
2265    PartialEq,
2266    ::serde::Serialize,
2267    ::serde::Deserialize,
2268    ::derive_builder::Builder,
2269    ::validator::Validate,
2270)]
2271pub struct Standardisation3Choice {
2272    #[serde(flatten)]
2273    pub value: Standardisation3ChoiceEnum,
2274}
2275#[derive(
2276    Debug,
2277    Default,
2278    Clone,
2279    PartialEq,
2280    ::serde::Serialize,
2281    ::serde::Deserialize,
2282    ::derive_builder::Builder,
2283    ::validator::Validate,
2284)]
2285pub struct InstrumentSubStructureType2ChoiceEnum {
2286    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
2287    pub prtry: Option<GenericIdentification30>,
2288    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
2289    pub cd: Option<InstrumentSubStructureType1Code>,
2290}
2291#[derive(
2292    Debug,
2293    Default,
2294    Clone,
2295    PartialEq,
2296    ::serde::Serialize,
2297    ::serde::Deserialize,
2298    ::derive_builder::Builder,
2299    ::validator::Validate,
2300)]
2301pub struct InstrumentSubStructureType2Choice {
2302    #[serde(flatten)]
2303    pub value: InstrumentSubStructureType2ChoiceEnum,
2304}
2305#[derive(
2306    Debug,
2307    Default,
2308    Clone,
2309    PartialEq,
2310    ::serde::Serialize,
2311    ::serde::Deserialize,
2312    ::derive_builder::Builder,
2313    ::validator::Validate,
2314)]
2315pub struct UpdateType36ChoiceEnum<
2316    A: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
2317    B: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
2318    C: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
2319    D: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
2320> {
2321    #[serde(rename = "UpdTp", skip_serializing_if = "Option::is_none")]
2322    pub upd_tp: Option<UpdateType35Choice<A, B, C>>,
2323    #[serde(rename = "Rplc", skip_serializing_if = "Option::is_none")]
2324    pub rplc: Option<SecurityAttributes12<D>>,
2325}
2326#[derive(
2327    Debug,
2328    Default,
2329    Clone,
2330    PartialEq,
2331    ::serde::Serialize,
2332    ::serde::Deserialize,
2333    ::derive_builder::Builder,
2334    ::validator::Validate,
2335)]
2336pub struct UpdateType36Choice<
2337    A: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
2338    B: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
2339    C: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
2340    D: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
2341> {
2342    #[serde(flatten)]
2343    pub value: UpdateType36ChoiceEnum<A, B, C, D>,
2344}
2345#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2346pub enum LegalRestrictions1Code {
2347    #[serde(rename = "USLE")]
2348    Usle,
2349    #[serde(rename = "NORE")]
2350    Nore,
2351    #[serde(rename = "REST")]
2352    Rest,
2353    #[default]
2354    Unknown,
2355}
2356#[derive(
2357    Debug,
2358    Default,
2359    Clone,
2360    PartialEq,
2361    ::serde::Serialize,
2362    ::serde::Deserialize,
2363    ::derive_builder::Builder,
2364    ::validator::Validate,
2365)]
2366pub struct FinancialInstrumentForm2 {
2367    #[serde(rename = "BookgApprnc", skip_serializing_if = "Option::is_none")]
2368    pub bookg_apprnc: Option<Appearance3Choice>,
2369    #[serde(rename = "LglForm", skip_serializing_if = "Option::is_none")]
2370    pub lgl_form: Option<FormOfSecurity8Choice>,
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 AnyBicDec2014Identifier {
2383    #[validate(regex = "ANY_BIC_DEC_2014_IDENTIFIER_REGEX")]
2384    #[serde(rename = "$text")]
2385    pub value: String,
2386}
2387#[derive(
2388    Debug,
2389    Default,
2390    Clone,
2391    PartialEq,
2392    ::serde::Serialize,
2393    ::serde::Deserialize,
2394    ::derive_builder::Builder,
2395    ::validator::Validate,
2396)]
2397pub struct ExternalFinancialInstrumentProductType1Code {
2398    #[validate(length(min = 1, max = 4,))]
2399    #[serde(rename = "$text")]
2400    pub value: String,
2401}
2402#[derive(
2403    Debug,
2404    Default,
2405    Clone,
2406    PartialEq,
2407    ::serde::Serialize,
2408    ::serde::Deserialize,
2409    ::derive_builder::Builder,
2410    ::validator::Validate,
2411)]
2412pub struct InvestorRestrictionType3ChoiceEnum {
2413    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
2414    pub prtry: Option<GenericIdentification30>,
2415    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
2416    pub cd: Option<InvestorRestrictionType1Code>,
2417}
2418#[derive(
2419    Debug,
2420    Default,
2421    Clone,
2422    PartialEq,
2423    ::serde::Serialize,
2424    ::serde::Deserialize,
2425    ::derive_builder::Builder,
2426    ::validator::Validate,
2427)]
2428pub struct InvestorRestrictionType3Choice {
2429    #[serde(flatten)]
2430    pub value: InvestorRestrictionType3ChoiceEnum,
2431}
2432#[derive(
2433    Debug,
2434    Default,
2435    Clone,
2436    PartialEq,
2437    ::serde::Serialize,
2438    ::serde::Deserialize,
2439    ::derive_builder::Builder,
2440    ::validator::Validate,
2441)]
2442pub struct Max4AlphaNumericText {
2443    #[validate(length(min = 1, max = 4,), regex = "MAX_4_ALPHA_NUMERIC_TEXT_REGEX")]
2444    #[serde(rename = "$text")]
2445    pub value: String,
2446}
2447#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2448pub enum PreferenceToIncome1Code {
2449    #[serde(rename = "ORDN")]
2450    Ordn,
2451    #[serde(rename = "PFRD")]
2452    Pfrd,
2453    #[default]
2454    Unknown,
2455}
2456#[derive(
2457    Debug,
2458    Default,
2459    Clone,
2460    PartialEq,
2461    ::serde::Serialize,
2462    ::serde::Deserialize,
2463    ::derive_builder::Builder,
2464    ::validator::Validate,
2465)]
2466pub struct ActiveCurrencyCode {
2467    #[validate(regex = "ACTIVE_CURRENCY_CODE_REGEX")]
2468    #[serde(rename = "$text")]
2469    pub value: String,
2470}
2471#[derive(
2472    Debug,
2473    Default,
2474    Clone,
2475    PartialEq,
2476    ::serde::Serialize,
2477    ::serde::Deserialize,
2478    ::derive_builder::Builder,
2479    ::validator::Validate,
2480)]
2481pub struct SecurityRestrictionType2ChoiceEnum {
2482    #[serde(rename = "PrtryRstrctn", skip_serializing_if = "Option::is_none")]
2483    pub prtry_rstrctn: Option<GenericIdentification30>,
2484    #[serde(rename = "RstrctnTp", skip_serializing_if = "Option::is_none")]
2485    pub rstrctn_tp: Option<RestrictionType1Code>,
2486}
2487#[derive(
2488    Debug,
2489    Default,
2490    Clone,
2491    PartialEq,
2492    ::serde::Serialize,
2493    ::serde::Deserialize,
2494    ::derive_builder::Builder,
2495    ::validator::Validate,
2496)]
2497pub struct SecurityRestrictionType2Choice {
2498    #[serde(flatten)]
2499    pub value: SecurityRestrictionType2ChoiceEnum,
2500}
2501#[derive(
2502    Debug,
2503    Default,
2504    Clone,
2505    PartialEq,
2506    ::serde::Serialize,
2507    ::serde::Deserialize,
2508    ::derive_builder::Builder,
2509    ::validator::Validate,
2510)]
2511pub struct UnitOfMeasure7ChoiceEnum {
2512    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
2513    pub prtry: Option<GenericIdentification30>,
2514    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
2515    pub cd: Option<UnitOfMeasure9Code>,
2516}
2517#[derive(
2518    Debug,
2519    Default,
2520    Clone,
2521    PartialEq,
2522    ::serde::Serialize,
2523    ::serde::Deserialize,
2524    ::derive_builder::Builder,
2525    ::validator::Validate,
2526)]
2527pub struct UnitOfMeasure7Choice {
2528    #[serde(flatten)]
2529    pub value: UnitOfMeasure7ChoiceEnum,
2530}
2531#[derive(
2532    Debug,
2533    Default,
2534    Clone,
2535    PartialEq,
2536    ::serde::Serialize,
2537    ::serde::Deserialize,
2538    ::derive_builder::Builder,
2539    ::validator::Validate,
2540)]
2541pub struct BenchmarkCurveName7ChoiceEnum {
2542    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
2543    pub cd: Option<BenchmarkCurveName1Code>,
2544    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
2545    pub prtry: Option<GenericIdentification30>,
2546}
2547#[derive(
2548    Debug,
2549    Default,
2550    Clone,
2551    PartialEq,
2552    ::serde::Serialize,
2553    ::serde::Deserialize,
2554    ::derive_builder::Builder,
2555    ::validator::Validate,
2556)]
2557pub struct BenchmarkCurveName7Choice {
2558    #[serde(flatten)]
2559    pub value: BenchmarkCurveName7ChoiceEnum,
2560}
2561#[derive(
2562    Debug,
2563    Default,
2564    Clone,
2565    PartialEq,
2566    ::serde::Serialize,
2567    ::serde::Deserialize,
2568    ::derive_builder::Builder,
2569    ::validator::Validate,
2570)]
2571pub struct SecurityMaintenanceRequestV01<
2572    A: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
2573    B: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
2574    C: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
2575    D: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
2576    E: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
2577> {
2578    #[serde(rename = "MsgHdr", skip_serializing_if = "Option::is_none")]
2579    pub msg_hdr: Option<MessageHeader1>,
2580    #[serde(rename = "UpdTp")]
2581    pub upd_tp: UpdateType36Choice<A, B, C, D>,
2582    #[serde(rename = "UpdRsn", skip_serializing_if = "Option::is_none")]
2583    pub upd_rsn: Option<SecuritiesUpdateReason1Choice>,
2584    #[validate]
2585    #[serde(rename = "FinInstrmId")]
2586    pub fin_instrm_id: SecurityIdentification39,
2587    #[validate(length(min = 0,))]
2588    #[serde(rename = "SplmtryData", default)]
2589    pub splmtry_data: Vec<SupplementaryData1<E>>,
2590}
2591#[derive(
2592    Debug,
2593    Default,
2594    Clone,
2595    PartialEq,
2596    ::serde::Serialize,
2597    ::serde::Deserialize,
2598    ::derive_builder::Builder,
2599    ::validator::Validate,
2600)]
2601pub struct ActiveOrHistoricCurrencyAnd13DecimalAmountSimpleType {
2602    #[validate(range(min = 0,))]
2603    #[serde(rename = "$text")]
2604    pub value: f64,
2605}
2606#[derive(
2607    Debug,
2608    Default,
2609    Clone,
2610    PartialEq,
2611    ::serde::Serialize,
2612    ::serde::Deserialize,
2613    ::derive_builder::Builder,
2614    ::validator::Validate,
2615)]
2616pub struct ImpliedCurrencyAndAmount {
2617    #[validate(range(min = 0,))]
2618    #[serde(rename = "$text")]
2619    pub value: f64,
2620}
2621#[derive(
2622    Debug,
2623    Default,
2624    Clone,
2625    PartialEq,
2626    ::serde::Serialize,
2627    ::serde::Deserialize,
2628    ::derive_builder::Builder,
2629    ::validator::Validate,
2630)]
2631pub struct OptionStyle1ChoiceEnum {
2632    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
2633    pub cd: Option<OptionStyle1Code>,
2634    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
2635    pub prtry: Option<GenericIdentification13>,
2636}
2637#[derive(
2638    Debug,
2639    Default,
2640    Clone,
2641    PartialEq,
2642    ::serde::Serialize,
2643    ::serde::Deserialize,
2644    ::derive_builder::Builder,
2645    ::validator::Validate,
2646)]
2647pub struct OptionStyle1Choice {
2648    #[serde(flatten)]
2649    pub value: OptionStyle1ChoiceEnum,
2650}
2651#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2652pub enum InvestorRestrictionType1Code {
2653    #[serde(rename = "LERE")]
2654    Lere,
2655    #[serde(rename = "CITI")]
2656    Citi,
2657    #[serde(rename = "INDV")]
2658    Indv,
2659    #[default]
2660    Unknown,
2661}
2662#[derive(
2663    Debug,
2664    Default,
2665    Clone,
2666    PartialEq,
2667    ::serde::Serialize,
2668    ::serde::Deserialize,
2669    ::derive_builder::Builder,
2670    ::validator::Validate,
2671)]
2672pub struct Warrant4 {
2673    #[serde(rename = "Mltplr", skip_serializing_if = "Option::is_none")]
2674    pub mltplr: Option<BaseOneRate>,
2675    #[serde(rename = "SbcptPric", skip_serializing_if = "Option::is_none")]
2676    pub sbcpt_pric: Option<Price8>,
2677    #[serde(rename = "Tp", skip_serializing_if = "Option::is_none")]
2678    pub tp: Option<WarrantStyle3Choice>,
2679    #[validate(length(min = 0,))]
2680    #[serde(rename = "WarrtAgt", default)]
2681    pub warrt_agt: Vec<Organisation38>,
2682}
2683#[derive(
2684    Debug,
2685    Default,
2686    Clone,
2687    PartialEq,
2688    ::serde::Serialize,
2689    ::serde::Deserialize,
2690    ::derive_builder::Builder,
2691    ::validator::Validate,
2692)]
2693pub struct Term1 {
2694    #[serde(rename = "Oprtr")]
2695    pub oprtr: Operator1Code,
2696    #[serde(rename = "Val")]
2697    pub val: RateOrAbsoluteValue1Choice,
2698}
2699#[derive(
2700    Debug,
2701    Default,
2702    Clone,
2703    PartialEq,
2704    ::serde::Serialize,
2705    ::serde::Deserialize,
2706    ::derive_builder::Builder,
2707    ::validator::Validate,
2708)]
2709pub struct Max16Text {
2710    #[validate(length(min = 1, max = 16,))]
2711    #[serde(rename = "$text")]
2712    pub value: String,
2713}
2714#[derive(
2715    Debug,
2716    Default,
2717    Clone,
2718    PartialEq,
2719    ::serde::Serialize,
2720    ::serde::Deserialize,
2721    ::derive_builder::Builder,
2722    ::validator::Validate,
2723)]
2724pub struct CommonFinancialInstrumentAttributes12 {
2725    #[serde(rename = "SctySts", skip_serializing_if = "Option::is_none")]
2726    pub scty_sts: Option<SecurityStatus3Choice>,
2727    #[serde(rename = "ISOSctyLngNm", skip_serializing_if = "Option::is_none")]
2728    pub iso_scty_lng_nm: Option<Max350Text>,
2729    #[serde(rename = "ISOSctyShrtNm", skip_serializing_if = "Option::is_none")]
2730    pub iso_scty_shrt_nm: Option<Max35Text>,
2731    #[serde(rename = "NmVldFr", skip_serializing_if = "Option::is_none")]
2732    pub nm_vld_fr: Option<DateAndDateTime2Choice>,
2733    #[serde(rename = "DnmtnCcy", skip_serializing_if = "Option::is_none")]
2734    pub dnmtn_ccy: Option<ActiveOrHistoricCurrencyCode>,
2735    #[serde(rename = "CertNb", skip_serializing_if = "Option::is_none")]
2736    pub cert_nb: Option<Max35Text>,
2737    #[serde(rename = "CtrctVrsnNb", skip_serializing_if = "Option::is_none")]
2738    pub ctrct_vrsn_nb: Option<Number>,
2739    #[serde(rename = "CpnAttchdNb", skip_serializing_if = "Option::is_none")]
2740    pub cpn_attchd_nb: Option<Max3NumericText>,
2741    #[serde(rename = "TaxLotNb", skip_serializing_if = "Option::is_none")]
2742    pub tax_lot_nb: Option<Max15NumericText>,
2743    #[serde(rename = "PoolNb", skip_serializing_if = "Option::is_none")]
2744    pub pool_nb: Option<Max15NumericText>,
2745    #[serde(rename = "CvrdInd", skip_serializing_if = "Option::is_none")]
2746    pub cvrd_ind: Option<YesNoIndicator>,
2747    #[serde(rename = "LglRstrctns", skip_serializing_if = "Option::is_none")]
2748    pub lgl_rstrctns: Option<LegalRestrictions4Choice>,
2749    #[serde(rename = "PosLmt", skip_serializing_if = "Option::is_none")]
2750    pub pos_lmt: Option<FinancialInstrumentQuantity1Choice>,
2751    #[serde(rename = "NearTermPosLmt", skip_serializing_if = "Option::is_none")]
2752    pub near_term_pos_lmt: Option<FinancialInstrumentQuantity1Choice>,
2753    #[serde(rename = "ListgDt", skip_serializing_if = "Option::is_none")]
2754    pub listg_dt: Option<IsoDate>,
2755    #[serde(rename = "RcrdDt", skip_serializing_if = "Option::is_none")]
2756    pub rcrd_dt: Option<IsoDateTime>,
2757    #[serde(rename = "XpryDt", skip_serializing_if = "Option::is_none")]
2758    pub xpry_dt: Option<IsoDate>,
2759    #[serde(rename = "Purp", skip_serializing_if = "Option::is_none")]
2760    pub purp: Option<Max256Text>,
2761    #[serde(rename = "ClssfctnTp", skip_serializing_if = "Option::is_none")]
2762    pub clssfctn_tp: Option<ClassificationType2>,
2763    #[serde(rename = "Issnc", skip_serializing_if = "Option::is_none")]
2764    pub issnc: Option<Issuance5>,
2765    #[validate(length(min = 0,))]
2766    #[serde(rename = "TradgMkt", default)]
2767    pub tradg_mkt: Vec<TradingParameters2>,
2768    #[validate(length(min = 0,))]
2769    #[serde(rename = "SprdAndBchmkCrv", default)]
2770    pub sprd_and_bchmk_crv: Vec<BenchmarkCurve6>,
2771    #[serde(rename = "PutTp", skip_serializing_if = "Option::is_none")]
2772    pub put_tp: Option<PutType3Choice>,
2773    #[serde(rename = "CallTp", skip_serializing_if = "Option::is_none")]
2774    pub call_tp: Option<CallType3Choice>,
2775    #[serde(rename = "FngbInd", skip_serializing_if = "Option::is_none")]
2776    pub fngb_ind: Option<YesNoIndicator>,
2777    #[serde(rename = "Cnfdtl", skip_serializing_if = "Option::is_none")]
2778    pub cnfdtl: Option<YesNoIndicator>,
2779    #[serde(rename = "PrvtPlcmnt", skip_serializing_if = "Option::is_none")]
2780    pub prvt_plcmnt: Option<YesNoIndicator>,
2781    #[serde(rename = "ConvtblInd", skip_serializing_if = "Option::is_none")]
2782    pub convtbl_ind: Option<YesNoIndicator>,
2783    #[serde(rename = "ConvsPrd", skip_serializing_if = "Option::is_none")]
2784    pub convs_prd: Option<DateTimePeriod1>,
2785    #[serde(rename = "ConvsRatioNmrtr", skip_serializing_if = "Option::is_none")]
2786    pub convs_ratio_nmrtr: Option<FinancialInstrumentQuantity1Choice>,
2787    #[serde(rename = "ConvsRatioDnmtr", skip_serializing_if = "Option::is_none")]
2788    pub convs_ratio_dnmtr: Option<FinancialInstrumentQuantity1Choice>,
2789    #[serde(rename = "PmryPlcOfDpst", skip_serializing_if = "Option::is_none")]
2790    pub pmry_plc_of_dpst: Option<PartyIdentification136>,
2791    #[serde(rename = "TradgMtd", skip_serializing_if = "Option::is_none")]
2792    pub tradg_mtd: Option<UnitOrFaceAmount1Choice>,
2793    #[serde(rename = "TEFRARule", skip_serializing_if = "Option::is_none")]
2794    pub tefra_rule: Option<TefraRules3Choice>,
2795    #[serde(rename = "SrNb", skip_serializing_if = "Option::is_none")]
2796    pub sr_nb: Option<Max16Text>,
2797    #[serde(rename = "Clss", skip_serializing_if = "Option::is_none")]
2798    pub clss: Option<Max16Text>,
2799    #[validate(length(min = 0,))]
2800    #[serde(rename = "WhldgTaxRgm", default)]
2801    pub whldg_tax_rgm: Vec<SecurityWithHoldingTax1>,
2802    #[serde(rename = "PmtSts", skip_serializing_if = "Option::is_none")]
2803    pub pmt_sts: Option<SecuritiesPaymentStatus5Choice>,
2804    #[serde(rename = "InitlPhysForm", skip_serializing_if = "Option::is_none")]
2805    pub initl_phys_form: Option<InitialPhysicalForm4Choice>,
2806    #[serde(rename = "AftrXchgPhysForm", skip_serializing_if = "Option::is_none")]
2807    pub aftr_xchg_phys_form: Option<InitialPhysicalForm3Choice>,
2808    #[serde(rename = "CmonSfkpr", skip_serializing_if = "Option::is_none")]
2809    pub cmon_sfkpr: Option<PartyIdentification177Choice>,
2810    #[serde(rename = "RedTp", skip_serializing_if = "Option::is_none")]
2811    pub red_tp: Option<MaturityRedemptionType3Choice>,
2812    #[serde(rename = "RedPmtCcy", skip_serializing_if = "Option::is_none")]
2813    pub red_pmt_ccy: Option<ActiveCurrencyCode>,
2814    #[validate(length(min = 0,))]
2815    #[serde(rename = "Rstrctn", default)]
2816    pub rstrctn: Vec<SecurityRestriction3>,
2817    #[serde(rename = "FinInstrmId", skip_serializing_if = "Option::is_none")]
2818    pub fin_instrm_id: Option<SecurityIdentification39>,
2819    #[validate(length(min = 0,))]
2820    #[serde(rename = "SttlmInf", default)]
2821    pub sttlm_inf: Vec<SettlementInformation17>,
2822    #[serde(rename = "FinInstrmForm", skip_serializing_if = "Option::is_none")]
2823    pub fin_instrm_form: Option<FinancialInstrumentForm2>,
2824    #[serde(rename = "CtctNm", skip_serializing_if = "Option::is_none")]
2825    pub ctct_nm: Option<Organisation38>,
2826    #[serde(rename = "LeadMgr", skip_serializing_if = "Option::is_none")]
2827    pub lead_mgr: Option<Organisation38>,
2828    #[serde(rename = "PrncplPngAgt", skip_serializing_if = "Option::is_none")]
2829    pub prncpl_png_agt: Option<Organisation38>,
2830    #[serde(rename = "PngAgt", skip_serializing_if = "Option::is_none")]
2831    pub png_agt: Option<Organisation38>,
2832    #[serde(rename = "Dpstry", skip_serializing_if = "Option::is_none")]
2833    pub dpstry: Option<Organisation38>,
2834    #[serde(rename = "UndrlygRsk", skip_serializing_if = "Option::is_none")]
2835    pub undrlyg_rsk: Option<Organisation38>,
2836}
2837#[derive(
2838    Debug,
2839    Default,
2840    Clone,
2841    PartialEq,
2842    ::serde::Serialize,
2843    ::serde::Deserialize,
2844    ::derive_builder::Builder,
2845    ::validator::Validate,
2846)]
2847pub struct PhoneNumber {
2848    #[validate(regex = "PHONE_NUMBER_REGEX")]
2849    #[serde(rename = "$text")]
2850    pub value: String,
2851}
2852#[derive(
2853    Debug,
2854    Default,
2855    Clone,
2856    PartialEq,
2857    ::serde::Serialize,
2858    ::serde::Deserialize,
2859    ::derive_builder::Builder,
2860    ::validator::Validate,
2861)]
2862pub struct SecurityWithHoldingTax1 {
2863    #[serde(rename = "WhldgTaxVal")]
2864    pub whldg_tax_val: RateAndAmountFormat1Choice,
2865    #[serde(rename = "Ctry")]
2866    pub ctry: CountryCode,
2867}
2868#[derive(
2869    Debug,
2870    Default,
2871    Clone,
2872    PartialEq,
2873    ::serde::Serialize,
2874    ::serde::Deserialize,
2875    ::derive_builder::Builder,
2876    ::validator::Validate,
2877)]
2878pub struct Max3NumericText {
2879    #[validate(regex = "MAX_3_NUMERIC_TEXT_REGEX")]
2880    #[serde(rename = "$text")]
2881    pub value: String,
2882}
2883#[derive(
2884    Debug,
2885    Default,
2886    Clone,
2887    PartialEq,
2888    ::serde::Serialize,
2889    ::serde::Deserialize,
2890    ::derive_builder::Builder,
2891    ::validator::Validate,
2892)]
2893pub struct Isin2021Identifier {
2894    #[validate(regex = "ISIN_2021_IDENTIFIER_REGEX")]
2895    #[serde(rename = "$text")]
2896    pub value: String,
2897}
2898#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2899pub enum LegalRestrictions2Code {
2900    #[serde(rename = "JURO")]
2901    Juro,
2902    #[serde(rename = "PPLA")]
2903    Ppla,
2904    #[serde(rename = "ACRI")]
2905    Acri,
2906    #[serde(rename = "MARG")]
2907    Marg,
2908    #[serde(rename = "PRIV")]
2909    Priv,
2910    #[default]
2911    Unknown,
2912}
2913#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
2914pub enum BenchmarkCurveName1Code {
2915    #[serde(rename = "MAAA")]
2916    Maaa,
2917    #[serde(rename = "FUSW")]
2918    Fusw,
2919    #[serde(rename = "LIBI")]
2920    Libi,
2921    #[serde(rename = "LIBO")]
2922    Libo,
2923    #[serde(rename = "SWAP")]
2924    Swap,
2925    #[serde(rename = "TREA")]
2926    Trea,
2927    #[serde(rename = "EURI")]
2928    Euri,
2929    #[serde(rename = "PFAN")]
2930    Pfan,
2931    #[default]
2932    Unknown,
2933}
2934#[derive(
2935    Debug,
2936    Default,
2937    Clone,
2938    PartialEq,
2939    ::serde::Serialize,
2940    ::serde::Deserialize,
2941    ::derive_builder::Builder,
2942    ::validator::Validate,
2943)]
2944pub struct MicIdentifier {
2945    #[validate(regex = "MIC_IDENTIFIER_REGEX")]
2946    #[serde(rename = "$text")]
2947    pub value: String,
2948}
2949#[derive(
2950    Debug,
2951    Default,
2952    Clone,
2953    PartialEq,
2954    ::serde::Serialize,
2955    ::serde::Deserialize,
2956    ::derive_builder::Builder,
2957    ::validator::Validate,
2958)]
2959pub struct DateTimePeriod2 {
2960    #[validate]
2961    #[serde(rename = "FrDtTm")]
2962    pub fr_dt_tm: IsoDateTime,
2963    #[serde(rename = "ToDtTm", skip_serializing_if = "Option::is_none")]
2964    pub to_dt_tm: Option<IsoDateTime>,
2965}
2966#[derive(
2967    Debug,
2968    Default,
2969    Clone,
2970    PartialEq,
2971    ::serde::Serialize,
2972    ::serde::Deserialize,
2973    ::derive_builder::Builder,
2974    ::validator::Validate,
2975)]
2976pub struct PostalAddress3 {
2977    #[serde(rename = "AdrTp")]
2978    pub adr_tp: AddressType1Code,
2979    #[validate]
2980    #[serde(rename = "MlngInd")]
2981    pub mlng_ind: YesNoIndicator,
2982    #[validate]
2983    #[serde(rename = "RegnAdrInd")]
2984    pub regn_adr_ind: YesNoIndicator,
2985    #[validate]
2986    #[serde(rename = "NmAndAdr")]
2987    pub nm_and_adr: NameAndAddress4,
2988}
2989#[derive(
2990    Debug,
2991    Default,
2992    Clone,
2993    PartialEq,
2994    ::serde::Serialize,
2995    ::serde::Deserialize,
2996    ::derive_builder::Builder,
2997    ::validator::Validate,
2998)]
2999pub struct PriceRateOrAmount3ChoiceEnum {
3000    #[serde(rename = "Rate", skip_serializing_if = "Option::is_none")]
3001    pub rate: Option<PercentageRate>,
3002    #[serde(rename = "Amt", skip_serializing_if = "Option::is_none")]
3003    pub amt: Option<ActiveOrHistoricCurrencyAnd13DecimalAmount>,
3004}
3005#[derive(
3006    Debug,
3007    Default,
3008    Clone,
3009    PartialEq,
3010    ::serde::Serialize,
3011    ::serde::Deserialize,
3012    ::derive_builder::Builder,
3013    ::validator::Validate,
3014)]
3015pub struct PriceRateOrAmount3Choice {
3016    #[serde(flatten)]
3017    pub value: PriceRateOrAmount3ChoiceEnum,
3018}
3019#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3020pub enum TimeUnit1Code {
3021    #[serde(rename = "DAYC")]
3022    Dayc,
3023    #[serde(rename = "HOUR")]
3024    Hour,
3025    #[serde(rename = "MINU")]
3026    Minu,
3027    #[serde(rename = "MNTH")]
3028    Mnth,
3029    #[serde(rename = "SECO")]
3030    Seco,
3031    #[serde(rename = "WEEK")]
3032    Week,
3033    #[serde(rename = "YEAR")]
3034    Year,
3035    #[default]
3036    Unknown,
3037}
3038#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3039pub enum OptionType1Code {
3040    #[serde(rename = "CALL")]
3041    Call,
3042    #[serde(rename = "PUTO")]
3043    Puto,
3044    #[default]
3045    Unknown,
3046}
3047#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3048pub enum InitialPhysicalForm1Code {
3049    #[serde(rename = "GTGT")]
3050    Gtgt,
3051    #[serde(rename = "GPGP")]
3052    Gpgp,
3053    #[serde(rename = "DERN")]
3054    Dern,
3055    #[default]
3056    Unknown,
3057}
3058#[derive(
3059    Debug,
3060    Default,
3061    Clone,
3062    PartialEq,
3063    ::serde::Serialize,
3064    ::serde::Deserialize,
3065    ::derive_builder::Builder,
3066    ::validator::Validate,
3067)]
3068pub struct CalculationType3ChoiceEnum {
3069    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
3070    pub cd: Option<CalculationType1Code>,
3071    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
3072    pub prtry: Option<GenericIdentification30>,
3073}
3074#[derive(
3075    Debug,
3076    Default,
3077    Clone,
3078    PartialEq,
3079    ::serde::Serialize,
3080    ::serde::Deserialize,
3081    ::derive_builder::Builder,
3082    ::validator::Validate,
3083)]
3084pub struct CalculationType3Choice {
3085    #[serde(flatten)]
3086    pub value: CalculationType3ChoiceEnum,
3087}
3088#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3089pub enum Frequency5Code {
3090    #[serde(rename = "YEAR")]
3091    Year,
3092    #[serde(rename = "MNTH")]
3093    Mnth,
3094    #[serde(rename = "QURT")]
3095    Qurt,
3096    #[serde(rename = "MIAN")]
3097    Mian,
3098    #[serde(rename = "WEEK")]
3099    Week,
3100    #[serde(rename = "DAIL")]
3101    Dail,
3102    #[serde(rename = "ADHO")]
3103    Adho,
3104    #[serde(rename = "INDA")]
3105    Inda,
3106    #[serde(rename = "OVNG")]
3107    Ovng,
3108    #[serde(rename = "TEND")]
3109    Tend,
3110    #[default]
3111    Unknown,
3112}
3113#[derive(
3114    Debug,
3115    Default,
3116    Clone,
3117    PartialEq,
3118    ::serde::Serialize,
3119    ::serde::Deserialize,
3120    ::derive_builder::Builder,
3121    ::validator::Validate,
3122)]
3123pub struct GlobalNote2ChoiceEnum {
3124    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
3125    pub cd: Option<GlobalNote1Code>,
3126    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
3127    pub prtry: Option<GenericIdentification30>,
3128}
3129#[derive(
3130    Debug,
3131    Default,
3132    Clone,
3133    PartialEq,
3134    ::serde::Serialize,
3135    ::serde::Deserialize,
3136    ::derive_builder::Builder,
3137    ::validator::Validate,
3138)]
3139pub struct GlobalNote2Choice {
3140    #[serde(flatten)]
3141    pub value: GlobalNote2ChoiceEnum,
3142}
3143#[derive(
3144    Debug,
3145    Default,
3146    Clone,
3147    PartialEq,
3148    ::serde::Serialize,
3149    ::serde::Deserialize,
3150    ::derive_builder::Builder,
3151    ::validator::Validate,
3152)]
3153pub struct NameAndAddress4 {
3154    #[serde(rename = "Nm", skip_serializing_if = "Option::is_none")]
3155    pub nm: Option<Max350Text>,
3156    #[validate]
3157    #[serde(rename = "Adr")]
3158    pub adr: PostalAddress1,
3159}
3160#[derive(
3161    Debug,
3162    Default,
3163    Clone,
3164    PartialEq,
3165    ::serde::Serialize,
3166    ::serde::Deserialize,
3167    ::derive_builder::Builder,
3168    ::validator::Validate,
3169)]
3170pub struct BenchmarkCurve6 {
3171    #[serde(rename = "Sprd", skip_serializing_if = "Option::is_none")]
3172    pub sprd: Option<DecimalNumber>,
3173    #[serde(rename = "BchmkId", skip_serializing_if = "Option::is_none")]
3174    pub bchmk_id: Option<SecurityIdentification39>,
3175    #[serde(rename = "BchmkPric", skip_serializing_if = "Option::is_none")]
3176    pub bchmk_pric: Option<Price8>,
3177    #[serde(rename = "BchmkCrvCcy", skip_serializing_if = "Option::is_none")]
3178    pub bchmk_crv_ccy: Option<ActiveOrHistoricCurrencyCode>,
3179    #[serde(rename = "BchmkCrvNm", skip_serializing_if = "Option::is_none")]
3180    pub bchmk_crv_nm: Option<BenchmarkCurveName7Choice>,
3181    #[serde(rename = "BchmkCrvPt", skip_serializing_if = "Option::is_none")]
3182    pub bchmk_crv_pt: Option<Max256Text>,
3183}
3184#[derive(
3185    Debug,
3186    Default,
3187    Clone,
3188    PartialEq,
3189    ::serde::Serialize,
3190    ::serde::Deserialize,
3191    ::derive_builder::Builder,
3192    ::validator::Validate,
3193)]
3194pub struct Number {
3195    #[serde(rename = "$text")]
3196    pub value: f64,
3197}
3198#[derive(
3199    Debug,
3200    Default,
3201    Clone,
3202    PartialEq,
3203    ::serde::Serialize,
3204    ::serde::Deserialize,
3205    ::derive_builder::Builder,
3206    ::validator::Validate,
3207)]
3208pub struct MaturityRedemptionType3ChoiceEnum {
3209    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
3210    pub cd: Option<MaturityRedemptionType1Code>,
3211    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
3212    pub prtry: Option<GenericIdentification30>,
3213}
3214#[derive(
3215    Debug,
3216    Default,
3217    Clone,
3218    PartialEq,
3219    ::serde::Serialize,
3220    ::serde::Deserialize,
3221    ::derive_builder::Builder,
3222    ::validator::Validate,
3223)]
3224pub struct MaturityRedemptionType3Choice {
3225    #[serde(flatten)]
3226    pub value: MaturityRedemptionType3ChoiceEnum,
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 BaseOneRate {
3239    #[serde(rename = "$text")]
3240    pub value: f64,
3241}
3242#[derive(
3243    Debug,
3244    Default,
3245    Clone,
3246    PartialEq,
3247    ::serde::Serialize,
3248    ::serde::Deserialize,
3249    ::derive_builder::Builder,
3250    ::validator::Validate,
3251)]
3252pub struct MessageHeader1 {
3253    #[validate]
3254    #[serde(rename = "MsgId")]
3255    pub msg_id: Max35Text,
3256    #[serde(rename = "CreDtTm", skip_serializing_if = "Option::is_none")]
3257    pub cre_dt_tm: Option<IsoDateTime>,
3258}
3259#[derive(
3260    Debug,
3261    Default,
3262    Clone,
3263    PartialEq,
3264    ::serde::Serialize,
3265    ::serde::Deserialize,
3266    ::derive_builder::Builder,
3267    ::validator::Validate,
3268)]
3269pub struct SettlementInformation17 {
3270    #[serde(rename = "SctiesQtyTp", skip_serializing_if = "Option::is_none")]
3271    pub scties_qty_tp: Option<SettlementUnitType3Choice>,
3272    #[serde(rename = "CtrctSttlmMnth", skip_serializing_if = "Option::is_none")]
3273    pub ctrct_sttlm_mnth: Option<IsoYearMonth>,
3274    #[serde(rename = "MinDnmtn", skip_serializing_if = "Option::is_none")]
3275    pub min_dnmtn: Option<FinancialInstrumentQuantity1Choice>,
3276    #[serde(rename = "MinMltplQty", skip_serializing_if = "Option::is_none")]
3277    pub min_mltpl_qty: Option<FinancialInstrumentQuantity1Choice>,
3278    #[validate(length(min = 0,))]
3279    #[serde(rename = "DevtgSttlmUnit", default)]
3280    pub devtg_sttlm_unit: Vec<FinancialInstrumentQuantity1Choice>,
3281}
3282#[derive(
3283    Debug,
3284    Default,
3285    Clone,
3286    PartialEq,
3287    ::serde::Serialize,
3288    ::serde::Deserialize,
3289    ::derive_builder::Builder,
3290    ::validator::Validate,
3291)]
3292pub struct OptionParty3ChoiceEnum {
3293    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
3294    pub prtry: Option<GenericIdentification30>,
3295    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
3296    pub cd: Option<OptionParty1Code>,
3297}
3298#[derive(
3299    Debug,
3300    Default,
3301    Clone,
3302    PartialEq,
3303    ::serde::Serialize,
3304    ::serde::Deserialize,
3305    ::derive_builder::Builder,
3306    ::validator::Validate,
3307)]
3308pub struct OptionParty3Choice {
3309    #[serde(flatten)]
3310    pub value: OptionParty3ChoiceEnum,
3311}
3312#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3313pub enum SettlementUnitType1Code {
3314    #[serde(rename = "FAMT")]
3315    Famt,
3316    #[serde(rename = "UNIT")]
3317    Unit,
3318    #[default]
3319    Unknown,
3320}
3321#[derive(
3322    Debug,
3323    Default,
3324    Clone,
3325    PartialEq,
3326    ::serde::Serialize,
3327    ::serde::Deserialize,
3328    ::derive_builder::Builder,
3329    ::validator::Validate,
3330)]
3331pub struct Debt5 {
3332    #[serde(rename = "PmtCcy", skip_serializing_if = "Option::is_none")]
3333    pub pmt_ccy: Option<ActiveCurrencyCode>,
3334    #[serde(rename = "FaceAmt", skip_serializing_if = "Option::is_none")]
3335    pub face_amt: Option<ActiveCurrencyAndAmount>,
3336    #[serde(rename = "PmtFrqcy", skip_serializing_if = "Option::is_none")]
3337    pub pmt_frqcy: Option<Frequency35Choice>,
3338    #[serde(rename = "IntrstFxgDt", skip_serializing_if = "Option::is_none")]
3339    pub intrst_fxg_dt: Option<IsoDateTime>,
3340    #[serde(rename = "DtdDt", skip_serializing_if = "Option::is_none")]
3341    pub dtd_dt: Option<IsoDateTime>,
3342    #[serde(rename = "FrstPmtDt", skip_serializing_if = "Option::is_none")]
3343    pub frst_pmt_dt: Option<IsoDateTime>,
3344    #[serde(rename = "MtrtyDt", skip_serializing_if = "Option::is_none")]
3345    pub mtrty_dt: Option<IsoDateTime>,
3346    #[serde(rename = "NxtCpnDt", skip_serializing_if = "Option::is_none")]
3347    pub nxt_cpn_dt: Option<IsoDateTime>,
3348    #[serde(rename = "PutblDt", skip_serializing_if = "Option::is_none")]
3349    pub putbl_dt: Option<IsoDateTime>,
3350    #[serde(rename = "NxtCllblDt", skip_serializing_if = "Option::is_none")]
3351    pub nxt_cllbl_dt: Option<IsoDateTime>,
3352    #[serde(rename = "NxtFctrDt", skip_serializing_if = "Option::is_none")]
3353    pub nxt_fctr_dt: Option<IsoDateTime>,
3354    #[serde(rename = "XprtnDt", skip_serializing_if = "Option::is_none")]
3355    pub xprtn_dt: Option<IsoDateTime>,
3356    #[serde(rename = "PmtDrctnInd", skip_serializing_if = "Option::is_none")]
3357    pub pmt_drctn_ind: Option<PaymentDirectionIndicator>,
3358    #[serde(rename = "IntrstRate", skip_serializing_if = "Option::is_none")]
3359    pub intrst_rate: Option<PercentageRate>,
3360    #[serde(rename = "NxtIntrstRate", skip_serializing_if = "Option::is_none")]
3361    pub nxt_intrst_rate: Option<PercentageRate>,
3362    #[serde(rename = "OddCpnInd", skip_serializing_if = "Option::is_none")]
3363    pub odd_cpn_ind: Option<YesNoIndicator>,
3364    #[serde(rename = "CllblInd", skip_serializing_if = "Option::is_none")]
3365    pub cllbl_ind: Option<YesNoIndicator>,
3366    #[serde(rename = "CPPrgm", skip_serializing_if = "Option::is_none")]
3367    pub cp_prgm: Option<Number>,
3368    #[serde(rename = "CPRegnTp", skip_serializing_if = "Option::is_none")]
3369    pub cp_regn_tp: Option<Max350Text>,
3370    #[serde(rename = "IntrstAcrlDt", skip_serializing_if = "Option::is_none")]
3371    pub intrst_acrl_dt: Option<IsoDateTime>,
3372    #[serde(rename = "PutblInd", skip_serializing_if = "Option::is_none")]
3373    pub putbl_ind: Option<YesNoIndicator>,
3374    #[serde(rename = "PreFnddInd", skip_serializing_if = "Option::is_none")]
3375    pub pre_fndd_ind: Option<YesNoIndicator>,
3376    #[serde(rename = "EscrwdInd", skip_serializing_if = "Option::is_none")]
3377    pub escrwd_ind: Option<YesNoIndicator>,
3378    #[serde(rename = "PerptlInd", skip_serializing_if = "Option::is_none")]
3379    pub perptl_ind: Option<YesNoIndicator>,
3380    #[serde(rename = "SubrdntdInd", skip_serializing_if = "Option::is_none")]
3381    pub subrdntd_ind: Option<YesNoIndicator>,
3382    #[serde(rename = "XtndblInd", skip_serializing_if = "Option::is_none")]
3383    pub xtndbl_ind: Option<YesNoIndicator>,
3384    #[serde(rename = "XtndblPrd", skip_serializing_if = "Option::is_none")]
3385    pub xtndbl_prd: Option<DateTimePeriod1Choice>,
3386    #[serde(rename = "VarblRateInd", skip_serializing_if = "Option::is_none")]
3387    pub varbl_rate_ind: Option<YesNoIndicator>,
3388    #[serde(rename = "OverAlltmtAmt", skip_serializing_if = "Option::is_none")]
3389    pub over_alltmt_amt: Option<ActiveCurrencyAndAmount>,
3390    #[serde(rename = "OverAlltmtRate", skip_serializing_if = "Option::is_none")]
3391    pub over_alltmt_rate: Option<PercentageRate>,
3392    #[serde(rename = "AmtsblInd", skip_serializing_if = "Option::is_none")]
3393    pub amtsbl_ind: Option<YesNoIndicator>,
3394    #[serde(rename = "IntrstClctnMtd", skip_serializing_if = "Option::is_none")]
3395    pub intrst_clctn_mtd: Option<Max70Text>,
3396    #[serde(rename = "CptlsdIntrst", skip_serializing_if = "Option::is_none")]
3397    pub cptlsd_intrst: Option<DistributionPolicy2Choice>,
3398    #[validate(length(min = 0,))]
3399    #[serde(rename = "ActlDnmtnAmt", default)]
3400    pub actl_dnmtn_amt: Vec<ActiveCurrencyAndAmount>,
3401    #[serde(rename = "CurFctr", skip_serializing_if = "Option::is_none")]
3402    pub cur_fctr: Option<PercentageRate>,
3403    #[serde(rename = "NxtFctr", skip_serializing_if = "Option::is_none")]
3404    pub nxt_fctr: Option<PercentageRate>,
3405    #[serde(rename = "PrvsFctr", skip_serializing_if = "Option::is_none")]
3406    pub prvs_fctr: Option<PercentageRate>,
3407    #[serde(rename = "Pcs", skip_serializing_if = "Option::is_none")]
3408    pub pcs: Option<DecimalNumber>,
3409    #[serde(rename = "PlsMax", skip_serializing_if = "Option::is_none")]
3410    pub pls_max: Option<DecimalNumber>,
3411    #[serde(rename = "PlsPerMln", skip_serializing_if = "Option::is_none")]
3412    pub pls_per_mln: Option<DecimalNumber>,
3413    #[serde(rename = "PlsPerLot", skip_serializing_if = "Option::is_none")]
3414    pub pls_per_lot: Option<DecimalNumber>,
3415    #[serde(rename = "PlsPerTrad", skip_serializing_if = "Option::is_none")]
3416    pub pls_per_trad: Option<DecimalNumber>,
3417    #[serde(rename = "CstPrePmtPnltyInd", skip_serializing_if = "Option::is_none")]
3418    pub cst_pre_pmt_pnlty_ind: Option<YesNoIndicator>,
3419    #[serde(rename = "LotId", skip_serializing_if = "Option::is_none")]
3420    pub lot_id: Option<Max35Text>,
3421    #[serde(rename = "CstPrePmtYld", skip_serializing_if = "Option::is_none")]
3422    pub cst_pre_pmt_yld: Option<PercentageRate>,
3423    #[serde(rename = "WghtdAvrgCpn", skip_serializing_if = "Option::is_none")]
3424    pub wghtd_avrg_cpn: Option<PercentageRate>,
3425    #[serde(rename = "WghtdAvrgLife", skip_serializing_if = "Option::is_none")]
3426    pub wghtd_avrg_life: Option<DecimalNumber>,
3427    #[serde(rename = "WghtdAvrgLn", skip_serializing_if = "Option::is_none")]
3428    pub wghtd_avrg_ln: Option<DecimalNumber>,
3429    #[serde(rename = "WghtdAvrgMtrty", skip_serializing_if = "Option::is_none")]
3430    pub wghtd_avrg_mtrty: Option<DecimalNumber>,
3431    #[serde(rename = "InsrdInd", skip_serializing_if = "Option::is_none")]
3432    pub insrd_ind: Option<YesNoIndicator>,
3433    #[serde(rename = "BkQlfdInd", skip_serializing_if = "Option::is_none")]
3434    pub bk_qlfd_ind: Option<YesNoIndicator>,
3435    #[validate(length(min = 0,))]
3436    #[serde(rename = "YldClctn", default)]
3437    pub yld_clctn: Vec<YieldCalculation6>,
3438    #[serde(rename = "IntrstTp", skip_serializing_if = "Option::is_none")]
3439    pub intrst_tp: Option<InterestType3Code>,
3440    #[serde(rename = "InstrmStrTp", skip_serializing_if = "Option::is_none")]
3441    pub instrm_str_tp: Option<InstrumentSubStructureType2Choice>,
3442    #[serde(rename = "GblTp", skip_serializing_if = "Option::is_none")]
3443    pub gbl_tp: Option<GlobalNote2Choice>,
3444    #[serde(
3445        rename = "PotntlEuroSysElgblty",
3446        skip_serializing_if = "Option::is_none"
3447    )]
3448    pub potntl_euro_sys_elgblty: Option<YesNoIndicator>,
3449    #[serde(rename = "Geogcs", skip_serializing_if = "Option::is_none")]
3450    pub geogcs: Option<Max35Text>,
3451    #[serde(rename = "YldRg", skip_serializing_if = "Option::is_none")]
3452    pub yld_rg: Option<AmountOrPercentageRange1>,
3453    #[serde(rename = "CpnRg", skip_serializing_if = "Option::is_none")]
3454    pub cpn_rg: Option<AmountOrPercentageRange1>,
3455    #[serde(rename = "Purp", skip_serializing_if = "Option::is_none")]
3456    pub purp: Option<Max256Text>,
3457    #[serde(rename = "AltrntvMinTaxInd", skip_serializing_if = "Option::is_none")]
3458    pub altrntv_min_tax_ind: Option<YesNoIndicator>,
3459    #[serde(rename = "AutoRinvstmt", skip_serializing_if = "Option::is_none")]
3460    pub auto_rinvstmt: Option<PercentageRate>,
3461    #[serde(rename = "Hrcut", skip_serializing_if = "Option::is_none")]
3462    pub hrcut: Option<PercentageRate>,
3463    #[serde(rename = "TxConds", skip_serializing_if = "Option::is_none")]
3464    pub tx_conds: Option<TradeTransactionCondition7Choice>,
3465    #[serde(rename = "LookBck", skip_serializing_if = "Option::is_none")]
3466    pub look_bck: Option<Number>,
3467    #[serde(rename = "MaxSbstitn", skip_serializing_if = "Option::is_none")]
3468    pub max_sbstitn: Option<Number>,
3469    #[serde(rename = "MinIncrmt", skip_serializing_if = "Option::is_none")]
3470    pub min_incrmt: Option<FinancialInstrumentQuantity1Choice>,
3471    #[serde(rename = "MinQty", skip_serializing_if = "Option::is_none")]
3472    pub min_qty: Option<FinancialInstrumentQuantity1Choice>,
3473    #[serde(rename = "Pdctn", skip_serializing_if = "Option::is_none")]
3474    pub pdctn: Option<Max35Text>,
3475    #[serde(rename = "RstrctdInd", skip_serializing_if = "Option::is_none")]
3476    pub rstrctd_ind: Option<YesNoIndicator>,
3477    #[serde(rename = "PricFrqcy", skip_serializing_if = "Option::is_none")]
3478    pub pric_frqcy: Option<Frequency35Choice>,
3479    #[serde(rename = "Sctr", skip_serializing_if = "Option::is_none")]
3480    pub sctr: Option<Max35Text>,
3481    #[serde(rename = "SbstitnFrqcy", skip_serializing_if = "Option::is_none")]
3482    pub sbstitn_frqcy: Option<Frequency35Choice>,
3483    #[serde(rename = "SbstitnLft", skip_serializing_if = "Option::is_none")]
3484    pub sbstitn_lft: Option<Number>,
3485    #[serde(rename = "WhlPoolInd", skip_serializing_if = "Option::is_none")]
3486    pub whl_pool_ind: Option<YesNoIndicator>,
3487    #[serde(rename = "PricSrc", skip_serializing_if = "Option::is_none")]
3488    pub pric_src: Option<Max35Text>,
3489    #[serde(rename = "PricRg", skip_serializing_if = "Option::is_none")]
3490    pub pric_rg: Option<AmountOrPercentageRange1>,
3491}
3492#[derive(
3493    Debug,
3494    Default,
3495    Clone,
3496    PartialEq,
3497    ::serde::Serialize,
3498    ::serde::Deserialize,
3499    ::derive_builder::Builder,
3500    ::validator::Validate,
3501)]
3502pub struct IsoDate {
3503    #[serde(rename = "$text")]
3504    pub value: ::chrono::NaiveDate,
3505}
3506#[derive(
3507    Debug,
3508    Default,
3509    Clone,
3510    PartialEq,
3511    ::serde::Serialize,
3512    ::serde::Deserialize,
3513    ::derive_builder::Builder,
3514    ::validator::Validate,
3515)]
3516pub struct SecuritiesUpdateReason1ChoiceEnum {
3517    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
3518    pub cd: Option<ExternalSecuritiesUpdateReason1Code>,
3519    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
3520    pub prtry: Option<GenericIdentification30>,
3521}
3522#[derive(
3523    Debug,
3524    Default,
3525    Clone,
3526    PartialEq,
3527    ::serde::Serialize,
3528    ::serde::Deserialize,
3529    ::derive_builder::Builder,
3530    ::validator::Validate,
3531)]
3532pub struct SecuritiesUpdateReason1Choice {
3533    #[serde(flatten)]
3534    pub value: SecuritiesUpdateReason1ChoiceEnum,
3535}
3536#[derive(
3537    Debug,
3538    Default,
3539    Clone,
3540    PartialEq,
3541    ::serde::Serialize,
3542    ::serde::Deserialize,
3543    ::derive_builder::Builder,
3544    ::validator::Validate,
3545)]
3546pub struct Max350Text {
3547    #[validate(length(min = 1, max = 350,))]
3548    #[serde(rename = "$text")]
3549    pub value: String,
3550}
3551#[derive(
3552    Debug,
3553    Default,
3554    Clone,
3555    PartialEq,
3556    ::serde::Serialize,
3557    ::serde::Deserialize,
3558    ::derive_builder::Builder,
3559    ::validator::Validate,
3560)]
3561pub struct OptionType8ChoiceEnum {
3562    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
3563    pub prtry: Option<GenericIdentification30>,
3564    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
3565    pub cd: Option<OptionType1Code>,
3566}
3567#[derive(
3568    Debug,
3569    Default,
3570    Clone,
3571    PartialEq,
3572    ::serde::Serialize,
3573    ::serde::Deserialize,
3574    ::derive_builder::Builder,
3575    ::validator::Validate,
3576)]
3577pub struct OptionType8Choice {
3578    #[serde(flatten)]
3579    pub value: OptionType8ChoiceEnum,
3580}
3581#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3582pub enum PutType1Code {
3583    #[serde(rename = "MAND")]
3584    Mand,
3585    #[serde(rename = "OPTI")]
3586    Opti,
3587    #[serde(rename = "TWOS")]
3588    Twos,
3589    #[default]
3590    Unknown,
3591}
3592#[derive(
3593    Debug,
3594    Default,
3595    Clone,
3596    PartialEq,
3597    ::serde::Serialize,
3598    ::serde::Deserialize,
3599    ::derive_builder::Builder,
3600    ::validator::Validate,
3601)]
3602pub struct SecuritiesPaymentStatus5ChoiceEnum {
3603    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
3604    pub cd: Option<SecuritiesPaymentStatus1Code>,
3605    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
3606    pub prtry: Option<GenericIdentification30>,
3607}
3608#[derive(
3609    Debug,
3610    Default,
3611    Clone,
3612    PartialEq,
3613    ::serde::Serialize,
3614    ::serde::Deserialize,
3615    ::derive_builder::Builder,
3616    ::validator::Validate,
3617)]
3618pub struct SecuritiesPaymentStatus5Choice {
3619    #[serde(flatten)]
3620    pub value: SecuritiesPaymentStatus5ChoiceEnum,
3621}
3622#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3623pub enum InstrumentSubStructureType1Code {
3624    #[serde(rename = "ABSE")]
3625    Abse,
3626    #[serde(rename = "AIRT")]
3627    Airt,
3628    #[serde(rename = "AUTT")]
3629    Autt,
3630    #[serde(rename = "CBOB")]
3631    Cbob,
3632    #[serde(rename = "CDOB")]
3633    Cdob,
3634    #[serde(rename = "CLNO")]
3635    Clno,
3636    #[serde(rename = "CLOB")]
3637    Clob,
3638    #[serde(rename = "CMBS")]
3639    Cmbs,
3640    #[serde(rename = "CSMR")]
3641    Csmr,
3642    #[serde(rename = "CRCT")]
3643    Crct,
3644    #[serde(rename = "HELO")]
3645    Helo,
3646    #[serde(rename = "LPNO")]
3647    Lpno,
3648    #[serde(rename = "PFAB")]
3649    Pfab,
3650    #[serde(rename = "PYRT")]
3651    Pyrt,
3652    #[serde(rename = "REPK")]
3653    Repk,
3654    #[serde(rename = "RMBS")]
3655    Rmbs,
3656    #[serde(rename = "SCBO")]
3657    Scbo,
3658    #[serde(rename = "STRB")]
3659    Strb,
3660    #[serde(rename = "STUT")]
3661    Stut,
3662    #[serde(rename = "WBSE")]
3663    Wbse,
3664    #[default]
3665    Unknown,
3666}
3667#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3668pub enum OptionParty1Code {
3669    #[serde(rename = "SLLR")]
3670    Sllr,
3671    #[serde(rename = "BYER")]
3672    Byer,
3673    #[default]
3674    Unknown,
3675}
3676#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3677pub enum TefraRules1Code {
3678    #[serde(rename = "RULC")]
3679    Rulc,
3680    #[serde(rename = "RULD")]
3681    Ruld,
3682    #[default]
3683    Unknown,
3684}
3685#[derive(
3686    Debug,
3687    Default,
3688    Clone,
3689    PartialEq,
3690    ::serde::Serialize,
3691    ::serde::Deserialize,
3692    ::derive_builder::Builder,
3693    ::validator::Validate,
3694)]
3695pub struct Max140Text {
3696    #[validate(length(min = 1, max = 140,))]
3697    #[serde(rename = "$text")]
3698    pub value: String,
3699}
3700#[derive(
3701    Debug,
3702    Default,
3703    Clone,
3704    PartialEq,
3705    ::serde::Serialize,
3706    ::serde::Deserialize,
3707    ::derive_builder::Builder,
3708    ::validator::Validate,
3709)]
3710pub struct Derivative4 {
3711    #[serde(rename = "Futr", skip_serializing_if = "Option::is_none")]
3712    pub futr: Option<Future4>,
3713    #[serde(rename = "Optn", skip_serializing_if = "Option::is_none")]
3714    pub optn: Option<Option15>,
3715}
3716#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3717pub enum Appearance1Code {
3718    #[serde(rename = "DELI")]
3719    Deli,
3720    #[serde(rename = "NDEL")]
3721    Ndel,
3722    #[serde(rename = "LIMI")]
3723    Limi,
3724    #[serde(rename = "BENT")]
3725    Bent,
3726    #[serde(rename = "DFBE")]
3727    Dfbe,
3728    #[serde(rename = "DLBE")]
3729    Dlbe,
3730    #[serde(rename = "TMPG")]
3731    Tmpg,
3732    #[serde(rename = "GLOB")]
3733    Glob,
3734    #[default]
3735    Unknown,
3736}
3737#[derive(
3738    Debug,
3739    Default,
3740    Clone,
3741    PartialEq,
3742    ::serde::Serialize,
3743    ::serde::Deserialize,
3744    ::derive_builder::Builder,
3745    ::validator::Validate,
3746)]
3747pub struct IdentificationSource3ChoiceEnum {
3748    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
3749    pub cd: Option<ExternalFinancialInstrumentIdentificationType1Code>,
3750    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
3751    pub prtry: Option<Max35Text>,
3752}
3753#[derive(
3754    Debug,
3755    Default,
3756    Clone,
3757    PartialEq,
3758    ::serde::Serialize,
3759    ::serde::Deserialize,
3760    ::derive_builder::Builder,
3761    ::validator::Validate,
3762)]
3763pub struct IdentificationSource3Choice {
3764    #[serde(flatten)]
3765    pub value: IdentificationSource3ChoiceEnum,
3766}
3767#[derive(
3768    Debug,
3769    Default,
3770    Clone,
3771    PartialEq,
3772    ::serde::Serialize,
3773    ::serde::Deserialize,
3774    ::derive_builder::Builder,
3775    ::validator::Validate,
3776)]
3777pub struct Max70Text {
3778    #[validate(length(min = 1, max = 70,))]
3779    #[serde(rename = "$text")]
3780    pub value: String,
3781}
3782#[derive(
3783    Debug,
3784    Default,
3785    Clone,
3786    PartialEq,
3787    ::serde::Serialize,
3788    ::serde::Deserialize,
3789    ::derive_builder::Builder,
3790    ::validator::Validate,
3791)]
3792pub struct TradingParameters2 {
3793    #[serde(rename = "MktId", skip_serializing_if = "Option::is_none")]
3794    pub mkt_id: Option<MicIdentifier>,
3795    #[serde(rename = "RndLot", skip_serializing_if = "Option::is_none")]
3796    pub rnd_lot: Option<FinancialInstrumentQuantity1Choice>,
3797    #[serde(rename = "TradLotSz", skip_serializing_if = "Option::is_none")]
3798    pub trad_lot_sz: Option<FinancialInstrumentQuantity1Choice>,
3799    #[validate(length(min = 0, max = 5,))]
3800    #[serde(rename = "ScndryPlcOfListg", default)]
3801    pub scndry_plc_of_listg: Vec<MicIdentifier>,
3802    #[serde(rename = "MinTraddNmnlQty", skip_serializing_if = "Option::is_none")]
3803    pub min_tradd_nmnl_qty: Option<UnitOrFaceAmount1Choice>,
3804    #[serde(rename = "MaxTraddNmnlQty", skip_serializing_if = "Option::is_none")]
3805    pub max_tradd_nmnl_qty: Option<UnitOrFaceAmount1Choice>,
3806    #[serde(
3807        rename = "MinTradgPricgIncrmt",
3808        skip_serializing_if = "Option::is_none"
3809    )]
3810    pub min_tradg_pricg_incrmt: Option<Number>,
3811    #[serde(rename = "PmryPlcOfListgId", skip_serializing_if = "Option::is_none")]
3812    pub pmry_plc_of_listg_id: Option<MicIdentifier>,
3813}
3814#[derive(
3815    Debug,
3816    Default,
3817    Clone,
3818    PartialEq,
3819    ::serde::Serialize,
3820    ::serde::Deserialize,
3821    ::derive_builder::Builder,
3822    ::validator::Validate,
3823)]
3824pub struct Organisation38 {
3825    #[validate]
3826    #[serde(rename = "Nm")]
3827    pub nm: Max140Text,
3828    #[serde(rename = "Id", skip_serializing_if = "Option::is_none")]
3829    pub id: Option<PartyIdentification177Choice>,
3830    #[serde(rename = "Purp", skip_serializing_if = "Option::is_none")]
3831    pub purp: Option<Max35Text>,
3832    #[serde(rename = "TaxtnCtry", skip_serializing_if = "Option::is_none")]
3833    pub taxtn_ctry: Option<CountryCode>,
3834    #[serde(rename = "RegnCtry", skip_serializing_if = "Option::is_none")]
3835    pub regn_ctry: Option<CountryCode>,
3836    #[serde(rename = "RegnDt", skip_serializing_if = "Option::is_none")]
3837    pub regn_dt: Option<IsoDate>,
3838    #[serde(rename = "TaxIdNb", skip_serializing_if = "Option::is_none")]
3839    pub tax_id_nb: Option<Max35Text>,
3840    #[serde(rename = "NtlRegnNb", skip_serializing_if = "Option::is_none")]
3841    pub ntl_regn_nb: Option<Max35Text>,
3842    #[validate(length(min = 1, max = 5,))]
3843    #[serde(rename = "PstlAdr", default)]
3844    pub pstl_adr: Vec<PostalAddress3>,
3845    #[serde(rename = "PmryComAdr", skip_serializing_if = "Option::is_none")]
3846    pub pmry_com_adr: Option<CommunicationAddress3>,
3847    #[serde(rename = "ScndryComAdr", skip_serializing_if = "Option::is_none")]
3848    pub scndry_com_adr: Option<CommunicationAddress3>,
3849}
3850#[derive(
3851    Debug,
3852    Default,
3853    Clone,
3854    PartialEq,
3855    ::serde::Serialize,
3856    ::serde::Deserialize,
3857    ::derive_builder::Builder,
3858    ::validator::Validate,
3859)]
3860pub struct PartyIdentification120ChoiceEnum {
3861    #[serde(rename = "AnyBIC", skip_serializing_if = "Option::is_none")]
3862    pub any_bic: Option<AnyBicDec2014Identifier>,
3863    #[serde(rename = "PrtryId", skip_serializing_if = "Option::is_none")]
3864    pub prtry_id: Option<GenericIdentification36>,
3865    #[serde(rename = "NmAndAdr", skip_serializing_if = "Option::is_none")]
3866    pub nm_and_adr: Option<NameAndAddress5>,
3867}
3868#[derive(
3869    Debug,
3870    Default,
3871    Clone,
3872    PartialEq,
3873    ::serde::Serialize,
3874    ::serde::Deserialize,
3875    ::derive_builder::Builder,
3876    ::validator::Validate,
3877)]
3878pub struct PartyIdentification120Choice {
3879    #[serde(flatten)]
3880    pub value: PartyIdentification120ChoiceEnum,
3881}
3882#[derive(
3883    Debug,
3884    Default,
3885    Clone,
3886    PartialEq,
3887    ::serde::Serialize,
3888    ::serde::Deserialize,
3889    ::derive_builder::Builder,
3890    ::validator::Validate,
3891)]
3892pub struct Price8 {
3893    #[serde(rename = "ValTp", skip_serializing_if = "Option::is_none")]
3894    pub val_tp: Option<PriceValueType3Code>,
3895    #[serde(rename = "Val")]
3896    pub val: PriceRateOrAmount3Choice,
3897    #[serde(rename = "PricTp", skip_serializing_if = "Option::is_none")]
3898    pub pric_tp: Option<TypeOfPrice1Code>,
3899}
3900#[derive(
3901    Debug,
3902    Default,
3903    Clone,
3904    PartialEq,
3905    ::serde::Serialize,
3906    ::serde::Deserialize,
3907    ::derive_builder::Builder,
3908    ::validator::Validate,
3909)]
3910pub struct FinancialInstrument97 {
3911    #[serde(rename = "Eqty", skip_serializing_if = "Option::is_none")]
3912    pub eqty: Option<Equity3>,
3913    #[serde(rename = "Warrt", skip_serializing_if = "Option::is_none")]
3914    pub warrt: Option<Warrant4>,
3915    #[serde(rename = "Debt", skip_serializing_if = "Option::is_none")]
3916    pub debt: Option<Debt5>,
3917    #[serde(rename = "Deriv", skip_serializing_if = "Option::is_none")]
3918    pub deriv: Option<Derivative4>,
3919}
3920#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
3921pub enum AddressType2Code {
3922    #[serde(rename = "ADDR")]
3923    Addr,
3924    #[serde(rename = "PBOX")]
3925    Pbox,
3926    #[serde(rename = "HOME")]
3927    Home,
3928    #[serde(rename = "BIZZ")]
3929    Bizz,
3930    #[serde(rename = "MLTO")]
3931    Mlto,
3932    #[serde(rename = "DLVY")]
3933    Dlvy,
3934    #[default]
3935    Unknown,
3936}
3937#[derive(
3938    Debug,
3939    Default,
3940    Clone,
3941    PartialEq,
3942    ::serde::Serialize,
3943    ::serde::Deserialize,
3944    ::derive_builder::Builder,
3945    ::validator::Validate,
3946)]
3947pub struct Exact4AlphaNumericText {
3948    #[validate(regex = "EXACT_4_ALPHA_NUMERIC_TEXT_REGEX")]
3949    #[serde(rename = "$text")]
3950    pub value: String,
3951}
3952#[derive(
3953    Debug,
3954    Default,
3955    Clone,
3956    PartialEq,
3957    ::serde::Serialize,
3958    ::serde::Deserialize,
3959    ::derive_builder::Builder,
3960    ::validator::Validate,
3961)]
3962pub struct DateAndDateTime2ChoiceEnum {
3963    #[serde(rename = "Dt", skip_serializing_if = "Option::is_none")]
3964    pub dt: Option<IsoDate>,
3965    #[serde(rename = "DtTm", skip_serializing_if = "Option::is_none")]
3966    pub dt_tm: Option<IsoDateTime>,
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 DateAndDateTime2Choice {
3979    #[serde(flatten)]
3980    pub value: DateAndDateTime2ChoiceEnum,
3981}
3982#[derive(
3983    Debug,
3984    Default,
3985    Clone,
3986    PartialEq,
3987    ::serde::Serialize,
3988    ::serde::Deserialize,
3989    ::derive_builder::Builder,
3990    ::validator::Validate,
3991)]
3992pub struct UnderlyingAttributes4 {
3993    #[serde(rename = "AllcnPctg", skip_serializing_if = "Option::is_none")]
3994    pub allcn_pctg: Option<PercentageRate>,
3995    #[serde(rename = "Qty", skip_serializing_if = "Option::is_none")]
3996    pub qty: Option<UnitOrFaceAmount1Choice>,
3997    #[serde(rename = "SttlmTp", skip_serializing_if = "Option::is_none")]
3998    pub sttlm_tp: Option<SettlementType3Choice>,
3999    #[serde(rename = "CshAmt", skip_serializing_if = "Option::is_none")]
4000    pub csh_amt: Option<ActiveCurrencyAndAmount>,
4001    #[serde(rename = "CshTp", skip_serializing_if = "Option::is_none")]
4002    pub csh_tp: Option<Max35Text>,
4003    #[serde(rename = "Pric", skip_serializing_if = "Option::is_none")]
4004    pub pric: Option<Price8>,
4005    #[serde(rename = "DrtyPric", skip_serializing_if = "Option::is_none")]
4006    pub drty_pric: Option<Price8>,
4007    #[serde(rename = "EndPric", skip_serializing_if = "Option::is_none")]
4008    pub end_pric: Option<Price8>,
4009    #[serde(rename = "StartVal", skip_serializing_if = "Option::is_none")]
4010    pub start_val: Option<ActiveCurrencyAndAmount>,
4011    #[serde(rename = "CurVal", skip_serializing_if = "Option::is_none")]
4012    pub cur_val: Option<ActiveCurrencyAndAmount>,
4013    #[serde(rename = "EndVal", skip_serializing_if = "Option::is_none")]
4014    pub end_val: Option<ActiveCurrencyAndAmount>,
4015    #[serde(rename = "AdjstdQty", skip_serializing_if = "Option::is_none")]
4016    pub adjstd_qty: Option<UnitOrFaceAmount1Choice>,
4017    #[serde(rename = "XchgRate", skip_serializing_if = "Option::is_none")]
4018    pub xchg_rate: Option<PercentageRate>,
4019    #[serde(rename = "CapVal", skip_serializing_if = "Option::is_none")]
4020    pub cap_val: Option<ActiveCurrencyAndAmount>,
4021}
4022#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
4023pub enum OptionStyle1Code {
4024    #[serde(rename = "AMER")]
4025    Amer,
4026    #[serde(rename = "EURO")]
4027    Euro,
4028    #[serde(rename = "BERM")]
4029    Berm,
4030    #[serde(rename = "ASIA")]
4031    Asia,
4032    #[serde(rename = "CANA")]
4033    Cana,
4034    #[default]
4035    Unknown,
4036}
4037#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
4038pub enum PriceValueType3Code {
4039    #[serde(rename = "DISC")]
4040    Disc,
4041    #[serde(rename = "PREM")]
4042    Prem,
4043    #[serde(rename = "PARV")]
4044    Parv,
4045    #[serde(rename = "YIEL")]
4046    Yiel,
4047    #[serde(rename = "SPRE")]
4048    Spre,
4049    #[serde(rename = "PEUN")]
4050    Peun,
4051    #[serde(rename = "ABSO")]
4052    Abso,
4053    #[serde(rename = "TEDP")]
4054    Tedp,
4055    #[serde(rename = "TEDY")]
4056    Tedy,
4057    #[serde(rename = "FICT")]
4058    Fict,
4059    #[serde(rename = "VACT")]
4060    Vact,
4061    #[default]
4062    Unknown,
4063}
4064#[derive(
4065    Debug,
4066    Default,
4067    Clone,
4068    PartialEq,
4069    ::serde::Serialize,
4070    ::serde::Deserialize,
4071    ::derive_builder::Builder,
4072    ::validator::Validate,
4073)]
4074pub struct SecurityAttributes12<
4075    A: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
4076> {
4077    #[validate(length(min = 0,))]
4078    #[serde(rename = "FinInstrmTp", default)]
4079    pub fin_instrm_tp: Vec<FinancialInstrument97>,
4080    #[validate(length(min = 0,))]
4081    #[serde(rename = "FinInstrmAttrbts", default)]
4082    pub fin_instrm_attrbts: Vec<CommonFinancialInstrumentAttributes12>,
4083    #[validate(length(min = 0,))]
4084    #[serde(rename = "SplmtryData", default)]
4085    pub splmtry_data: Vec<SupplementaryData1<A>>,
4086}
4087#[derive(Debug, Default, Clone, PartialEq, ::serde::Serialize, ::serde::Deserialize)]
4088pub enum CallType1Code {
4089    #[serde(rename = "LOTT")]
4090    Lott,
4091    #[serde(rename = "PRTA")]
4092    Prta,
4093    #[default]
4094    Unknown,
4095}
4096#[derive(
4097    Debug,
4098    Default,
4099    Clone,
4100    PartialEq,
4101    ::serde::Serialize,
4102    ::serde::Deserialize,
4103    ::derive_builder::Builder,
4104    ::validator::Validate,
4105)]
4106pub struct LegalRestrictions5ChoiceEnum {
4107    #[serde(rename = "Cd", skip_serializing_if = "Option::is_none")]
4108    pub cd: Option<LegalRestrictions2Code>,
4109    #[serde(rename = "Prtry", skip_serializing_if = "Option::is_none")]
4110    pub prtry: Option<GenericIdentification30>,
4111}
4112#[derive(
4113    Debug,
4114    Default,
4115    Clone,
4116    PartialEq,
4117    ::serde::Serialize,
4118    ::serde::Deserialize,
4119    ::derive_builder::Builder,
4120    ::validator::Validate,
4121)]
4122pub struct LegalRestrictions5Choice {
4123    #[serde(flatten)]
4124    pub value: LegalRestrictions5ChoiceEnum,
4125}
4126#[derive(
4127    Debug,
4128    Default,
4129    Clone,
4130    PartialEq,
4131    ::serde::Serialize,
4132    ::serde::Deserialize,
4133    ::derive_builder::Builder,
4134    ::validator::Validate,
4135)]
4136pub struct SupplementaryDataEnvelope1<
4137    A: std::fmt::Debug + Default + Clone + PartialEq + ::serde::Serialize + ::validator::Validate,
4138> {
4139    #[validate]
4140    #[serde(flatten)]
4141    pub value: A,
4142}
iso_20022_reda/reda_007_001_01.rs

iso_20022_reda/
reda_007_001_01.rs
