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