#![allow(clippy::all)]
#![allow(non_snake_case, non_camel_case_types, dead_code, unused_imports)]
#![allow(non_local_definitions)]
use std::str::FromStr;
use crate::validate::Validate;
use yaserde_derive::{YaDeserialize, YaSerialize};
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct AccountIdentification55Choice {
#[yaserde(rename = "IBAN")]
#[cfg_attr(feature = "serde", serde(rename = "IBAN"))]
pub iban: Option<Iban2007Identifier>,
#[yaserde(rename = "BBAN")]
#[cfg_attr(feature = "serde", serde(rename = "BBAN"))]
pub bban: Option<Bbanidentifier>,
#[yaserde(rename = "UPIC")]
#[cfg_attr(feature = "serde", serde(rename = "UPIC"))]
pub upic: Option<Upicidentifier>,
#[yaserde(rename = "PrtryAcct")]
#[cfg_attr(feature = "serde", serde(rename = "PrtryAcct"))]
pub prtry_acct: Option<SimpleIdentificationInformation2>,
}
impl Validate for AccountIdentification55Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ActiveCurrencyAndAmountSimpleType (pub String);
crate::simple_type!(ActiveCurrencyAndAmountSimpleType);
impl Validate for ActiveCurrencyAndAmountSimpleType {
fn validate(&self) -> Result<(), String> {
if self.0 < "0".parse::<String>().unwrap() {
return Err(format!("MinInclusive validation error: invalid value of 0! \nExpected: 0 >= 0.\nActual: 0 == {}", self.0));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct ActiveCurrencyAndAmount {
#[yaserde(text)]
pub value: String,
#[yaserde(attribute, rename = "Ccy")]
#[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
pub ccy: ActiveCurrencyCode,
}
impl Validate for ActiveCurrencyAndAmount {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ActiveCurrencyCode (pub String);
crate::simple_type!(ActiveCurrencyCode);
impl Validate for ActiveCurrencyCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ActiveOrHistoricCurrencyAnd13DecimalAmountSimpleType (pub String);
crate::simple_type!(ActiveOrHistoricCurrencyAnd13DecimalAmountSimpleType);
impl Validate for ActiveOrHistoricCurrencyAnd13DecimalAmountSimpleType {
fn validate(&self) -> Result<(), String> {
if self.0 < "0".parse::<String>().unwrap() {
return Err(format!("MinInclusive validation error: invalid value of 0! \nExpected: 0 >= 0.\nActual: 0 == {}", self.0));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct ActiveOrHistoricCurrencyAnd13DecimalAmount {
#[yaserde(text)]
pub value: String,
#[yaserde(attribute, rename = "Ccy")]
#[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
pub ccy: ActiveOrHistoricCurrencyCode,
}
impl Validate for ActiveOrHistoricCurrencyAnd13DecimalAmount {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ActiveOrHistoricCurrencyAndAmountSimpleType (pub String);
crate::simple_type!(ActiveOrHistoricCurrencyAndAmountSimpleType);
impl Validate for ActiveOrHistoricCurrencyAndAmountSimpleType {
fn validate(&self) -> Result<(), String> {
if self.0 < "0".parse::<String>().unwrap() {
return Err(format!("MinInclusive validation error: invalid value of 0! \nExpected: 0 >= 0.\nActual: 0 == {}", self.0));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct ActiveOrHistoricCurrencyAndAmount {
#[yaserde(text)]
pub value: String,
#[yaserde(attribute, rename = "Ccy")]
#[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
pub ccy: ActiveOrHistoricCurrencyCode,
}
impl Validate for ActiveOrHistoricCurrencyAndAmount {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ActiveOrHistoricCurrencyCode (pub String);
crate::simple_type!(ActiveOrHistoricCurrencyCode);
impl Validate for ActiveOrHistoricCurrencyCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum AddressType2Code {
#[yaserde(rename = "ADDR")]
#[cfg_attr(feature = "serde", serde(rename = "ADDR"))]
Addr,
#[yaserde(rename = "PBOX")]
#[cfg_attr(feature = "serde", serde(rename = "PBOX"))]
Pbox,
#[yaserde(rename = "HOME")]
#[cfg_attr(feature = "serde", serde(rename = "HOME"))]
Home,
#[yaserde(rename = "BIZZ")]
#[cfg_attr(feature = "serde", serde(rename = "BIZZ"))]
Bizz,
#[yaserde(rename = "MLTO")]
#[cfg_attr(feature = "serde", serde(rename = "MLTO"))]
Mlto,
#[yaserde(rename = "DLVY")]
#[cfg_attr(feature = "serde", serde(rename = "DLVY"))]
Dlvy,
__Unknown__(String),
}
impl Default for AddressType2Code {
fn default() -> AddressType2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AddressType2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct AffirmationReason2 {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: UnaffirmedReason3Choice,
#[yaserde(rename = "AddtlRsnInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlRsnInf"))]
pub addtl_rsn_inf: Max210Text,
}
impl Validate for AffirmationReason2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct AffirmationReason2Choice {
#[yaserde(rename = "Rsn")]
#[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
pub rsn: Vec<AffirmationReason2>,
#[yaserde(rename = "NoSpcfdRsn")]
#[cfg_attr(feature = "serde", serde(rename = "NoSpcfdRsn"))]
pub no_spcfd_rsn: Option<NoReasonCode>,
}
impl Validate for AffirmationReason2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct AffirmationStatus11Choice {
#[yaserde(rename = "Affrmd")]
#[cfg_attr(feature = "serde", serde(rename = "Affrmd"))]
pub affrmd: Option<ProprietaryReason4>,
#[yaserde(rename = "Uaffrmd")]
#[cfg_attr(feature = "serde", serde(rename = "Uaffrmd"))]
pub uaffrmd: Option<AffirmationReason2Choice>,
#[yaserde(rename = "PrtrySts")]
#[cfg_attr(feature = "serde", serde(rename = "PrtrySts"))]
pub prtry_sts: Option<ProprietaryStatusAndReason6>,
}
impl Validate for AffirmationStatus11Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct AllegementMatchingReason2 {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: AllegementReason2Choice,
#[yaserde(rename = "AddtlRsnInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlRsnInf"))]
pub addtl_rsn_inf: Max210Text,
}
impl Validate for AllegementMatchingReason2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum AllegementReason1Code {
#[yaserde(rename = "ALG1")]
#[cfg_attr(feature = "serde", serde(rename = "ALG1"))]
Alg1,
__Unknown__(String),
}
impl Default for AllegementReason1Code {
fn default() -> AllegementReason1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AllegementReason1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct AllegementReason2Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<AllegementReason1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for AllegementReason2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct AlternatePartyIdentification8 {
#[yaserde(rename = "IdTp")]
#[cfg_attr(feature = "serde", serde(rename = "IdTp"))]
pub id_tp: IdentificationType43Choice,
#[yaserde(rename = "Ctry")]
#[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
pub ctry: CountryCode,
#[yaserde(rename = "AltrnId")]
#[cfg_attr(feature = "serde", serde(rename = "AltrnId"))]
pub altrn_id: Max35Text,
}
impl Validate for AlternatePartyIdentification8 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct AmountAndDirection29 {
#[yaserde(rename = "Amt")]
#[cfg_attr(feature = "serde", serde(rename = "Amt"))]
pub amt: ActiveOrHistoricCurrencyAndAmount,
#[yaserde(rename = "CdtDbtInd")]
#[cfg_attr(feature = "serde", serde(rename = "CdtDbtInd"))]
pub cdt_dbt_ind: CreditDebitCode,
#[yaserde(rename = "OrgnlCcyAndOrdrdAmt")]
#[cfg_attr(feature = "serde", serde(rename = "OrgnlCcyAndOrdrdAmt"))]
pub orgnl_ccy_and_ordrd_amt: ActiveOrHistoricCurrencyAndAmount,
#[yaserde(rename = "FXDtls")]
#[cfg_attr(feature = "serde", serde(rename = "FXDtls"))]
pub fx_dtls: ForeignExchangeTerms18,
}
impl Validate for AmountAndDirection29 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct AmountOrRate2Choice {
#[yaserde(rename = "Amt")]
#[cfg_attr(feature = "serde", serde(rename = "Amt"))]
pub amt: Option<ActiveCurrencyAndAmount>,
#[yaserde(rename = "Rate")]
#[cfg_attr(feature = "serde", serde(rename = "Rate"))]
pub rate: Option<PercentageRate>,
}
impl Validate for AmountOrRate2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct AnyBICDec2014Identifier (pub String);
crate::simple_type!(AnyBICDec2014Identifier);
impl Validate for AnyBICDec2014Identifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum AwaitingAffirmationReason1Code {
#[yaserde(rename = "WAFF")]
#[cfg_attr(feature = "serde", serde(rename = "WAFF"))]
Waff,
__Unknown__(String),
}
impl Default for AwaitingAffirmationReason1Code {
fn default() -> AwaitingAffirmationReason1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AwaitingAffirmationReason1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct AwaitingAffirmationReason2 {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: AwaitingAffirmationReason2Choice,
#[yaserde(rename = "AddtlRsnInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlRsnInf"))]
pub addtl_rsn_inf: Max210Text,
}
impl Validate for AwaitingAffirmationReason2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct AwaitingAffirmationReason2Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<AwaitingAffirmationReason1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for AwaitingAffirmationReason2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum AwaitingCancellationReason1Code {
#[yaserde(rename = "WCAN")]
#[cfg_attr(feature = "serde", serde(rename = "WCAN"))]
Wcan,
__Unknown__(String),
}
impl Default for AwaitingCancellationReason1Code {
fn default() -> AwaitingCancellationReason1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AwaitingCancellationReason1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct AwaitingCancellationReason2 {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: AwaitingCancellationReason2Choice,
#[yaserde(rename = "AddtlRsnInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlRsnInf"))]
pub addtl_rsn_inf: Max210Text,
}
impl Validate for AwaitingCancellationReason2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct AwaitingCancellationReason2Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<AwaitingCancellationReason1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for AwaitingCancellationReason2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Bbanidentifier (pub String);
crate::simple_type!(Bbanidentifier);
impl Validate for Bbanidentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct BaseOneRate (pub String);
crate::simple_type!(BaseOneRate);
impl Validate for BaseOneRate {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum BusinessProcessType1Code {
#[yaserde(rename = "ISUP")]
#[cfg_attr(feature = "serde", serde(rename = "ISUP"))]
Isup,
#[yaserde(rename = "NISP")]
#[cfg_attr(feature = "serde", serde(rename = "NISP"))]
Nisp,
#[yaserde(rename = "PRAC")]
#[cfg_attr(feature = "serde", serde(rename = "PRAC"))]
Prac,
#[yaserde(rename = "RSAL")]
#[cfg_attr(feature = "serde", serde(rename = "RSAL"))]
Rsal,
#[yaserde(rename = "PROP")]
#[cfg_attr(feature = "serde", serde(rename = "PROP"))]
Prop,
#[yaserde(rename = "THRU")]
#[cfg_attr(feature = "serde", serde(rename = "THRU"))]
Thru,
#[yaserde(rename = "IDEL")]
#[cfg_attr(feature = "serde", serde(rename = "IDEL"))]
Idel,
#[yaserde(rename = "DPLX")]
#[cfg_attr(feature = "serde", serde(rename = "DPLX"))]
Dplx,
__Unknown__(String),
}
impl Default for BusinessProcessType1Code {
fn default() -> BusinessProcessType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for BusinessProcessType1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct BusinessProcessType2Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<BusinessProcessType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for BusinessProcessType2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum CalculationType1Code {
#[yaserde(rename = "AFTX")]
#[cfg_attr(feature = "serde", serde(rename = "AFTX"))]
Aftx,
#[yaserde(rename = "ANNU")]
#[cfg_attr(feature = "serde", serde(rename = "ANNU"))]
Annu,
#[yaserde(rename = "ISSU")]
#[cfg_attr(feature = "serde", serde(rename = "ISSU"))]
Issu,
#[yaserde(rename = "AVMA")]
#[cfg_attr(feature = "serde", serde(rename = "AVMA"))]
Avma,
#[yaserde(rename = "BOOK")]
#[cfg_attr(feature = "serde", serde(rename = "BOOK"))]
Book,
#[yaserde(rename = "YTNC")]
#[cfg_attr(feature = "serde", serde(rename = "YTNC"))]
Ytnc,
#[yaserde(rename = "CHCL")]
#[cfg_attr(feature = "serde", serde(rename = "CHCL"))]
Chcl,
#[yaserde(rename = "CLOS")]
#[cfg_attr(feature = "serde", serde(rename = "CLOS"))]
Clos,
#[yaserde(rename = "CMPD")]
#[cfg_attr(feature = "serde", serde(rename = "CMPD"))]
Cmpd,
#[yaserde(rename = "CUYI")]
#[cfg_attr(feature = "serde", serde(rename = "CUYI"))]
Cuyi,
#[yaserde(rename = "TRGR")]
#[cfg_attr(feature = "serde", serde(rename = "TRGR"))]
Trgr,
#[yaserde(rename = "GVEQ")]
#[cfg_attr(feature = "serde", serde(rename = "GVEQ"))]
Gveq,
#[yaserde(rename = "FLAS")]
#[cfg_attr(feature = "serde", serde(rename = "FLAS"))]
Flas,
#[yaserde(rename = "NVFL")]
#[cfg_attr(feature = "serde", serde(rename = "NVFL"))]
Nvfl,
#[yaserde(rename = "LSCL")]
#[cfg_attr(feature = "serde", serde(rename = "LSCL"))]
Lscl,
#[yaserde(rename = "LSMT")]
#[cfg_attr(feature = "serde", serde(rename = "LSMT"))]
Lsmt,
#[yaserde(rename = "LSQR")]
#[cfg_attr(feature = "serde", serde(rename = "LSQR"))]
Lsqr,
#[yaserde(rename = "LSYR")]
#[cfg_attr(feature = "serde", serde(rename = "LSYR"))]
Lsyr,
#[yaserde(rename = "LGAL")]
#[cfg_attr(feature = "serde", serde(rename = "LGAL"))]
Lgal,
#[yaserde(rename = "MARK")]
#[cfg_attr(feature = "serde", serde(rename = "MARK"))]
Mark,
#[yaserde(rename = "YTMA")]
#[cfg_attr(feature = "serde", serde(rename = "YTMA"))]
Ytma,
#[yaserde(rename = "NXRF")]
#[cfg_attr(feature = "serde", serde(rename = "NXRF"))]
Nxrf,
#[yaserde(rename = "PNAV")]
#[cfg_attr(feature = "serde", serde(rename = "PNAV"))]
Pnav,
#[yaserde(rename = "NXPT")]
#[cfg_attr(feature = "serde", serde(rename = "NXPT"))]
Nxpt,
#[yaserde(rename = "PRCL")]
#[cfg_attr(feature = "serde", serde(rename = "PRCL"))]
Prcl,
#[yaserde(rename = "PRYL")]
#[cfg_attr(feature = "serde", serde(rename = "PRYL"))]
Pryl,
#[yaserde(rename = "SEMI")]
#[cfg_attr(feature = "serde", serde(rename = "SEMI"))]
Semi,
#[yaserde(rename = "SHLF")]
#[cfg_attr(feature = "serde", serde(rename = "SHLF"))]
Shlf,
#[yaserde(rename = "SPLL")]
#[cfg_attr(feature = "serde", serde(rename = "SPLL"))]
Spll,
#[yaserde(rename = "TXQV")]
#[cfg_attr(feature = "serde", serde(rename = "TXQV"))]
Txqv,
#[yaserde(rename = "TTDT")]
#[cfg_attr(feature = "serde", serde(rename = "TTDT"))]
Ttdt,
#[yaserde(rename = "TRYL")]
#[cfg_attr(feature = "serde", serde(rename = "TRYL"))]
Tryl,
#[yaserde(rename = "WRST")]
#[cfg_attr(feature = "serde", serde(rename = "WRST"))]
Wrst,
__Unknown__(String),
}
impl Default for CalculationType1Code {
fn default() -> CalculationType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for CalculationType1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum CallIn1Code {
#[yaserde(rename = "CFAV")]
#[cfg_attr(feature = "serde", serde(rename = "CFAV"))]
Cfav,
#[yaserde(rename = "CFST")]
#[cfg_attr(feature = "serde", serde(rename = "CFST"))]
Cfst,
#[yaserde(rename = "CFCC")]
#[cfg_attr(feature = "serde", serde(rename = "CFCC"))]
Cfcc,
__Unknown__(String),
}
impl Default for CallIn1Code {
fn default() -> CallIn1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for CallIn1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct CancellationProcessingStatus10Choice {
#[yaserde(rename = "CxlPdg")]
#[cfg_attr(feature = "serde", serde(rename = "CxlPdg"))]
pub cxl_pdg: Option<CancellationReason39Choice>,
#[yaserde(rename = "CxlReqd")]
#[cfg_attr(feature = "serde", serde(rename = "CxlReqd"))]
pub cxl_reqd: Option<ProprietaryReason4>,
#[yaserde(rename = "CxlCmpltd")]
#[cfg_attr(feature = "serde", serde(rename = "CxlCmpltd"))]
pub cxl_cmpltd: Option<ProprietaryReason4>,
#[yaserde(rename = "PrtrySts")]
#[cfg_attr(feature = "serde", serde(rename = "PrtrySts"))]
pub prtry_sts: Option<ProprietaryStatusAndReason6>,
}
impl Validate for CancellationProcessingStatus10Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct CancellationReason39Choice {
#[yaserde(rename = "NoSpcfdRsn")]
#[cfg_attr(feature = "serde", serde(rename = "NoSpcfdRsn"))]
pub no_spcfd_rsn: Option<NoReasonCode>,
#[yaserde(rename = "Rsn")]
#[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
pub rsn: Vec<AwaitingCancellationReason2>,
}
impl Validate for CancellationReason39Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct CashAccountIdentification5Choice {
#[yaserde(rename = "IBAN")]
#[cfg_attr(feature = "serde", serde(rename = "IBAN"))]
pub iban: Option<Iban2007Identifier>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<Max34Text>,
}
impl Validate for CashAccountIdentification5Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum CashMarginOrder1Code {
#[yaserde(rename = "CASH")]
#[cfg_attr(feature = "serde", serde(rename = "CASH"))]
Cash,
#[yaserde(rename = "MRGO")]
#[cfg_attr(feature = "serde", serde(rename = "MRGO"))]
Mrgo,
#[yaserde(rename = "MRGC")]
#[cfg_attr(feature = "serde", serde(rename = "MRGC"))]
Mrgc,
__Unknown__(String),
}
impl Default for CashMarginOrder1Code {
fn default() -> CashMarginOrder1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for CashMarginOrder1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum ChargeTaxBasis1Code {
#[yaserde(rename = "FLAT")]
#[cfg_attr(feature = "serde", serde(rename = "FLAT"))]
Flat,
#[yaserde(rename = "PERU")]
#[cfg_attr(feature = "serde", serde(rename = "PERU"))]
Peru,
__Unknown__(String),
}
impl Default for ChargeTaxBasis1Code {
fn default() -> ChargeTaxBasis1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for ChargeTaxBasis1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct ChargeTaxBasisType2Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<ChargeTaxBasis1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for ChargeTaxBasisType2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct Commission25 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: CommissionType6Choice,
#[yaserde(rename = "Comssn")]
#[cfg_attr(feature = "serde", serde(rename = "Comssn"))]
pub comssn: AmountOrRate2Choice,
#[yaserde(rename = "RcptId")]
#[cfg_attr(feature = "serde", serde(rename = "RcptId"))]
pub rcpt_id: PartyIdentification267,
#[yaserde(rename = "ClctnDt")]
#[cfg_attr(feature = "serde", serde(rename = "ClctnDt"))]
pub clctn_dt: Isodate,
#[yaserde(rename = "TtlComssn")]
#[cfg_attr(feature = "serde", serde(rename = "TtlComssn"))]
pub ttl_comssn: AmountAndDirection29,
#[yaserde(rename = "TtlVATAmt")]
#[cfg_attr(feature = "serde", serde(rename = "TtlVATAmt"))]
pub ttl_vat_amt: ActiveCurrencyAndAmount,
#[yaserde(rename = "VATRate")]
#[cfg_attr(feature = "serde", serde(rename = "VATRate"))]
pub vat_rate: BaseOneRate,
}
impl Validate for Commission25 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct CommissionType6Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<CommissionType9Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for CommissionType6Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum CommissionType9Code {
#[yaserde(rename = "CLDI")]
#[cfg_attr(feature = "serde", serde(rename = "CLDI"))]
Cldi,
#[yaserde(rename = "STEP")]
#[cfg_attr(feature = "serde", serde(rename = "STEP"))]
Step,
#[yaserde(rename = "SOFT")]
#[cfg_attr(feature = "serde", serde(rename = "SOFT"))]
Soft,
#[yaserde(rename = "PERN")]
#[cfg_attr(feature = "serde", serde(rename = "PERN"))]
Pern,
#[yaserde(rename = "FLAT")]
#[cfg_attr(feature = "serde", serde(rename = "FLAT"))]
Flat,
#[yaserde(rename = "PERU")]
#[cfg_attr(feature = "serde", serde(rename = "PERU"))]
Peru,
#[yaserde(rename = "PWCD")]
#[cfg_attr(feature = "serde", serde(rename = "PWCD"))]
Pwcd,
#[yaserde(rename = "PWEU")]
#[cfg_attr(feature = "serde", serde(rename = "PWEU"))]
Pweu,
#[yaserde(rename = "BRKR")]
#[cfg_attr(feature = "serde", serde(rename = "BRKR"))]
Brkr,
#[yaserde(rename = "DFDP")]
#[cfg_attr(feature = "serde", serde(rename = "DFDP"))]
Dfdp,
#[yaserde(rename = "PBOC")]
#[cfg_attr(feature = "serde", serde(rename = "PBOC"))]
Pboc,
__Unknown__(String),
}
impl Default for CommissionType9Code {
fn default() -> CommissionType9Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for CommissionType9Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct ConfirmationParties9 {
#[yaserde(rename = "Invstr")]
#[cfg_attr(feature = "serde", serde(rename = "Invstr"))]
pub invstr: Vec<PartyIdentificationAndAccount220>,
#[yaserde(rename = "Buyr")]
#[cfg_attr(feature = "serde", serde(rename = "Buyr"))]
pub buyr: ConfirmationPartyDetails12,
#[yaserde(rename = "Brrwr")]
#[cfg_attr(feature = "serde", serde(rename = "Brrwr"))]
pub brrwr: ConfirmationPartyDetails12,
#[yaserde(rename = "Sellr")]
#[cfg_attr(feature = "serde", serde(rename = "Sellr"))]
pub sellr: ConfirmationPartyDetails12,
#[yaserde(rename = "Lndr")]
#[cfg_attr(feature = "serde", serde(rename = "Lndr"))]
pub lndr: ConfirmationPartyDetails12,
#[yaserde(rename = "BrkrOfCdt")]
#[cfg_attr(feature = "serde", serde(rename = "BrkrOfCdt"))]
pub brkr_of_cdt: ConfirmationPartyDetails14,
#[yaserde(rename = "IntrdcgFirm")]
#[cfg_attr(feature = "serde", serde(rename = "IntrdcgFirm"))]
pub intrdcg_firm: ConfirmationPartyDetails14,
#[yaserde(rename = "StepInFirm")]
#[cfg_attr(feature = "serde", serde(rename = "StepInFirm"))]
pub step_in_firm: ConfirmationPartyDetails11,
#[yaserde(rename = "StepOutFirm")]
#[cfg_attr(feature = "serde", serde(rename = "StepOutFirm"))]
pub step_out_firm: ConfirmationPartyDetails11,
#[yaserde(rename = "ClrFirm")]
#[cfg_attr(feature = "serde", serde(rename = "ClrFirm"))]
pub clr_firm: ConfirmationPartyDetails16,
#[yaserde(rename = "ExctgBrkr")]
#[cfg_attr(feature = "serde", serde(rename = "ExctgBrkr"))]
pub exctg_brkr: ConfirmationPartyDetails16,
#[yaserde(rename = "AffrmgPty")]
#[cfg_attr(feature = "serde", serde(rename = "AffrmgPty"))]
pub affrmg_pty: ConfirmationPartyDetails14,
#[yaserde(rename = "TradBnfcryPty")]
#[cfg_attr(feature = "serde", serde(rename = "TradBnfcryPty"))]
pub trad_bnfcry_pty: ConfirmationPartyDetails14,
}
impl Validate for ConfirmationParties9 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct ConfirmationPartyDetails11 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: PartyIdentification240Choice,
#[yaserde(rename = "AltrnId")]
#[cfg_attr(feature = "serde", serde(rename = "AltrnId"))]
pub altrn_id: AlternatePartyIdentification8,
#[yaserde(rename = "PrcgId")]
#[cfg_attr(feature = "serde", serde(rename = "PrcgId"))]
pub prcg_id: Max35Text,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: PartyTextInformation5,
}
impl Validate for ConfirmationPartyDetails11 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct ConfirmationPartyDetails12 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: PartyIdentification240Choice,
#[yaserde(rename = "AltrnId")]
#[cfg_attr(feature = "serde", serde(rename = "AltrnId"))]
pub altrn_id: AlternatePartyIdentification8,
#[yaserde(rename = "PrcgId")]
#[cfg_attr(feature = "serde", serde(rename = "PrcgId"))]
pub prcg_id: Max35Text,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: PartyTextInformation5,
#[yaserde(rename = "InvstrCpcty")]
#[cfg_attr(feature = "serde", serde(rename = "InvstrCpcty"))]
pub invstr_cpcty: InvestorCapacity4Choice,
#[yaserde(rename = "TradgPtyCpcty")]
#[cfg_attr(feature = "serde", serde(rename = "TradgPtyCpcty"))]
pub tradg_pty_cpcty: TradingPartyCapacity4Choice,
}
impl Validate for ConfirmationPartyDetails12 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct ConfirmationPartyDetails14 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: PartyIdentification240Choice,
#[yaserde(rename = "SfkpgAcct")]
#[cfg_attr(feature = "serde", serde(rename = "SfkpgAcct"))]
pub sfkpg_acct: SecuritiesAccount35,
#[yaserde(rename = "CshDtls")]
#[cfg_attr(feature = "serde", serde(rename = "CshDtls"))]
pub csh_dtls: AccountIdentification55Choice,
#[yaserde(rename = "AltrnId")]
#[cfg_attr(feature = "serde", serde(rename = "AltrnId"))]
pub altrn_id: AlternatePartyIdentification8,
#[yaserde(rename = "PrcgId")]
#[cfg_attr(feature = "serde", serde(rename = "PrcgId"))]
pub prcg_id: Max35Text,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: PartyTextInformation5,
#[yaserde(rename = "PtyCpcty")]
#[cfg_attr(feature = "serde", serde(rename = "PtyCpcty"))]
pub pty_cpcty: TradingPartyCapacity3Choice,
}
impl Validate for ConfirmationPartyDetails14 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct ConfirmationPartyDetails16 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: PartyIdentification240Choice,
#[yaserde(rename = "SfkpgAcct")]
#[cfg_attr(feature = "serde", serde(rename = "SfkpgAcct"))]
pub sfkpg_acct: SecuritiesAccount35,
#[yaserde(rename = "CshDtls")]
#[cfg_attr(feature = "serde", serde(rename = "CshDtls"))]
pub csh_dtls: AccountIdentification55Choice,
#[yaserde(rename = "AltrnId")]
#[cfg_attr(feature = "serde", serde(rename = "AltrnId"))]
pub altrn_id: AlternatePartyIdentification8,
#[yaserde(rename = "PrcgId")]
#[cfg_attr(feature = "serde", serde(rename = "PrcgId"))]
pub prcg_id: Max35Text,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: PartyTextInformation5,
#[yaserde(rename = "PtyCpcty")]
#[cfg_attr(feature = "serde", serde(rename = "PtyCpcty"))]
pub pty_cpcty: TradingPartyCapacity3Choice,
#[yaserde(rename = "InvstrPrtcnAssoctnMmbsh")]
#[cfg_attr(feature = "serde", serde(rename = "InvstrPrtcnAssoctnMmbsh"))]
pub invstr_prtcn_assoctn_mmbsh: YesNoIndicator,
}
impl Validate for ConfirmationPartyDetails16 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct CountryCode (pub String);
crate::simple_type!(CountryCode);
impl Validate for CountryCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum CreditDebitCode {
#[yaserde(rename = "CRDT")]
#[cfg_attr(feature = "serde", serde(rename = "CRDT"))]
Crdt,
#[yaserde(rename = "DBIT")]
#[cfg_attr(feature = "serde", serde(rename = "DBIT"))]
Dbit,
__Unknown__(String),
}
impl Default for CreditDebitCode {
fn default() -> CreditDebitCode {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for CreditDebitCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct CurrencyToBuyOrSell1Choice {
#[yaserde(rename = "CcyToBuy")]
#[cfg_attr(feature = "serde", serde(rename = "CcyToBuy"))]
pub ccy_to_buy: Option<ActiveCurrencyCode>,
#[yaserde(rename = "CcyToSell")]
#[cfg_attr(feature = "serde", serde(rename = "CcyToSell"))]
pub ccy_to_sell: Option<ActiveCurrencyCode>,
}
impl Validate for CurrencyToBuyOrSell1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct DateAndDateTime1Choice {
#[yaserde(rename = "Dt")]
#[cfg_attr(feature = "serde", serde(rename = "Dt"))]
pub dt: Option<Isodate>,
#[yaserde(rename = "DtTm")]
#[cfg_attr(feature = "serde", serde(rename = "DtTm"))]
pub dt_tm: Option<IsodateTime>,
}
impl Validate for DateAndDateTime1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct DateTimePeriod1 {
#[yaserde(rename = "FrDtTm")]
#[cfg_attr(feature = "serde", serde(rename = "FrDtTm"))]
pub fr_dt_tm: IsodateTime,
#[yaserde(rename = "ToDtTm")]
#[cfg_attr(feature = "serde", serde(rename = "ToDtTm"))]
pub to_dt_tm: IsodateTime,
}
impl Validate for DateTimePeriod1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct DateTimePeriod1Choice {
#[yaserde(rename = "FrDtTm")]
#[cfg_attr(feature = "serde", serde(rename = "FrDtTm"))]
pub fr_dt_tm: Option<IsodateTime>,
#[yaserde(rename = "ToDtTm")]
#[cfg_attr(feature = "serde", serde(rename = "ToDtTm"))]
pub to_dt_tm: Option<IsodateTime>,
#[yaserde(rename = "DtTmRg")]
#[cfg_attr(feature = "serde", serde(rename = "DtTmRg"))]
pub dt_tm_rg: Option<DateTimePeriod1>,
}
impl Validate for DateTimePeriod1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct DecimalNumber (pub String);
crate::simple_type!(DecimalNumber);
impl Validate for DecimalNumber {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum DeliveryReceiptType2Code {
#[yaserde(rename = "FREE")]
#[cfg_attr(feature = "serde", serde(rename = "FREE"))]
Free,
#[yaserde(rename = "APMT")]
#[cfg_attr(feature = "serde", serde(rename = "APMT"))]
Apmt,
__Unknown__(String),
}
impl Default for DeliveryReceiptType2Code {
fn default() -> DeliveryReceiptType2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for DeliveryReceiptType2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct Document {
#[yaserde(rename = "SctiesTradConfStsAdvc")]
#[cfg_attr(feature = "serde", serde(rename = "SctiesTradConfStsAdvc"))]
pub scties_trad_conf_sts_advc: SecuritiesTradeConfirmationStatusAdviceV04,
}
impl Validate for Document {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct DocumentNumber17Choice {
#[yaserde(rename = "ShrtNb")]
#[cfg_attr(feature = "serde", serde(rename = "ShrtNb"))]
pub shrt_nb: Option<Exact3NumericText>,
#[yaserde(rename = "LngNb")]
#[cfg_attr(feature = "serde", serde(rename = "LngNb"))]
pub lng_nb: Option<Iso20022MessageIdentificationText>,
#[yaserde(rename = "PrtryNb")]
#[cfg_attr(feature = "serde", serde(rename = "PrtryNb"))]
pub prtry_nb: Option<GenericIdentification30>,
}
impl Validate for DocumentNumber17Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum EucapitalGain2Code {
#[yaserde(rename = "EUSI")]
#[cfg_attr(feature = "serde", serde(rename = "EUSI"))]
Eusi,
#[yaserde(rename = "EUSO")]
#[cfg_attr(feature = "serde", serde(rename = "EUSO"))]
Euso,
#[yaserde(rename = "UKWN")]
#[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
Ukwn,
__Unknown__(String),
}
impl Default for EucapitalGain2Code {
fn default() -> EucapitalGain2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for EucapitalGain2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct EucapitalGainType3Choice {
#[yaserde(rename = "EUCptlGn")]
#[cfg_attr(feature = "serde", serde(rename = "EUCptlGn"))]
pub eucptl_gn: Option<EucapitalGain2Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for EucapitalGainType3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum Eligibility1Code {
#[yaserde(rename = "ELIG")]
#[cfg_attr(feature = "serde", serde(rename = "ELIG"))]
Elig,
#[yaserde(rename = "RETL")]
#[cfg_attr(feature = "serde", serde(rename = "RETL"))]
Retl,
#[yaserde(rename = "PROF")]
#[cfg_attr(feature = "serde", serde(rename = "PROF"))]
Prof,
__Unknown__(String),
}
impl Default for Eligibility1Code {
fn default() -> Eligibility1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for Eligibility1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Exact3NumericText (pub String);
crate::simple_type!(Exact3NumericText);
impl Validate for Exact3NumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Exact4AlphaNumericText (pub String);
crate::simple_type!(Exact4AlphaNumericText);
impl Validate for Exact4AlphaNumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ExternalFinancialInstrumentIdentificationType1Code (pub String);
crate::simple_type!(ExternalFinancialInstrumentIdentificationType1Code);
impl Validate for ExternalFinancialInstrumentIdentificationType1Code {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 4 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 4 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ExternalTradeTransactionCondition1Code (pub String);
crate::simple_type!(ExternalTradeTransactionCondition1Code);
impl Validate for ExternalTradeTransactionCondition1Code {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 4 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 4 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct FinancialInstrumentQuantity1Choice {
#[yaserde(rename = "Unit")]
#[cfg_attr(feature = "serde", serde(rename = "Unit"))]
pub unit: Option<DecimalNumber>,
#[yaserde(rename = "FaceAmt")]
#[cfg_attr(feature = "serde", serde(rename = "FaceAmt"))]
pub face_amt: Option<ImpliedCurrencyAndAmount>,
#[yaserde(rename = "AmtsdVal")]
#[cfg_attr(feature = "serde", serde(rename = "AmtsdVal"))]
pub amtsd_val: Option<ImpliedCurrencyAndAmount>,
}
impl Validate for FinancialInstrumentQuantity1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct ForeignExchangeTerms18 {
#[yaserde(rename = "UnitCcy")]
#[cfg_attr(feature = "serde", serde(rename = "UnitCcy"))]
pub unit_ccy: ActiveCurrencyCode,
#[yaserde(rename = "QtdCcy")]
#[cfg_attr(feature = "serde", serde(rename = "QtdCcy"))]
pub qtd_ccy: ActiveCurrencyCode,
#[yaserde(rename = "XchgRate")]
#[cfg_attr(feature = "serde", serde(rename = "XchgRate"))]
pub xchg_rate: BaseOneRate,
#[yaserde(rename = "ConvtdAmt")]
#[cfg_attr(feature = "serde", serde(rename = "ConvtdAmt"))]
pub convtd_amt: ActiveCurrencyAndAmount,
}
impl Validate for ForeignExchangeTerms18 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct GenericIdentification30 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Exact4AlphaNumericText,
#[yaserde(rename = "Issr")]
#[cfg_attr(feature = "serde", serde(rename = "Issr"))]
pub issr: Max35Text,
#[yaserde(rename = "SchmeNm")]
#[cfg_attr(feature = "serde", serde(rename = "SchmeNm"))]
pub schme_nm: Max35Text,
}
impl Validate for GenericIdentification30 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct GenericIdentification36 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max35Text,
#[yaserde(rename = "Issr")]
#[cfg_attr(feature = "serde", serde(rename = "Issr"))]
pub issr: Max35Text,
#[yaserde(rename = "SchmeNm")]
#[cfg_attr(feature = "serde", serde(rename = "SchmeNm"))]
pub schme_nm: Max35Text,
}
impl Validate for GenericIdentification36 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct GenericIdentification37 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max35Text,
#[yaserde(rename = "Issr")]
#[cfg_attr(feature = "serde", serde(rename = "Issr"))]
pub issr: Max35Text,
}
impl Validate for GenericIdentification37 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Iban2007Identifier (pub String);
crate::simple_type!(Iban2007Identifier);
impl Validate for Iban2007Identifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Isinoct2015Identifier (pub String);
crate::simple_type!(Isinoct2015Identifier);
impl Validate for Isinoct2015Identifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Iso20022MessageIdentificationText (pub String);
crate::simple_type!(Iso20022MessageIdentificationText);
impl Validate for Iso20022MessageIdentificationText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Isodate (pub String);
crate::simple_type!(Isodate);
impl Validate for Isodate {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct IsodateTime (pub String);
crate::simple_type!(IsodateTime);
impl Validate for IsodateTime {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct IdentificationReference16Choice {
#[yaserde(rename = "InstgPtyTxId")]
#[cfg_attr(feature = "serde", serde(rename = "InstgPtyTxId"))]
pub instg_pty_tx_id: Option<Max35Text>,
#[yaserde(rename = "ExctgPtyTxId")]
#[cfg_attr(feature = "serde", serde(rename = "ExctgPtyTxId"))]
pub exctg_pty_tx_id: Option<Max35Text>,
#[yaserde(rename = "MktInfrstrctrTxId")]
#[cfg_attr(feature = "serde", serde(rename = "MktInfrstrctrTxId"))]
pub mkt_infrstrctr_tx_id: Option<Max35Text>,
#[yaserde(rename = "ClntOrdrLkId")]
#[cfg_attr(feature = "serde", serde(rename = "ClntOrdrLkId"))]
pub clnt_ordr_lk_id: Option<Max35Text>,
#[yaserde(rename = "PoolId")]
#[cfg_attr(feature = "serde", serde(rename = "PoolId"))]
pub pool_id: Option<Max35Text>,
#[yaserde(rename = "BlckId")]
#[cfg_attr(feature = "serde", serde(rename = "BlckId"))]
pub blck_id: Option<Max35Text>,
#[yaserde(rename = "AllcnId")]
#[cfg_attr(feature = "serde", serde(rename = "AllcnId"))]
pub allcn_id: Option<Max35Text>,
#[yaserde(rename = "IndvAllcnId")]
#[cfg_attr(feature = "serde", serde(rename = "IndvAllcnId"))]
pub indv_allcn_id: Option<Max35Text>,
#[yaserde(rename = "ScndryAllcnId")]
#[cfg_attr(feature = "serde", serde(rename = "ScndryAllcnId"))]
pub scndry_allcn_id: Option<Max35Text>,
#[yaserde(rename = "IndxId")]
#[cfg_attr(feature = "serde", serde(rename = "IndxId"))]
pub indx_id: Option<Max35Text>,
#[yaserde(rename = "CmonId")]
#[cfg_attr(feature = "serde", serde(rename = "CmonId"))]
pub cmon_id: Option<Max35Text>,
#[yaserde(rename = "CmplcId")]
#[cfg_attr(feature = "serde", serde(rename = "CmplcId"))]
pub cmplc_id: Option<Max35Text>,
#[yaserde(rename = "CxlReqId")]
#[cfg_attr(feature = "serde", serde(rename = "CxlReqId"))]
pub cxl_req_id: Option<Max35Text>,
#[yaserde(rename = "CollTxId")]
#[cfg_attr(feature = "serde", serde(rename = "CollTxId"))]
pub coll_tx_id: Option<Max35Text>,
#[yaserde(rename = "UnqTxIdr")]
#[cfg_attr(feature = "serde", serde(rename = "UnqTxIdr"))]
pub unq_tx_idr: Option<Utiidentifier>,
}
impl Validate for IdentificationReference16Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct IdentificationSource3Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<ExternalFinancialInstrumentIdentificationType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<Max35Text>,
}
impl Validate for IdentificationSource3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct IdentificationType43Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<TypeOfIdentification2Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification36>,
}
impl Validate for IdentificationType43Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ImpliedCurrencyAndAmount (pub String);
crate::simple_type!(ImpliedCurrencyAndAmount);
impl Validate for ImpliedCurrencyAndAmount {
fn validate(&self) -> Result<(), String> {
if self.0 < "0".parse::<String>().unwrap() {
return Err(format!("MinInclusive validation error: invalid value of 0! \nExpected: 0 >= 0.\nActual: 0 == {}", self.0));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct InstructionProcessingReason3Choice {
#[yaserde(rename = "Rsn")]
#[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
pub rsn: Vec<RejectionReason67>,
#[yaserde(rename = "NoSpcfdRsn")]
#[cfg_attr(feature = "serde", serde(rename = "NoSpcfdRsn"))]
pub no_spcfd_rsn: Option<NoReasonCode>,
}
impl Validate for InstructionProcessingReason3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct InstructionProcessingReason4Choice {
#[yaserde(rename = "Rsn")]
#[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
pub rsn: Vec<RepairReason14>,
#[yaserde(rename = "NoSpcfdRsn")]
#[cfg_attr(feature = "serde", serde(rename = "NoSpcfdRsn"))]
pub no_spcfd_rsn: Option<NoReasonCode>,
}
impl Validate for InstructionProcessingReason4Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum InterestType2Code {
#[yaserde(rename = "CINT")]
#[cfg_attr(feature = "serde", serde(rename = "CINT"))]
Cint,
#[yaserde(rename = "XINT")]
#[cfg_attr(feature = "serde", serde(rename = "XINT"))]
Xint,
__Unknown__(String),
}
impl Default for InterestType2Code {
fn default() -> InterestType2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for InterestType2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct InvestorCapacity4Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<Eligibility1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for InvestorCapacity4Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct Linkages77 {
#[yaserde(rename = "MsgNb")]
#[cfg_attr(feature = "serde", serde(rename = "MsgNb"))]
pub msg_nb: DocumentNumber17Choice,
#[yaserde(rename = "Ref")]
#[cfg_attr(feature = "serde", serde(rename = "Ref"))]
pub _ref: IdentificationReference16Choice,
}
impl Validate for Linkages77 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Micidentifier (pub String);
crate::simple_type!(Micidentifier);
impl Validate for Micidentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct MarketIdentification3Choice {
#[yaserde(rename = "MktIdrCd")]
#[cfg_attr(feature = "serde", serde(rename = "MktIdrCd"))]
pub mkt_idr_cd: Option<Micidentifier>,
#[yaserde(rename = "Desc")]
#[cfg_attr(feature = "serde", serde(rename = "Desc"))]
pub desc: Option<Max35Text>,
}
impl Validate for MarketIdentification3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct MarketIdentification93 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: MarketIdentification3Choice,
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: MarketType18Choice,
}
impl Validate for MarketIdentification93 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct MarketIdentification97 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: MarketIdentification3Choice,
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: MarketType8Choice,
}
impl Validate for MarketIdentification97 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct MarketType18Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<MarketType6Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for MarketType18Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum MarketType2Code {
#[yaserde(rename = "PRIM")]
#[cfg_attr(feature = "serde", serde(rename = "PRIM"))]
Prim,
#[yaserde(rename = "SECM")]
#[cfg_attr(feature = "serde", serde(rename = "SECM"))]
Secm,
#[yaserde(rename = "OTCO")]
#[cfg_attr(feature = "serde", serde(rename = "OTCO"))]
Otco,
#[yaserde(rename = "VARI")]
#[cfg_attr(feature = "serde", serde(rename = "VARI"))]
Vari,
#[yaserde(rename = "EXCH")]
#[cfg_attr(feature = "serde", serde(rename = "EXCH"))]
Exch,
__Unknown__(String),
}
impl Default for MarketType2Code {
fn default() -> MarketType2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for MarketType2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum MarketType6Code {
#[yaserde(rename = "OTCO")]
#[cfg_attr(feature = "serde", serde(rename = "OTCO"))]
Otco,
#[yaserde(rename = "VARI")]
#[cfg_attr(feature = "serde", serde(rename = "VARI"))]
Vari,
#[yaserde(rename = "EXCH")]
#[cfg_attr(feature = "serde", serde(rename = "EXCH"))]
Exch,
__Unknown__(String),
}
impl Default for MarketType6Code {
fn default() -> MarketType6Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for MarketType6Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct MarketType8Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<MarketType2Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for MarketType8Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct MatchingReason5Choice {
#[yaserde(rename = "Rsn")]
#[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
pub rsn: Vec<AllegementMatchingReason2>,
#[yaserde(rename = "NoSpcfdRsn")]
#[cfg_attr(feature = "serde", serde(rename = "NoSpcfdRsn"))]
pub no_spcfd_rsn: Option<NoReasonCode>,
}
impl Validate for MatchingReason5Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct MatchingReason6Choice {
#[yaserde(rename = "Rsn")]
#[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
pub rsn: Vec<UnmatchedReason23>,
#[yaserde(rename = "NoSpcfdRsn")]
#[cfg_attr(feature = "serde", serde(rename = "NoSpcfdRsn"))]
pub no_spcfd_rsn: Option<NoReasonCode>,
}
impl Validate for MatchingReason6Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum MatchingStatus1Code {
#[yaserde(rename = "MACH")]
#[cfg_attr(feature = "serde", serde(rename = "MACH"))]
Mach,
#[yaserde(rename = "NMAT")]
#[cfg_attr(feature = "serde", serde(rename = "NMAT"))]
Nmat,
__Unknown__(String),
}
impl Default for MatchingStatus1Code {
fn default() -> MatchingStatus1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for MatchingStatus1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct MatchingStatus27Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<MatchingStatus1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for MatchingStatus27Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct MatchingStatus35Choice {
#[yaserde(rename = "Mtchd")]
#[cfg_attr(feature = "serde", serde(rename = "Mtchd"))]
pub mtchd: Option<ProprietaryReason4>,
#[yaserde(rename = "MtchdWthTlrnce")]
#[cfg_attr(feature = "serde", serde(rename = "MtchdWthTlrnce"))]
pub mtchd_wth_tlrnce: Option<ProprietaryReason4>,
#[yaserde(rename = "MtchgAllgd")]
#[cfg_attr(feature = "serde", serde(rename = "MtchgAllgd"))]
pub mtchg_allgd: Option<MatchingReason5Choice>,
#[yaserde(rename = "Umtchd")]
#[cfg_attr(feature = "serde", serde(rename = "Umtchd"))]
pub umtchd: Option<MatchingReason6Choice>,
#[yaserde(rename = "PrtrySts")]
#[cfg_attr(feature = "serde", serde(rename = "PrtrySts"))]
pub prtry_sts: Option<ProprietaryStatusAndReason6>,
}
impl Validate for MatchingStatus35Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max140Text (pub String);
crate::simple_type!(Max140Text);
impl Validate for Max140Text {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 140 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 140 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max16Text (pub String);
crate::simple_type!(Max16Text);
impl Validate for Max16Text {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 16 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 16 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max210Text (pub String);
crate::simple_type!(Max210Text);
impl Validate for Max210Text {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 210 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 210 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max34Text (pub String);
crate::simple_type!(Max34Text);
impl Validate for Max34Text {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 34 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 34 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max350Text (pub String);
crate::simple_type!(Max350Text);
impl Validate for Max350Text {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 350 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 350 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max35Text (pub String);
crate::simple_type!(Max35Text);
impl Validate for Max35Text {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 35 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 35 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max3Number (pub String);
crate::simple_type!(Max3Number);
impl Validate for Max3Number {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max70Text (pub String);
crate::simple_type!(Max70Text);
impl Validate for Max70Text {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 70 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 70 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct NameAndAddress13 {
#[yaserde(rename = "Nm")]
#[cfg_attr(feature = "serde", serde(rename = "Nm"))]
pub nm: Max350Text,
#[yaserde(rename = "Adr")]
#[cfg_attr(feature = "serde", serde(rename = "Adr"))]
pub adr: PostalAddress8,
}
impl Validate for NameAndAddress13 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum NoReasonCode {
#[yaserde(rename = "NORE")]
#[cfg_attr(feature = "serde", serde(rename = "NORE"))]
Nore,
__Unknown__(String),
}
impl Default for NoReasonCode {
fn default() -> NoReasonCode {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for NoReasonCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct Order23 {
#[yaserde(rename = "BizPrcTp")]
#[cfg_attr(feature = "serde", serde(rename = "BizPrcTp"))]
pub biz_prc_tp: BusinessProcessType2Choice,
#[yaserde(rename = "OrdrId")]
#[cfg_attr(feature = "serde", serde(rename = "OrdrId"))]
pub ordr_id: Vec<Max35Text>,
#[yaserde(rename = "ClntOrdrId")]
#[cfg_attr(feature = "serde", serde(rename = "ClntOrdrId"))]
pub clnt_ordr_id: Vec<Max35Text>,
#[yaserde(rename = "ScndryClntOrdrId")]
#[cfg_attr(feature = "serde", serde(rename = "ScndryClntOrdrId"))]
pub scndry_clnt_ordr_id: Vec<Max35Text>,
#[yaserde(rename = "ListId")]
#[cfg_attr(feature = "serde", serde(rename = "ListId"))]
pub list_id: Vec<Max35Text>,
#[yaserde(rename = "FinInstrmId")]
#[cfg_attr(feature = "serde", serde(rename = "FinInstrmId"))]
pub fin_instrm_id: SecurityIdentification19,
#[yaserde(rename = "Sd")]
#[cfg_attr(feature = "serde", serde(rename = "Sd"))]
pub sd: Side3Code,
#[yaserde(rename = "Pmt")]
#[cfg_attr(feature = "serde", serde(rename = "Pmt"))]
pub pmt: DeliveryReceiptType2Code,
#[yaserde(rename = "TradTxTp")]
#[cfg_attr(feature = "serde", serde(rename = "TradTxTp"))]
pub trad_tx_tp: TradeType4Choice,
#[yaserde(rename = "TradTxCond")]
#[cfg_attr(feature = "serde", serde(rename = "TradTxCond"))]
pub trad_tx_cond: Vec<TradeTransactionCondition9Choice>,
#[yaserde(rename = "PreAdvc")]
#[cfg_attr(feature = "serde", serde(rename = "PreAdvc"))]
pub pre_advc: YesNoIndicator,
#[yaserde(rename = "PlcOfTrad")]
#[cfg_attr(feature = "serde", serde(rename = "PlcOfTrad"))]
pub plc_of_trad: MarketIdentification93,
#[yaserde(rename = "OrdrBookgDt")]
#[cfg_attr(feature = "serde", serde(rename = "OrdrBookgDt"))]
pub ordr_bookg_dt: Isodate,
#[yaserde(rename = "TradOrgtnDt")]
#[cfg_attr(feature = "serde", serde(rename = "TradOrgtnDt"))]
pub trad_orgtn_dt: IsodateTime,
#[yaserde(rename = "TradDt")]
#[cfg_attr(feature = "serde", serde(rename = "TradDt"))]
pub trad_dt: TradeDate7Choice,
#[yaserde(rename = "PrcgDt")]
#[cfg_attr(feature = "serde", serde(rename = "PrcgDt"))]
pub prcg_dt: TradeDate7Choice,
#[yaserde(rename = "SttlmDt")]
#[cfg_attr(feature = "serde", serde(rename = "SttlmDt"))]
pub sttlm_dt: SettlementDate16Choice,
#[yaserde(rename = "NAVDt")]
#[cfg_attr(feature = "serde", serde(rename = "NAVDt"))]
pub nav_dt: DateAndDateTime1Choice,
#[yaserde(rename = "PrtlFillDtls")]
#[cfg_attr(feature = "serde", serde(rename = "PrtlFillDtls"))]
pub prtl_fill_dtls: Vec<PartialFill4>,
#[yaserde(rename = "ConfQty")]
#[cfg_attr(feature = "serde", serde(rename = "ConfQty"))]
pub conf_qty: Quantity6Choice,
#[yaserde(rename = "QtyBrkdwn")]
#[cfg_attr(feature = "serde", serde(rename = "QtyBrkdwn"))]
pub qty_brkdwn: Vec<QuantityBreakdown76>,
#[yaserde(rename = "GrssTradAmt")]
#[cfg_attr(feature = "serde", serde(rename = "GrssTradAmt"))]
pub grss_trad_amt: AmountAndDirection29,
#[yaserde(rename = "DealPric")]
#[cfg_attr(feature = "serde", serde(rename = "DealPric"))]
pub deal_pric: Price14,
#[yaserde(rename = "TpOfPric")]
#[cfg_attr(feature = "serde", serde(rename = "TpOfPric"))]
pub tp_of_pric: TypeOfPrice47Choice,
#[yaserde(rename = "CshMrgn")]
#[cfg_attr(feature = "serde", serde(rename = "CshMrgn"))]
pub csh_mrgn: CashMarginOrder1Code,
#[yaserde(rename = "Comssn")]
#[cfg_attr(feature = "serde", serde(rename = "Comssn"))]
pub comssn: Commission25,
#[yaserde(rename = "NbOfDaysAcrd")]
#[cfg_attr(feature = "serde", serde(rename = "NbOfDaysAcrd"))]
pub nb_of_days_acrd: Max3Number,
#[yaserde(rename = "GvUpNbOfDays")]
#[cfg_attr(feature = "serde", serde(rename = "GvUpNbOfDays"))]
pub gv_up_nb_of_days: Max3Number,
#[yaserde(rename = "IntrstTp")]
#[cfg_attr(feature = "serde", serde(rename = "IntrstTp"))]
pub intrst_tp: InterestType2Code,
#[yaserde(rename = "AcrdIntrstPctg")]
#[cfg_attr(feature = "serde", serde(rename = "AcrdIntrstPctg"))]
pub acrd_intrst_pctg: PercentageRate,
#[yaserde(rename = "TradRgltryCondsTp")]
#[cfg_attr(feature = "serde", serde(rename = "TradRgltryCondsTp"))]
pub trad_rgltry_conds_tp: TradeRegulatoryConditions1Code,
#[yaserde(rename = "CcyToBuyOrSell")]
#[cfg_attr(feature = "serde", serde(rename = "CcyToBuyOrSell"))]
pub ccy_to_buy_or_sell: CurrencyToBuyOrSell1Choice,
#[yaserde(rename = "OrdrOrgtrElgblty")]
#[cfg_attr(feature = "serde", serde(rename = "OrdrOrgtrElgblty"))]
pub ordr_orgtr_elgblty: Eligibility1Code,
#[yaserde(rename = "PosFct")]
#[cfg_attr(feature = "serde", serde(rename = "PosFct"))]
pub pos_fct: PositionEffect2Code,
#[yaserde(rename = "DerivCvrd")]
#[cfg_attr(feature = "serde", serde(rename = "DerivCvrd"))]
pub deriv_cvrd: YesNoIndicator,
#[yaserde(rename = "ChrgTaxBsisTp")]
#[cfg_attr(feature = "serde", serde(rename = "ChrgTaxBsisTp"))]
pub chrg_tax_bsis_tp: ChargeTaxBasisType2Choice,
#[yaserde(rename = "CptlGnTp")]
#[cfg_attr(feature = "serde", serde(rename = "CptlGnTp"))]
pub cptl_gn_tp: EucapitalGainType3Choice,
#[yaserde(rename = "MtchSts")]
#[cfg_attr(feature = "serde", serde(rename = "MtchSts"))]
pub mtch_sts: MatchingStatus27Choice,
#[yaserde(rename = "CallInTp")]
#[cfg_attr(feature = "serde", serde(rename = "CallInTp"))]
pub call_in_tp: CallIn1Code,
#[yaserde(rename = "YldTp")]
#[cfg_attr(feature = "serde", serde(rename = "YldTp"))]
pub yld_tp: YieldCalculation7,
#[yaserde(rename = "Rptg")]
#[cfg_attr(feature = "serde", serde(rename = "Rptg"))]
pub rptg: Vec<Reporting6Choice>,
#[yaserde(rename = "AddtlPhysOrRegnDtls")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlPhysOrRegnDtls"))]
pub addtl_phys_or_regn_dtls: RegistrationParameters3,
#[yaserde(rename = "AddtlTradInstrPrcgInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlTradInstrPrcgInf"))]
pub addtl_trad_instr_prcg_inf: Max350Text,
#[yaserde(rename = "AcrdIntrstAmt")]
#[cfg_attr(feature = "serde", serde(rename = "AcrdIntrstAmt"))]
pub acrd_intrst_amt: AmountAndDirection29,
}
impl Validate for Order23 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct OriginalAndCurrentQuantities1 {
#[yaserde(rename = "FaceAmt")]
#[cfg_attr(feature = "serde", serde(rename = "FaceAmt"))]
pub face_amt: ImpliedCurrencyAndAmount,
#[yaserde(rename = "AmtsdVal")]
#[cfg_attr(feature = "serde", serde(rename = "AmtsdVal"))]
pub amtsd_val: ImpliedCurrencyAndAmount,
}
impl Validate for OriginalAndCurrentQuantities1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct OtherIdentification1 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max35Text,
#[yaserde(rename = "Sfx")]
#[cfg_attr(feature = "serde", serde(rename = "Sfx"))]
pub sfx: Max16Text,
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: IdentificationSource3Choice,
}
impl Validate for OtherIdentification1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct PartialFill4 {
#[yaserde(rename = "ConfQty")]
#[cfg_attr(feature = "serde", serde(rename = "ConfQty"))]
pub conf_qty: Quantity6Choice,
#[yaserde(rename = "DealPric")]
#[cfg_attr(feature = "serde", serde(rename = "DealPric"))]
pub deal_pric: Price14,
#[yaserde(rename = "TradDt")]
#[cfg_attr(feature = "serde", serde(rename = "TradDt"))]
pub trad_dt: TradeDate7Choice,
#[yaserde(rename = "PlcOfTrad")]
#[cfg_attr(feature = "serde", serde(rename = "PlcOfTrad"))]
pub plc_of_trad: MarketIdentification97,
#[yaserde(rename = "OrgnlOrdrdQty")]
#[cfg_attr(feature = "serde", serde(rename = "OrgnlOrdrdQty"))]
pub orgnl_ordrd_qty: QuantityOrAmount2Choice,
#[yaserde(rename = "PrevslyExctdQty")]
#[cfg_attr(feature = "serde", serde(rename = "PrevslyExctdQty"))]
pub prevsly_exctd_qty: QuantityOrAmount2Choice,
#[yaserde(rename = "RmngQty")]
#[cfg_attr(feature = "serde", serde(rename = "RmngQty"))]
pub rmng_qty: QuantityOrAmount2Choice,
#[yaserde(rename = "MtchIncrmtQty")]
#[cfg_attr(feature = "serde", serde(rename = "MtchIncrmtQty"))]
pub mtch_incrmt_qty: QuantityOrAmount2Choice,
}
impl Validate for PartialFill4 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct PartyIdentification240Choice {
#[yaserde(rename = "BIC")]
#[cfg_attr(feature = "serde", serde(rename = "BIC"))]
pub bic: Option<AnyBICDec2014Identifier>,
#[yaserde(rename = "PrtryId")]
#[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
pub prtry_id: Option<GenericIdentification36>,
#[yaserde(rename = "NmAndAdr")]
#[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
pub nm_and_adr: Option<NameAndAddress13>,
}
impl Validate for PartyIdentification240Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct PartyIdentification244Choice {
#[yaserde(rename = "BIC")]
#[cfg_attr(feature = "serde", serde(rename = "BIC"))]
pub bic: Option<AnyBICDec2014Identifier>,
#[yaserde(rename = "NmAndAdr")]
#[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
pub nm_and_adr: Option<NameAndAddress13>,
#[yaserde(rename = "Ctry")]
#[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
pub ctry: Option<CountryCode>,
}
impl Validate for PartyIdentification244Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct PartyIdentification267 {
#[yaserde(rename = "BIC")]
#[cfg_attr(feature = "serde", serde(rename = "BIC"))]
pub bic: AnyBICDec2014Identifier,
#[yaserde(rename = "PrtryId")]
#[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
pub prtry_id: GenericIdentification36,
#[yaserde(rename = "NmAndAdr")]
#[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
pub nm_and_adr: NameAndAddress13,
}
impl Validate for PartyIdentification267 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct PartyIdentification268 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: PartyIdentification244Choice,
#[yaserde(rename = "AltrnId")]
#[cfg_attr(feature = "serde", serde(rename = "AltrnId"))]
pub altrn_id: AlternatePartyIdentification8,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: PartyTextInformation1,
}
impl Validate for PartyIdentification268 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct PartyIdentificationAndAccount218 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: PartyIdentification240Choice,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: Max350Text,
#[yaserde(rename = "AltrnId")]
#[cfg_attr(feature = "serde", serde(rename = "AltrnId"))]
pub altrn_id: AlternatePartyIdentification8,
#[yaserde(rename = "SfkpgAcct")]
#[cfg_attr(feature = "serde", serde(rename = "SfkpgAcct"))]
pub sfkpg_acct: Max35Text,
}
impl Validate for PartyIdentificationAndAccount218 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct PartyIdentificationAndAccount220 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: PartyIdentification240Choice,
#[yaserde(rename = "SfkpgAcct")]
#[cfg_attr(feature = "serde", serde(rename = "SfkpgAcct"))]
pub sfkpg_acct: Max35Text,
#[yaserde(rename = "CshAcct")]
#[cfg_attr(feature = "serde", serde(rename = "CshAcct"))]
pub csh_acct: CashAccountIdentification5Choice,
#[yaserde(rename = "PrcgId")]
#[cfg_attr(feature = "serde", serde(rename = "PrcgId"))]
pub prcg_id: Max35Text,
#[yaserde(rename = "CtryOfRes")]
#[cfg_attr(feature = "serde", serde(rename = "CtryOfRes"))]
pub ctry_of_res: CountryCode,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: PartyTextInformation1,
#[yaserde(rename = "AltrnId")]
#[cfg_attr(feature = "serde", serde(rename = "AltrnId"))]
pub altrn_id: AlternatePartyIdentification8,
}
impl Validate for PartyIdentificationAndAccount220 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct PartyTextInformation1 {
#[yaserde(rename = "DclrtnDtls")]
#[cfg_attr(feature = "serde", serde(rename = "DclrtnDtls"))]
pub dclrtn_dtls: Max350Text,
#[yaserde(rename = "PtyCtctDtls")]
#[cfg_attr(feature = "serde", serde(rename = "PtyCtctDtls"))]
pub pty_ctct_dtls: Max140Text,
#[yaserde(rename = "RegnDtls")]
#[cfg_attr(feature = "serde", serde(rename = "RegnDtls"))]
pub regn_dtls: Max350Text,
}
impl Validate for PartyTextInformation1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct PartyTextInformation5 {
#[yaserde(rename = "DclrtnDtls")]
#[cfg_attr(feature = "serde", serde(rename = "DclrtnDtls"))]
pub dclrtn_dtls: Max350Text,
#[yaserde(rename = "PtyCtctDtls")]
#[cfg_attr(feature = "serde", serde(rename = "PtyCtctDtls"))]
pub pty_ctct_dtls: Max140Text,
}
impl Validate for PartyTextInformation5 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct PendingProcessing2Choice {
#[yaserde(rename = "NoSpcfdRsn")]
#[cfg_attr(feature = "serde", serde(rename = "NoSpcfdRsn"))]
pub no_spcfd_rsn: Option<NoReasonCode>,
#[yaserde(rename = "Rsn")]
#[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
pub rsn: Vec<AwaitingAffirmationReason2>,
}
impl Validate for PendingProcessing2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct PercentageRate (pub String);
crate::simple_type!(PercentageRate);
impl Validate for PercentageRate {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum PositionEffect2Code {
#[yaserde(rename = "OPEN")]
#[cfg_attr(feature = "serde", serde(rename = "OPEN"))]
Open,
#[yaserde(rename = "CLOS")]
#[cfg_attr(feature = "serde", serde(rename = "CLOS"))]
Clos,
#[yaserde(rename = "ROLL")]
#[cfg_attr(feature = "serde", serde(rename = "ROLL"))]
Roll,
#[yaserde(rename = "FIFO")]
#[cfg_attr(feature = "serde", serde(rename = "FIFO"))]
Fifo,
#[yaserde(rename = "CLOA")]
#[cfg_attr(feature = "serde", serde(rename = "CLOA"))]
Cloa,
__Unknown__(String),
}
impl Default for PositionEffect2Code {
fn default() -> PositionEffect2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for PositionEffect2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct PostalAddress8 {
#[yaserde(rename = "AdrTp")]
#[cfg_attr(feature = "serde", serde(rename = "AdrTp"))]
pub adr_tp: AddressType2Code,
#[yaserde(rename = "AdrLine")]
#[cfg_attr(feature = "serde", serde(rename = "AdrLine"))]
pub adr_line: Vec<Max70Text>,
#[yaserde(rename = "StrtNm")]
#[cfg_attr(feature = "serde", serde(rename = "StrtNm"))]
pub strt_nm: Max70Text,
#[yaserde(rename = "BldgNb")]
#[cfg_attr(feature = "serde", serde(rename = "BldgNb"))]
pub bldg_nb: Max16Text,
#[yaserde(rename = "PstCd")]
#[cfg_attr(feature = "serde", serde(rename = "PstCd"))]
pub pst_cd: Max16Text,
#[yaserde(rename = "TwnNm")]
#[cfg_attr(feature = "serde", serde(rename = "TwnNm"))]
pub twn_nm: Max35Text,
#[yaserde(rename = "CtrySubDvsn")]
#[cfg_attr(feature = "serde", serde(rename = "CtrySubDvsn"))]
pub ctry_sub_dvsn: Max35Text,
#[yaserde(rename = "Ctry")]
#[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
pub ctry: CountryCode,
}
impl Validate for PostalAddress8 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct Price14 {
#[yaserde(rename = "Val")]
#[cfg_attr(feature = "serde", serde(rename = "Val"))]
pub val: PriceRateOrAmount3Choice,
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: PriceValueType7Code,
}
impl Validate for Price14 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct PriceRateOrAmount3Choice {
#[yaserde(rename = "Rate")]
#[cfg_attr(feature = "serde", serde(rename = "Rate"))]
pub rate: Option<PercentageRate>,
#[yaserde(rename = "Amt")]
#[cfg_attr(feature = "serde", serde(rename = "Amt"))]
pub amt: Option<ActiveOrHistoricCurrencyAnd13DecimalAmount>,
}
impl Validate for PriceRateOrAmount3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum PriceValueType7Code {
#[yaserde(rename = "DISC")]
#[cfg_attr(feature = "serde", serde(rename = "DISC"))]
Disc,
#[yaserde(rename = "PREM")]
#[cfg_attr(feature = "serde", serde(rename = "PREM"))]
Prem,
#[yaserde(rename = "PARV")]
#[cfg_attr(feature = "serde", serde(rename = "PARV"))]
Parv,
#[yaserde(rename = "YIEL")]
#[cfg_attr(feature = "serde", serde(rename = "YIEL"))]
Yiel,
#[yaserde(rename = "SPRE")]
#[cfg_attr(feature = "serde", serde(rename = "SPRE"))]
Spre,
#[yaserde(rename = "PEUN")]
#[cfg_attr(feature = "serde", serde(rename = "PEUN"))]
Peun,
#[yaserde(rename = "ABSO")]
#[cfg_attr(feature = "serde", serde(rename = "ABSO"))]
Abso,
#[yaserde(rename = "TEDP")]
#[cfg_attr(feature = "serde", serde(rename = "TEDP"))]
Tedp,
#[yaserde(rename = "TEDY")]
#[cfg_attr(feature = "serde", serde(rename = "TEDY"))]
Tedy,
#[yaserde(rename = "FICT")]
#[cfg_attr(feature = "serde", serde(rename = "FICT"))]
Fict,
#[yaserde(rename = "VACT")]
#[cfg_attr(feature = "serde", serde(rename = "VACT"))]
Vact,
#[yaserde(rename = "PRCT")]
#[cfg_attr(feature = "serde", serde(rename = "PRCT"))]
Prct,
#[yaserde(rename = "ACTU")]
#[cfg_attr(feature = "serde", serde(rename = "ACTU"))]
Actu,
__Unknown__(String),
}
impl Default for PriceValueType7Code {
fn default() -> PriceValueType7Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for PriceValueType7Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct ProcessingStatus98Choice {
#[yaserde(rename = "AckdAccptd")]
#[cfg_attr(feature = "serde", serde(rename = "AckdAccptd"))]
pub ackd_accptd: Option<ProprietaryReason4>,
#[yaserde(rename = "AlrdyMtchdAndAffrmd")]
#[cfg_attr(feature = "serde", serde(rename = "AlrdyMtchdAndAffrmd"))]
pub alrdy_mtchd_and_affrmd: Option<ProprietaryReason4>,
#[yaserde(rename = "DfltActn")]
#[cfg_attr(feature = "serde", serde(rename = "DfltActn"))]
pub dflt_actn: Option<ProprietaryReason4>,
#[yaserde(rename = "Done")]
#[cfg_attr(feature = "serde", serde(rename = "Done"))]
pub done: Option<ProprietaryReason4>,
#[yaserde(rename = "ForcdRjctn")]
#[cfg_attr(feature = "serde", serde(rename = "ForcdRjctn"))]
pub forcd_rjctn: Option<ProprietaryReason4>,
#[yaserde(rename = "FullyExctdConfSnt")]
#[cfg_attr(feature = "serde", serde(rename = "FullyExctdConfSnt"))]
pub fully_exctd_conf_snt: Option<ProprietaryReason4>,
#[yaserde(rename = "Futr")]
#[cfg_attr(feature = "serde", serde(rename = "Futr"))]
pub futr: Option<ProprietaryReason4>,
#[yaserde(rename = "Gnrtd")]
#[cfg_attr(feature = "serde", serde(rename = "Gnrtd"))]
pub gnrtd: Option<ProprietaryReason4>,
#[yaserde(rename = "InRpr")]
#[cfg_attr(feature = "serde", serde(rename = "InRpr"))]
pub in_rpr: Option<InstructionProcessingReason4Choice>,
#[yaserde(rename = "NoInstr")]
#[cfg_attr(feature = "serde", serde(rename = "NoInstr"))]
pub no_instr: Option<ProprietaryReason4>,
#[yaserde(rename = "OpnOrdr")]
#[cfg_attr(feature = "serde", serde(rename = "OpnOrdr"))]
pub opn_ordr: Option<ProprietaryReason4>,
#[yaserde(rename = "PdgPrcg")]
#[cfg_attr(feature = "serde", serde(rename = "PdgPrcg"))]
pub pdg_prcg: Option<PendingProcessing2Choice>,
#[yaserde(rename = "RcvdAtIntrmy")]
#[cfg_attr(feature = "serde", serde(rename = "RcvdAtIntrmy"))]
pub rcvd_at_intrmy: Option<ProprietaryReason4>,
#[yaserde(rename = "Rjctd")]
#[cfg_attr(feature = "serde", serde(rename = "Rjctd"))]
pub rjctd: Option<InstructionProcessingReason3Choice>,
#[yaserde(rename = "SttlmInstrSnt")]
#[cfg_attr(feature = "serde", serde(rename = "SttlmInstrSnt"))]
pub sttlm_instr_snt: Option<ProprietaryReason4>,
#[yaserde(rename = "StgInstr")]
#[cfg_attr(feature = "serde", serde(rename = "StgInstr"))]
pub stg_instr: Option<ProprietaryReason4>,
#[yaserde(rename = "TradgSspdByStockXchg")]
#[cfg_attr(feature = "serde", serde(rename = "TradgSspdByStockXchg"))]
pub tradg_sspd_by_stock_xchg: Option<ProprietaryReason4>,
#[yaserde(rename = "Trtd")]
#[cfg_attr(feature = "serde", serde(rename = "Trtd"))]
pub trtd: Option<ProprietaryReason4>,
#[yaserde(rename = "PrtrySts")]
#[cfg_attr(feature = "serde", serde(rename = "PrtrySts"))]
pub prtry_sts: Option<ProprietaryStatusAndReason6>,
}
impl Validate for ProcessingStatus98Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct ProprietaryReason4 {
#[yaserde(rename = "Rsn")]
#[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
pub rsn: GenericIdentification30,
#[yaserde(rename = "AddtlRsnInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlRsnInf"))]
pub addtl_rsn_inf: Max210Text,
}
impl Validate for ProprietaryReason4 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct ProprietaryStatusAndReason6 {
#[yaserde(rename = "PrtrySts")]
#[cfg_attr(feature = "serde", serde(rename = "PrtrySts"))]
pub prtry_sts: GenericIdentification30,
#[yaserde(rename = "PrtryRsn")]
#[cfg_attr(feature = "serde", serde(rename = "PrtryRsn"))]
pub prtry_rsn: Vec<ProprietaryReason4>,
}
impl Validate for ProprietaryStatusAndReason6 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct PurposeCode9Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<SecuritiesAccountPurposeType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for PurposeCode9Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct Quantity6Choice {
#[yaserde(rename = "Qty")]
#[cfg_attr(feature = "serde", serde(rename = "Qty"))]
pub qty: Option<FinancialInstrumentQuantity1Choice>,
#[yaserde(rename = "OrgnlAndCurFace")]
#[cfg_attr(feature = "serde", serde(rename = "OrgnlAndCurFace"))]
pub orgnl_and_cur_face: Option<OriginalAndCurrentQuantities1>,
}
impl Validate for Quantity6Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct QuantityBreakdown76 {
#[yaserde(rename = "LotNb")]
#[cfg_attr(feature = "serde", serde(rename = "LotNb"))]
pub lot_nb: GenericIdentification37,
#[yaserde(rename = "LotQty")]
#[cfg_attr(feature = "serde", serde(rename = "LotQty"))]
pub lot_qty: FinancialInstrumentQuantity1Choice,
#[yaserde(rename = "LotDtTm")]
#[cfg_attr(feature = "serde", serde(rename = "LotDtTm"))]
pub lot_dt_tm: DateAndDateTime1Choice,
#[yaserde(rename = "LotPric")]
#[cfg_attr(feature = "serde", serde(rename = "LotPric"))]
pub lot_pric: Price14,
}
impl Validate for QuantityBreakdown76 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct QuantityOrAmount2Choice {
#[yaserde(rename = "Qty")]
#[cfg_attr(feature = "serde", serde(rename = "Qty"))]
pub qty: Option<FinancialInstrumentQuantity1Choice>,
#[yaserde(rename = "Amt")]
#[cfg_attr(feature = "serde", serde(rename = "Amt"))]
pub amt: Option<ActiveCurrencyAndAmount>,
}
impl Validate for QuantityOrAmount2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct RegistrationParameters3 {
#[yaserde(rename = "CertfctnId")]
#[cfg_attr(feature = "serde", serde(rename = "CertfctnId"))]
pub certfctn_id: Max35Text,
#[yaserde(rename = "CertfctnDtTm")]
#[cfg_attr(feature = "serde", serde(rename = "CertfctnDtTm"))]
pub certfctn_dt_tm: DateAndDateTime1Choice,
#[yaserde(rename = "RegarAcct")]
#[cfg_attr(feature = "serde", serde(rename = "RegarAcct"))]
pub regar_acct: Max35Text,
#[yaserde(rename = "CertNb")]
#[cfg_attr(feature = "serde", serde(rename = "CertNb"))]
pub cert_nb: Vec<SecuritiesCertificate3>,
}
impl Validate for RegistrationParameters3 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct RejectionReason52Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<RejectionReason78Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for RejectionReason52Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct RejectionReason67 {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: RejectionReason52Choice,
#[yaserde(rename = "AddtlRsnInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlRsnInf"))]
pub addtl_rsn_inf: Max210Text,
}
impl Validate for RejectionReason67 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum RejectionReason78Code {
#[yaserde(rename = "ASTM")]
#[cfg_attr(feature = "serde", serde(rename = "ASTM"))]
Astm,
#[yaserde(rename = "BUSE")]
#[cfg_attr(feature = "serde", serde(rename = "BUSE"))]
Buse,
#[yaserde(rename = "CADE")]
#[cfg_attr(feature = "serde", serde(rename = "CADE"))]
Cade,
#[yaserde(rename = "COMC")]
#[cfg_attr(feature = "serde", serde(rename = "COMC"))]
Comc,
#[yaserde(rename = "DDAT")]
#[cfg_attr(feature = "serde", serde(rename = "DDAT"))]
Ddat,
#[yaserde(rename = "DDEA")]
#[cfg_attr(feature = "serde", serde(rename = "DDEA"))]
Ddea,
#[yaserde(rename = "DMON")]
#[cfg_attr(feature = "serde", serde(rename = "DMON"))]
Dmon,
#[yaserde(rename = "DQUA")]
#[cfg_attr(feature = "serde", serde(rename = "DQUA"))]
Dqua,
#[yaserde(rename = "DSEC")]
#[cfg_attr(feature = "serde", serde(rename = "DSEC"))]
Dsec,
#[yaserde(rename = "DTRD")]
#[cfg_attr(feature = "serde", serde(rename = "DTRD"))]
Dtrd,
#[yaserde(rename = "FEEE")]
#[cfg_attr(feature = "serde", serde(rename = "FEEE"))]
Feee,
#[yaserde(rename = "FORF")]
#[cfg_attr(feature = "serde", serde(rename = "FORF"))]
Forf,
#[yaserde(rename = "IEXE")]
#[cfg_attr(feature = "serde", serde(rename = "IEXE"))]
Iexe,
#[yaserde(rename = "IIND")]
#[cfg_attr(feature = "serde", serde(rename = "IIND"))]
Iind,
#[yaserde(rename = "INNA")]
#[cfg_attr(feature = "serde", serde(rename = "INNA"))]
Inna,
#[yaserde(rename = "NARR")]
#[cfg_attr(feature = "serde", serde(rename = "NARR"))]
Narr,
#[yaserde(rename = "NCRR")]
#[cfg_attr(feature = "serde", serde(rename = "NCRR"))]
Ncrr,
#[yaserde(rename = "ODNP")]
#[cfg_attr(feature = "serde", serde(rename = "ODNP"))]
Odnp,
#[yaserde(rename = "PLCE")]
#[cfg_attr(feature = "serde", serde(rename = "PLCE"))]
Plce,
#[yaserde(rename = "QUNP")]
#[cfg_attr(feature = "serde", serde(rename = "QUNP"))]
Qunp,
#[yaserde(rename = "REFE")]
#[cfg_attr(feature = "serde", serde(rename = "REFE"))]
Refe,
#[yaserde(rename = "CTRA")]
#[cfg_attr(feature = "serde", serde(rename = "CTRA"))]
Ctra,
#[yaserde(rename = "REPO")]
#[cfg_attr(feature = "serde", serde(rename = "REPO"))]
Repo,
#[yaserde(rename = "REPP")]
#[cfg_attr(feature = "serde", serde(rename = "REPP"))]
Repp,
#[yaserde(rename = "RERT")]
#[cfg_attr(feature = "serde", serde(rename = "RERT"))]
Rert,
#[yaserde(rename = "RSPR")]
#[cfg_attr(feature = "serde", serde(rename = "RSPR"))]
Rspr,
#[yaserde(rename = "SAFE")]
#[cfg_attr(feature = "serde", serde(rename = "SAFE"))]
Safe,
#[yaserde(rename = "SETR")]
#[cfg_attr(feature = "serde", serde(rename = "SETR"))]
Setr,
#[yaserde(rename = "SETS")]
#[cfg_attr(feature = "serde", serde(rename = "SETS"))]
Sets,
#[yaserde(rename = "TERM")]
#[cfg_attr(feature = "serde", serde(rename = "TERM"))]
Term,
#[yaserde(rename = "TNAR")]
#[cfg_attr(feature = "serde", serde(rename = "TNAR"))]
Tnar,
#[yaserde(rename = "TNIU")]
#[cfg_attr(feature = "serde", serde(rename = "TNIU"))]
Tniu,
#[yaserde(rename = "TQHI")]
#[cfg_attr(feature = "serde", serde(rename = "TQHI"))]
Tqhi,
#[yaserde(rename = "TQNP")]
#[cfg_attr(feature = "serde", serde(rename = "TQNP"))]
Tqnp,
#[yaserde(rename = "TXST")]
#[cfg_attr(feature = "serde", serde(rename = "TXST"))]
Txst,
#[yaserde(rename = "ULNK")]
#[cfg_attr(feature = "serde", serde(rename = "ULNK"))]
Ulnk,
#[yaserde(rename = "VASU")]
#[cfg_attr(feature = "serde", serde(rename = "VASU"))]
Vasu,
#[yaserde(rename = "INIR")]
#[cfg_attr(feature = "serde", serde(rename = "INIR"))]
Inir,
#[yaserde(rename = "OPNM")]
#[cfg_attr(feature = "serde", serde(rename = "OPNM"))]
Opnm,
#[yaserde(rename = "OPTY")]
#[cfg_attr(feature = "serde", serde(rename = "OPTY"))]
Opty,
#[yaserde(rename = "UKWN")]
#[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
Ukwn,
#[yaserde(rename = "EXLI")]
#[cfg_attr(feature = "serde", serde(rename = "EXLI"))]
Exli,
#[yaserde(rename = "INPR")]
#[cfg_attr(feature = "serde", serde(rename = "INPR"))]
Inpr,
#[yaserde(rename = "PRIC")]
#[cfg_attr(feature = "serde", serde(rename = "PRIC"))]
Pric,
#[yaserde(rename = "EQTY")]
#[cfg_attr(feature = "serde", serde(rename = "EQTY"))]
Eqty,
#[yaserde(rename = "SIDE")]
#[cfg_attr(feature = "serde", serde(rename = "SIDE"))]
Side,
#[yaserde(rename = "CADI")]
#[cfg_attr(feature = "serde", serde(rename = "CADI"))]
Cadi,
#[yaserde(rename = "CPTY")]
#[cfg_attr(feature = "serde", serde(rename = "CPTY"))]
Cpty,
#[yaserde(rename = "DISC")]
#[cfg_attr(feature = "serde", serde(rename = "DISC"))]
Disc,
#[yaserde(rename = "DISE")]
#[cfg_attr(feature = "serde", serde(rename = "DISE"))]
Dise,
#[yaserde(rename = "RESU")]
#[cfg_attr(feature = "serde", serde(rename = "RESU"))]
Resu,
#[yaserde(rename = "XRAT")]
#[cfg_attr(feature = "serde", serde(rename = "XRAT"))]
Xrat,
#[yaserde(rename = "ACRU")]
#[cfg_attr(feature = "serde", serde(rename = "ACRU"))]
Acru,
#[yaserde(rename = "GAMN")]
#[cfg_attr(feature = "serde", serde(rename = "GAMN"))]
Gamn,
#[yaserde(rename = "DFLT")]
#[cfg_attr(feature = "serde", serde(rename = "DFLT"))]
Dflt,
#[yaserde(rename = "FAIL")]
#[cfg_attr(feature = "serde", serde(rename = "FAIL"))]
Fail,
#[yaserde(rename = "INDT")]
#[cfg_attr(feature = "serde", serde(rename = "INDT"))]
Indt,
#[yaserde(rename = "OTHR")]
#[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
Othr,
#[yaserde(rename = "DEPT")]
#[cfg_attr(feature = "serde", serde(rename = "DEPT"))]
Dept,
#[yaserde(rename = "ICUS")]
#[cfg_attr(feature = "serde", serde(rename = "ICUS"))]
Icus,
#[yaserde(rename = "ICAG")]
#[cfg_attr(feature = "serde", serde(rename = "ICAG"))]
Icag,
__Unknown__(String),
}
impl Default for RejectionReason78Code {
fn default() -> RejectionReason78Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for RejectionReason78Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct RepairReason14 {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: RepairReason19Choice,
#[yaserde(rename = "AddtlRsnInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlRsnInf"))]
pub addtl_rsn_inf: Max210Text,
}
impl Validate for RepairReason14 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct RepairReason19Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<RepairReason7Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for RepairReason19Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum RepairReason7Code {
#[yaserde(rename = "ADEA")]
#[cfg_attr(feature = "serde", serde(rename = "ADEA"))]
Adea,
#[yaserde(rename = "BATC")]
#[cfg_attr(feature = "serde", serde(rename = "BATC"))]
Batc,
#[yaserde(rename = "BUSE")]
#[cfg_attr(feature = "serde", serde(rename = "BUSE"))]
Buse,
#[yaserde(rename = "CADE")]
#[cfg_attr(feature = "serde", serde(rename = "CADE"))]
Cade,
#[yaserde(rename = "CASH")]
#[cfg_attr(feature = "serde", serde(rename = "CASH"))]
Cash,
#[yaserde(rename = "CASY")]
#[cfg_attr(feature = "serde", serde(rename = "CASY"))]
Casy,
#[yaserde(rename = "COMC")]
#[cfg_attr(feature = "serde", serde(rename = "COMC"))]
Comc,
#[yaserde(rename = "DDAT")]
#[cfg_attr(feature = "serde", serde(rename = "DDAT"))]
Ddat,
#[yaserde(rename = "DDEA")]
#[cfg_attr(feature = "serde", serde(rename = "DDEA"))]
Ddea,
#[yaserde(rename = "DEPT")]
#[cfg_attr(feature = "serde", serde(rename = "DEPT"))]
Dept,
#[yaserde(rename = "DMON")]
#[cfg_attr(feature = "serde", serde(rename = "DMON"))]
Dmon,
#[yaserde(rename = "DQUA")]
#[cfg_attr(feature = "serde", serde(rename = "DQUA"))]
Dqua,
#[yaserde(rename = "DSEC")]
#[cfg_attr(feature = "serde", serde(rename = "DSEC"))]
Dsec,
#[yaserde(rename = "DTRD")]
#[cfg_attr(feature = "serde", serde(rename = "DTRD"))]
Dtrd,
#[yaserde(rename = "FEEE")]
#[cfg_attr(feature = "serde", serde(rename = "FEEE"))]
Feee,
#[yaserde(rename = "FORF")]
#[cfg_attr(feature = "serde", serde(rename = "FORF"))]
Forf,
#[yaserde(rename = "ICAG")]
#[cfg_attr(feature = "serde", serde(rename = "ICAG"))]
Icag,
#[yaserde(rename = "ICUS")]
#[cfg_attr(feature = "serde", serde(rename = "ICUS"))]
Icus,
#[yaserde(rename = "IEXE")]
#[cfg_attr(feature = "serde", serde(rename = "IEXE"))]
Iexe,
#[yaserde(rename = "IIND")]
#[cfg_attr(feature = "serde", serde(rename = "IIND"))]
Iind,
#[yaserde(rename = "INNA")]
#[cfg_attr(feature = "serde", serde(rename = "INNA"))]
Inna,
#[yaserde(rename = "LEOG")]
#[cfg_attr(feature = "serde", serde(rename = "LEOG"))]
Leog,
#[yaserde(rename = "NARR")]
#[cfg_attr(feature = "serde", serde(rename = "NARR"))]
Narr,
#[yaserde(rename = "NCRR")]
#[cfg_attr(feature = "serde", serde(rename = "NCRR"))]
Ncrr,
#[yaserde(rename = "NRGM")]
#[cfg_attr(feature = "serde", serde(rename = "NRGM"))]
Nrgm,
#[yaserde(rename = "NRGN")]
#[cfg_attr(feature = "serde", serde(rename = "NRGN"))]
Nrgn,
#[yaserde(rename = "PHYS")]
#[cfg_attr(feature = "serde", serde(rename = "PHYS"))]
Phys,
#[yaserde(rename = "PLCE")]
#[cfg_attr(feature = "serde", serde(rename = "PLCE"))]
Plce,
#[yaserde(rename = "CTRA")]
#[cfg_attr(feature = "serde", serde(rename = "CTRA"))]
Ctra,
#[yaserde(rename = "REPO")]
#[cfg_attr(feature = "serde", serde(rename = "REPO"))]
Repo,
#[yaserde(rename = "REPP")]
#[cfg_attr(feature = "serde", serde(rename = "REPP"))]
Repp,
#[yaserde(rename = "RERT")]
#[cfg_attr(feature = "serde", serde(rename = "RERT"))]
Rert,
#[yaserde(rename = "RSPR")]
#[cfg_attr(feature = "serde", serde(rename = "RSPR"))]
Rspr,
#[yaserde(rename = "RTGS")]
#[cfg_attr(feature = "serde", serde(rename = "RTGS"))]
Rtgs,
#[yaserde(rename = "SAFE")]
#[cfg_attr(feature = "serde", serde(rename = "SAFE"))]
Safe,
#[yaserde(rename = "SETR")]
#[cfg_attr(feature = "serde", serde(rename = "SETR"))]
Setr,
#[yaserde(rename = "SETS")]
#[cfg_attr(feature = "serde", serde(rename = "SETS"))]
Sets,
#[yaserde(rename = "TERM")]
#[cfg_attr(feature = "serde", serde(rename = "TERM"))]
Term,
#[yaserde(rename = "TXST")]
#[cfg_attr(feature = "serde", serde(rename = "TXST"))]
Txst,
#[yaserde(rename = "ULNK")]
#[cfg_attr(feature = "serde", serde(rename = "ULNK"))]
Ulnk,
#[yaserde(rename = "VASU")]
#[cfg_attr(feature = "serde", serde(rename = "VASU"))]
Vasu,
__Unknown__(String),
}
impl Default for RepairReason7Code {
fn default() -> RepairReason7Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for RepairReason7Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct ReplacementProcessingStatus10Choice {
#[yaserde(rename = "Accptd")]
#[cfg_attr(feature = "serde", serde(rename = "Accptd"))]
pub accptd: Option<ProprietaryReason4>,
#[yaserde(rename = "Cmpltd")]
#[cfg_attr(feature = "serde", serde(rename = "Cmpltd"))]
pub cmpltd: Option<ProprietaryReason4>,
#[yaserde(rename = "Dnd")]
#[cfg_attr(feature = "serde", serde(rename = "Dnd"))]
pub dnd: Option<ProprietaryReason4>,
#[yaserde(rename = "InRpr")]
#[cfg_attr(feature = "serde", serde(rename = "InRpr"))]
pub in_rpr: Option<ProprietaryReason4>,
#[yaserde(rename = "PrtlRplcmntAccptd")]
#[cfg_attr(feature = "serde", serde(rename = "PrtlRplcmntAccptd"))]
pub prtl_rplcmnt_accptd: Option<ProprietaryReason4>,
#[yaserde(rename = "Pdg")]
#[cfg_attr(feature = "serde", serde(rename = "Pdg"))]
pub pdg: Option<ProprietaryReason4>,
#[yaserde(rename = "RcvdAtIntrmy")]
#[cfg_attr(feature = "serde", serde(rename = "RcvdAtIntrmy"))]
pub rcvd_at_intrmy: Option<ProprietaryReason4>,
#[yaserde(rename = "RcvdAtStockXchg")]
#[cfg_attr(feature = "serde", serde(rename = "RcvdAtStockXchg"))]
pub rcvd_at_stock_xchg: Option<ProprietaryReason4>,
#[yaserde(rename = "Rjctd")]
#[cfg_attr(feature = "serde", serde(rename = "Rjctd"))]
pub rjctd: Option<ProprietaryReason4>,
#[yaserde(rename = "ModReqd")]
#[cfg_attr(feature = "serde", serde(rename = "ModReqd"))]
pub mod_reqd: Option<ProprietaryReason4>,
#[yaserde(rename = "PrtrySts")]
#[cfg_attr(feature = "serde", serde(rename = "PrtrySts"))]
pub prtry_sts: Option<ProprietaryStatusAndReason6>,
}
impl Validate for ReplacementProcessingStatus10Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum Reporting2Code {
#[yaserde(rename = "STEX")]
#[cfg_attr(feature = "serde", serde(rename = "STEX"))]
Stex,
#[yaserde(rename = "REGU")]
#[cfg_attr(feature = "serde", serde(rename = "REGU"))]
Regu,
#[yaserde(rename = "DEFR")]
#[cfg_attr(feature = "serde", serde(rename = "DEFR"))]
Defr,
__Unknown__(String),
}
impl Default for Reporting2Code {
fn default() -> Reporting2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for Reporting2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct Reporting6Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<Reporting2Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for Reporting6Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct SecuritiesAccount35 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max35Text,
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: PurposeCode9Choice,
#[yaserde(rename = "Nm")]
#[cfg_attr(feature = "serde", serde(rename = "Nm"))]
pub nm: Max70Text,
}
impl Validate for SecuritiesAccount35 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum SecuritiesAccountPurposeType1Code {
#[yaserde(rename = "MARG")]
#[cfg_attr(feature = "serde", serde(rename = "MARG"))]
Marg,
#[yaserde(rename = "SHOR")]
#[cfg_attr(feature = "serde", serde(rename = "SHOR"))]
Shor,
#[yaserde(rename = "ABRD")]
#[cfg_attr(feature = "serde", serde(rename = "ABRD"))]
Abrd,
#[yaserde(rename = "CEND")]
#[cfg_attr(feature = "serde", serde(rename = "CEND"))]
Cend,
#[yaserde(rename = "DVPA")]
#[cfg_attr(feature = "serde", serde(rename = "DVPA"))]
Dvpa,
#[yaserde(rename = "PHYS")]
#[cfg_attr(feature = "serde", serde(rename = "PHYS"))]
Phys,
__Unknown__(String),
}
impl Default for SecuritiesAccountPurposeType1Code {
fn default() -> SecuritiesAccountPurposeType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for SecuritiesAccountPurposeType1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct SecuritiesCertificate3 {
#[yaserde(rename = "Nb")]
#[cfg_attr(feature = "serde", serde(rename = "Nb"))]
pub nb: Max35Text,
#[yaserde(rename = "Issr")]
#[cfg_attr(feature = "serde", serde(rename = "Issr"))]
pub issr: Max35Text,
#[yaserde(rename = "SchmeNm")]
#[cfg_attr(feature = "serde", serde(rename = "SchmeNm"))]
pub schme_nm: Max35Text,
}
impl Validate for SecuritiesCertificate3 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct SecuritiesTradeConfirmationStatusAdviceV04 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: TransactiontIdentification4,
#[yaserde(rename = "Refs")]
#[cfg_attr(feature = "serde", serde(rename = "Refs"))]
pub refs: Vec<Linkages77>,
#[yaserde(rename = "AffirmSts")]
#[cfg_attr(feature = "serde", serde(rename = "AffirmSts"))]
pub affirm_sts: AffirmationStatus11Choice,
#[yaserde(rename = "PrcgSts")]
#[cfg_attr(feature = "serde", serde(rename = "PrcgSts"))]
pub prcg_sts: ProcessingStatus98Choice,
#[yaserde(rename = "MtchgSts")]
#[cfg_attr(feature = "serde", serde(rename = "MtchgSts"))]
pub mtchg_sts: MatchingStatus35Choice,
#[yaserde(rename = "RplcmntPrcgSts")]
#[cfg_attr(feature = "serde", serde(rename = "RplcmntPrcgSts"))]
pub rplcmnt_prcg_sts: ReplacementProcessingStatus10Choice,
#[yaserde(rename = "CxlPrcgSts")]
#[cfg_attr(feature = "serde", serde(rename = "CxlPrcgSts"))]
pub cxl_prcg_sts: CancellationProcessingStatus10Choice,
#[yaserde(rename = "PtyTradgDtls")]
#[cfg_attr(feature = "serde", serde(rename = "PtyTradgDtls"))]
pub pty_tradg_dtls: Order23,
#[yaserde(rename = "CtrPtyTradgDtls")]
#[cfg_attr(feature = "serde", serde(rename = "CtrPtyTradgDtls"))]
pub ctr_pty_tradg_dtls: Order23,
#[yaserde(rename = "ConfPties")]
#[cfg_attr(feature = "serde", serde(rename = "ConfPties"))]
pub conf_pties: Vec<ConfirmationParties9>,
#[yaserde(rename = "DlvrgSttlmPties")]
#[cfg_attr(feature = "serde", serde(rename = "DlvrgSttlmPties"))]
pub dlvrg_sttlm_pties: SettlementParties121,
#[yaserde(rename = "RcvgSttlmPties")]
#[cfg_attr(feature = "serde", serde(rename = "RcvgSttlmPties"))]
pub rcvg_sttlm_pties: SettlementParties121,
#[yaserde(rename = "SplmtryData")]
#[cfg_attr(feature = "serde", serde(rename = "SplmtryData"))]
pub splmtry_data: Vec<SupplementaryData1>,
}
impl Validate for SecuritiesTradeConfirmationStatusAdviceV04 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct SecurityIdentification19 {
#[yaserde(rename = "ISIN")]
#[cfg_attr(feature = "serde", serde(rename = "ISIN"))]
pub isin: Isinoct2015Identifier,
#[yaserde(rename = "OthrId")]
#[cfg_attr(feature = "serde", serde(rename = "OthrId"))]
pub othr_id: Vec<OtherIdentification1>,
#[yaserde(rename = "Desc")]
#[cfg_attr(feature = "serde", serde(rename = "Desc"))]
pub desc: Max140Text,
}
impl Validate for SecurityIdentification19 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct SettlementDate16Choice {
#[yaserde(rename = "Dt")]
#[cfg_attr(feature = "serde", serde(rename = "Dt"))]
pub dt: Option<DateAndDateTime1Choice>,
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<SettlementDateCode12Choice>,
}
impl Validate for SettlementDate16Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum SettlementDate5Code {
#[yaserde(rename = "REGU")]
#[cfg_attr(feature = "serde", serde(rename = "REGU"))]
Regu,
#[yaserde(rename = "CASH")]
#[cfg_attr(feature = "serde", serde(rename = "CASH"))]
Cash,
#[yaserde(rename = "NXTD")]
#[cfg_attr(feature = "serde", serde(rename = "NXTD"))]
Nxtd,
#[yaserde(rename = "TONE")]
#[cfg_attr(feature = "serde", serde(rename = "TONE"))]
Tone,
#[yaserde(rename = "TTWO")]
#[cfg_attr(feature = "serde", serde(rename = "TTWO"))]
Ttwo,
#[yaserde(rename = "TTRE")]
#[cfg_attr(feature = "serde", serde(rename = "TTRE"))]
Ttre,
#[yaserde(rename = "TFOR")]
#[cfg_attr(feature = "serde", serde(rename = "TFOR"))]
Tfor,
#[yaserde(rename = "TFIV")]
#[cfg_attr(feature = "serde", serde(rename = "TFIV"))]
Tfiv,
#[yaserde(rename = "SELL")]
#[cfg_attr(feature = "serde", serde(rename = "SELL"))]
Sell,
#[yaserde(rename = "WDIS")]
#[cfg_attr(feature = "serde", serde(rename = "WDIS"))]
Wdis,
#[yaserde(rename = "WHID")]
#[cfg_attr(feature = "serde", serde(rename = "WHID"))]
Whid,
#[yaserde(rename = "TBAT")]
#[cfg_attr(feature = "serde", serde(rename = "TBAT"))]
Tbat,
#[yaserde(rename = "WISS")]
#[cfg_attr(feature = "serde", serde(rename = "WISS"))]
Wiss,
__Unknown__(String),
}
impl Default for SettlementDate5Code {
fn default() -> SettlementDate5Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for SettlementDate5Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct SettlementDateCode12Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<SettlementDate5Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for SettlementDateCode12Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct SettlementParties121 {
#[yaserde(rename = "Dpstry")]
#[cfg_attr(feature = "serde", serde(rename = "Dpstry"))]
pub dpstry: PartyIdentification268,
#[yaserde(rename = "Pty1")]
#[cfg_attr(feature = "serde", serde(rename = "Pty1"))]
pub pty_1: PartyIdentificationAndAccount218,
#[yaserde(rename = "Pty2")]
#[cfg_attr(feature = "serde", serde(rename = "Pty2"))]
pub pty_2: PartyIdentificationAndAccount218,
#[yaserde(rename = "Pty3")]
#[cfg_attr(feature = "serde", serde(rename = "Pty3"))]
pub pty_3: PartyIdentificationAndAccount218,
#[yaserde(rename = "Pty4")]
#[cfg_attr(feature = "serde", serde(rename = "Pty4"))]
pub pty_4: PartyIdentificationAndAccount218,
#[yaserde(rename = "Pty5")]
#[cfg_attr(feature = "serde", serde(rename = "Pty5"))]
pub pty_5: PartyIdentificationAndAccount218,
}
impl Validate for SettlementParties121 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum Side3Code {
#[yaserde(rename = "BUYI")]
#[cfg_attr(feature = "serde", serde(rename = "BUYI"))]
Buyi,
#[yaserde(rename = "SELL")]
#[cfg_attr(feature = "serde", serde(rename = "SELL"))]
Sell,
#[yaserde(rename = "CROS")]
#[cfg_attr(feature = "serde", serde(rename = "CROS"))]
Cros,
#[yaserde(rename = "CRSH")]
#[cfg_attr(feature = "serde", serde(rename = "CRSH"))]
Crsh,
#[yaserde(rename = "CSHE")]
#[cfg_attr(feature = "serde", serde(rename = "CSHE"))]
Cshe,
#[yaserde(rename = "DEFI")]
#[cfg_attr(feature = "serde", serde(rename = "DEFI"))]
Defi,
#[yaserde(rename = "OPPO")]
#[cfg_attr(feature = "serde", serde(rename = "OPPO"))]
Oppo,
#[yaserde(rename = "UNDI")]
#[cfg_attr(feature = "serde", serde(rename = "UNDI"))]
Undi,
#[yaserde(rename = "TWOS")]
#[cfg_attr(feature = "serde", serde(rename = "TWOS"))]
Twos,
#[yaserde(rename = "BUMI")]
#[cfg_attr(feature = "serde", serde(rename = "BUMI"))]
Bumi,
#[yaserde(rename = "SEPL")]
#[cfg_attr(feature = "serde", serde(rename = "SEPL"))]
Sepl,
#[yaserde(rename = "SESH")]
#[cfg_attr(feature = "serde", serde(rename = "SESH"))]
Sesh,
#[yaserde(rename = "SSEX")]
#[cfg_attr(feature = "serde", serde(rename = "SSEX"))]
Ssex,
#[yaserde(rename = "LEND")]
#[cfg_attr(feature = "serde", serde(rename = "LEND"))]
Lend,
#[yaserde(rename = "BORW")]
#[cfg_attr(feature = "serde", serde(rename = "BORW"))]
Borw,
#[yaserde(rename = "OPEX")]
#[cfg_attr(feature = "serde", serde(rename = "OPEX"))]
Opex,
__Unknown__(String),
}
impl Default for Side3Code {
fn default() -> Side3Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for Side3Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct SimpleIdentificationInformation2 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max34Text,
}
impl Validate for SimpleIdentificationInformation2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct SupplementaryData1 {
#[yaserde(rename = "PlcAndNm")]
#[cfg_attr(feature = "serde", serde(rename = "PlcAndNm"))]
pub plc_and_nm: Max350Text,
#[yaserde(rename = "Envlp")]
#[cfg_attr(feature = "serde", serde(rename = "Envlp"))]
pub envlp: SupplementaryDataEnvelope1,
}
impl Validate for SupplementaryData1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct SupplementaryDataEnvelope1 {}
impl Validate for SupplementaryDataEnvelope1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct TradeDate7Choice {
#[yaserde(rename = "Dt")]
#[cfg_attr(feature = "serde", serde(rename = "Dt"))]
pub dt: Option<DateAndDateTime1Choice>,
#[yaserde(rename = "Val")]
#[cfg_attr(feature = "serde", serde(rename = "Val"))]
pub val: Option<TradingDateCode2Choice>,
}
impl Validate for TradeDate7Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum TradeRegulatoryConditions1Code {
#[yaserde(rename = "SOLI")]
#[cfg_attr(feature = "serde", serde(rename = "SOLI"))]
Soli,
#[yaserde(rename = "USOL")]
#[cfg_attr(feature = "serde", serde(rename = "USOL"))]
Usol,
__Unknown__(String),
}
impl Default for TradeRegulatoryConditions1Code {
fn default() -> TradeRegulatoryConditions1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for TradeRegulatoryConditions1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct TradeTransactionCondition9Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<ExternalTradeTransactionCondition1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for TradeTransactionCondition9Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum TradeType3Code {
#[yaserde(rename = "BSKT")]
#[cfg_attr(feature = "serde", serde(rename = "BSKT"))]
Bskt,
#[yaserde(rename = "INDX")]
#[cfg_attr(feature = "serde", serde(rename = "INDX"))]
Indx,
#[yaserde(rename = "IPOO")]
#[cfg_attr(feature = "serde", serde(rename = "IPOO"))]
Ipoo,
#[yaserde(rename = "LIST")]
#[cfg_attr(feature = "serde", serde(rename = "LIST"))]
List,
#[yaserde(rename = "PRAL")]
#[cfg_attr(feature = "serde", serde(rename = "PRAL"))]
Pral,
#[yaserde(rename = "PROG")]
#[cfg_attr(feature = "serde", serde(rename = "PROG"))]
Prog,
#[yaserde(rename = "TRAD")]
#[cfg_attr(feature = "serde", serde(rename = "TRAD"))]
Trad,
#[yaserde(rename = "BRBR")]
#[cfg_attr(feature = "serde", serde(rename = "BRBR"))]
Brbr,
#[yaserde(rename = "RISK")]
#[cfg_attr(feature = "serde", serde(rename = "RISK"))]
Risk,
#[yaserde(rename = "VWAP")]
#[cfg_attr(feature = "serde", serde(rename = "VWAP"))]
Vwap,
#[yaserde(rename = "AGEN")]
#[cfg_attr(feature = "serde", serde(rename = "AGEN"))]
Agen,
#[yaserde(rename = "GUAR")]
#[cfg_attr(feature = "serde", serde(rename = "GUAR"))]
Guar,
#[yaserde(rename = "EMTR")]
#[cfg_attr(feature = "serde", serde(rename = "EMTR"))]
Emtr,
#[yaserde(rename = "ISSU")]
#[cfg_attr(feature = "serde", serde(rename = "ISSU"))]
Issu,
#[yaserde(rename = "BOST")]
#[cfg_attr(feature = "serde", serde(rename = "BOST"))]
Bost,
#[yaserde(rename = "BOEN")]
#[cfg_attr(feature = "serde", serde(rename = "BOEN"))]
Boen,
#[yaserde(rename = "LABO")]
#[cfg_attr(feature = "serde", serde(rename = "LABO"))]
Labo,
#[yaserde(rename = "BORE")]
#[cfg_attr(feature = "serde", serde(rename = "BORE"))]
Bore,
#[yaserde(rename = "OFIT")]
#[cfg_attr(feature = "serde", serde(rename = "OFIT"))]
Ofit,
#[yaserde(rename = "BOSU")]
#[cfg_attr(feature = "serde", serde(rename = "BOSU"))]
Bosu,
#[yaserde(rename = "FBBT")]
#[cfg_attr(feature = "serde", serde(rename = "FBBT"))]
Fbbt,
#[yaserde(rename = "OPTN")]
#[cfg_attr(feature = "serde", serde(rename = "OPTN"))]
Optn,
#[yaserde(rename = "FUOP")]
#[cfg_attr(feature = "serde", serde(rename = "FUOP"))]
Fuop,
#[yaserde(rename = "FUTR")]
#[cfg_attr(feature = "serde", serde(rename = "FUTR"))]
Futr,
__Unknown__(String),
}
impl Default for TradeType3Code {
fn default() -> TradeType3Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for TradeType3Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct TradeType4Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<TradeType3Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for TradeType4Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum TradingCapacity4Code {
#[yaserde(rename = "PRIN")]
#[cfg_attr(feature = "serde", serde(rename = "PRIN"))]
Prin,
#[yaserde(rename = "CPRN")]
#[cfg_attr(feature = "serde", serde(rename = "CPRN"))]
Cprn,
#[yaserde(rename = "RISP")]
#[cfg_attr(feature = "serde", serde(rename = "RISP"))]
Risp,
#[yaserde(rename = "PROP")]
#[cfg_attr(feature = "serde", serde(rename = "PROP"))]
Prop,
#[yaserde(rename = "AGEN")]
#[cfg_attr(feature = "serde", serde(rename = "AGEN"))]
Agen,
#[yaserde(rename = "CAGN")]
#[cfg_attr(feature = "serde", serde(rename = "CAGN"))]
Cagn,
#[yaserde(rename = "OAGN")]
#[cfg_attr(feature = "serde", serde(rename = "OAGN"))]
Oagn,
#[yaserde(rename = "PRAG")]
#[cfg_attr(feature = "serde", serde(rename = "PRAG"))]
Prag,
#[yaserde(rename = "BAGN")]
#[cfg_attr(feature = "serde", serde(rename = "BAGN"))]
Bagn,
#[yaserde(rename = "INFI")]
#[cfg_attr(feature = "serde", serde(rename = "INFI"))]
Infi,
#[yaserde(rename = "MKTM")]
#[cfg_attr(feature = "serde", serde(rename = "MKTM"))]
Mktm,
#[yaserde(rename = "MLTF")]
#[cfg_attr(feature = "serde", serde(rename = "MLTF"))]
Mltf,
#[yaserde(rename = "RMKT")]
#[cfg_attr(feature = "serde", serde(rename = "RMKT"))]
Rmkt,
#[yaserde(rename = "SINT")]
#[cfg_attr(feature = "serde", serde(rename = "SINT"))]
Sint,
#[yaserde(rename = "TAGT")]
#[cfg_attr(feature = "serde", serde(rename = "TAGT"))]
Tagt,
__Unknown__(String),
}
impl Default for TradingCapacity4Code {
fn default() -> TradingCapacity4Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for TradingCapacity4Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum TradingCapacity6Code {
#[yaserde(rename = "AGEN")]
#[cfg_attr(feature = "serde", serde(rename = "AGEN"))]
Agen,
#[yaserde(rename = "BAGN")]
#[cfg_attr(feature = "serde", serde(rename = "BAGN"))]
Bagn,
#[yaserde(rename = "CAGN")]
#[cfg_attr(feature = "serde", serde(rename = "CAGN"))]
Cagn,
#[yaserde(rename = "CPRN")]
#[cfg_attr(feature = "serde", serde(rename = "CPRN"))]
Cprn,
#[yaserde(rename = "OAGN")]
#[cfg_attr(feature = "serde", serde(rename = "OAGN"))]
Oagn,
#[yaserde(rename = "PRAG")]
#[cfg_attr(feature = "serde", serde(rename = "PRAG"))]
Prag,
#[yaserde(rename = "PRIN")]
#[cfg_attr(feature = "serde", serde(rename = "PRIN"))]
Prin,
__Unknown__(String),
}
impl Default for TradingCapacity6Code {
fn default() -> TradingCapacity6Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for TradingCapacity6Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum TradingDate1Code {
#[yaserde(rename = "VARI")]
#[cfg_attr(feature = "serde", serde(rename = "VARI"))]
Vari,
__Unknown__(String),
}
impl Default for TradingDate1Code {
fn default() -> TradingDate1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for TradingDate1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct TradingDateCode2Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<TradingDate1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for TradingDateCode2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct TradingPartyCapacity3Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<TradingCapacity6Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification36>,
}
impl Validate for TradingPartyCapacity3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct TradingPartyCapacity4Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<TradingCapacity4Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for TradingPartyCapacity4Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct TransactiontIdentification4 {
#[yaserde(rename = "TxId")]
#[cfg_attr(feature = "serde", serde(rename = "TxId"))]
pub tx_id: Max35Text,
}
impl Validate for TransactiontIdentification4 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum TypeOfIdentification2Code {
#[yaserde(rename = "ARNU")]
#[cfg_attr(feature = "serde", serde(rename = "ARNU"))]
Arnu,
#[yaserde(rename = "CHTY")]
#[cfg_attr(feature = "serde", serde(rename = "CHTY"))]
Chty,
#[yaserde(rename = "CORP")]
#[cfg_attr(feature = "serde", serde(rename = "CORP"))]
Corp,
#[yaserde(rename = "FIIN")]
#[cfg_attr(feature = "serde", serde(rename = "FIIN"))]
Fiin,
#[yaserde(rename = "TXID")]
#[cfg_attr(feature = "serde", serde(rename = "TXID"))]
Txid,
__Unknown__(String),
}
impl Default for TypeOfIdentification2Code {
fn default() -> TypeOfIdentification2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for TypeOfIdentification2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum TypeOfPrice3Code {
#[yaserde(rename = "AVER")]
#[cfg_attr(feature = "serde", serde(rename = "AVER"))]
Aver,
#[yaserde(rename = "AVOV")]
#[cfg_attr(feature = "serde", serde(rename = "AVOV"))]
Avov,
#[yaserde(rename = "GREX")]
#[cfg_attr(feature = "serde", serde(rename = "GREX"))]
Grex,
#[yaserde(rename = "NET2")]
#[cfg_attr(feature = "serde", serde(rename = "NET2"))]
Net2,
#[yaserde(rename = "NET1")]
#[cfg_attr(feature = "serde", serde(rename = "NET1"))]
Net1,
#[yaserde(rename = "PARV")]
#[cfg_attr(feature = "serde", serde(rename = "PARV"))]
Parv,
#[yaserde(rename = "RDAV")]
#[cfg_attr(feature = "serde", serde(rename = "RDAV"))]
Rdav,
__Unknown__(String),
}
impl Default for TypeOfPrice3Code {
fn default() -> TypeOfPrice3Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for TypeOfPrice3Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct TypeOfPrice47Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<TypeOfPrice3Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for TypeOfPrice47Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Upicidentifier (pub String);
crate::simple_type!(Upicidentifier);
impl Validate for Upicidentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Utiidentifier (pub String);
crate::simple_type!(Utiidentifier);
impl Validate for Utiidentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum UnaffirmedReason1Code {
#[yaserde(rename = "NAFF")]
#[cfg_attr(feature = "serde", serde(rename = "NAFF"))]
Naff,
__Unknown__(String),
}
impl Default for UnaffirmedReason1Code {
fn default() -> UnaffirmedReason1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for UnaffirmedReason1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct UnaffirmedReason3Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<UnaffirmedReason1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for UnaffirmedReason3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct UnmatchedReason23 {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: UnmatchedReason32Choice,
#[yaserde(rename = "AddtlRsnInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlRsnInf"))]
pub addtl_rsn_inf: Max210Text,
}
impl Validate for UnmatchedReason23 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct UnmatchedReason32Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<UnmatchedReason4Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for UnmatchedReason32Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub enum UnmatchedReason4Code {
#[yaserde(rename = "ADEA")]
#[cfg_attr(feature = "serde", serde(rename = "ADEA"))]
Adea,
#[yaserde(rename = "CADE")]
#[cfg_attr(feature = "serde", serde(rename = "CADE"))]
Cade,
#[yaserde(rename = "CHAR")]
#[cfg_attr(feature = "serde", serde(rename = "CHAR"))]
Char,
#[yaserde(rename = "CMIS")]
#[cfg_attr(feature = "serde", serde(rename = "CMIS"))]
Cmis,
#[yaserde(rename = "CPCA")]
#[cfg_attr(feature = "serde", serde(rename = "CPCA"))]
Cpca,
#[yaserde(rename = "DDAT")]
#[cfg_attr(feature = "serde", serde(rename = "DDAT"))]
Ddat,
#[yaserde(rename = "DDEA")]
#[cfg_attr(feature = "serde", serde(rename = "DDEA"))]
Ddea,
#[yaserde(rename = "DEAL")]
#[cfg_attr(feature = "serde", serde(rename = "DEAL"))]
Deal,
#[yaserde(rename = "DELN")]
#[cfg_attr(feature = "serde", serde(rename = "DELN"))]
Deln,
#[yaserde(rename = "DEPT")]
#[cfg_attr(feature = "serde", serde(rename = "DEPT"))]
Dept,
#[yaserde(rename = "DMON")]
#[cfg_attr(feature = "serde", serde(rename = "DMON"))]
Dmon,
#[yaserde(rename = "DQUA")]
#[cfg_attr(feature = "serde", serde(rename = "DQUA"))]
Dqua,
#[yaserde(rename = "DSEC")]
#[cfg_attr(feature = "serde", serde(rename = "DSEC"))]
Dsec,
#[yaserde(rename = "DTRD")]
#[cfg_attr(feature = "serde", serde(rename = "DTRD"))]
Dtrd,
#[yaserde(rename = "EXEC")]
#[cfg_attr(feature = "serde", serde(rename = "EXEC"))]
Exec,
#[yaserde(rename = "FORF")]
#[cfg_attr(feature = "serde", serde(rename = "FORF"))]
Forf,
#[yaserde(rename = "LATE")]
#[cfg_attr(feature = "serde", serde(rename = "LATE"))]
Late,
#[yaserde(rename = "LEOG")]
#[cfg_attr(feature = "serde", serde(rename = "LEOG"))]
Leog,
#[yaserde(rename = "MCAN")]
#[cfg_attr(feature = "serde", serde(rename = "MCAN"))]
Mcan,
#[yaserde(rename = "NARR")]
#[cfg_attr(feature = "serde", serde(rename = "NARR"))]
Narr,
#[yaserde(rename = "PHYS")]
#[cfg_attr(feature = "serde", serde(rename = "PHYS"))]
Phys,
#[yaserde(rename = "PLCE")]
#[cfg_attr(feature = "serde", serde(rename = "PLCE"))]
Plce,
#[yaserde(rename = "PODU")]
#[cfg_attr(feature = "serde", serde(rename = "PODU"))]
Podu,
#[yaserde(rename = "REPA")]
#[cfg_attr(feature = "serde", serde(rename = "REPA"))]
Repa,
#[yaserde(rename = "REPO")]
#[cfg_attr(feature = "serde", serde(rename = "REPO"))]
Repo,
#[yaserde(rename = "REPP")]
#[cfg_attr(feature = "serde", serde(rename = "REPP"))]
Repp,
#[yaserde(rename = "RERT")]
#[cfg_attr(feature = "serde", serde(rename = "RERT"))]
Rert,
#[yaserde(rename = "RSPR")]
#[cfg_attr(feature = "serde", serde(rename = "RSPR"))]
Rspr,
#[yaserde(rename = "RTGS")]
#[cfg_attr(feature = "serde", serde(rename = "RTGS"))]
Rtgs,
#[yaserde(rename = "SAFE")]
#[cfg_attr(feature = "serde", serde(rename = "SAFE"))]
Safe,
#[yaserde(rename = "SETR")]
#[cfg_attr(feature = "serde", serde(rename = "SETR"))]
Setr,
#[yaserde(rename = "SETS")]
#[cfg_attr(feature = "serde", serde(rename = "SETS"))]
Sets,
#[yaserde(rename = "TERM")]
#[cfg_attr(feature = "serde", serde(rename = "TERM"))]
Term,
#[yaserde(rename = "TXST")]
#[cfg_attr(feature = "serde", serde(rename = "TXST"))]
Txst,
#[yaserde(rename = "VASU")]
#[cfg_attr(feature = "serde", serde(rename = "VASU"))]
Vasu,
#[yaserde(rename = "POSE")]
#[cfg_attr(feature = "serde", serde(rename = "POSE"))]
Pose,
#[yaserde(rename = "BORT")]
#[cfg_attr(feature = "serde", serde(rename = "BORT"))]
Bort,
#[yaserde(rename = "COAX")]
#[cfg_attr(feature = "serde", serde(rename = "COAX"))]
Coax,
#[yaserde(rename = "OTHI")]
#[cfg_attr(feature = "serde", serde(rename = "OTHI"))]
Othi,
#[yaserde(rename = "BOFE")]
#[cfg_attr(feature = "serde", serde(rename = "BOFE"))]
Bofe,
#[yaserde(rename = "TACR")]
#[cfg_attr(feature = "serde", serde(rename = "TACR"))]
Tacr,
#[yaserde(rename = "SDAT")]
#[cfg_attr(feature = "serde", serde(rename = "SDAT"))]
Sdat,
#[yaserde(rename = "COID")]
#[cfg_attr(feature = "serde", serde(rename = "COID"))]
Coid,
#[yaserde(rename = "SCRA")]
#[cfg_attr(feature = "serde", serde(rename = "SCRA"))]
Scra,
#[yaserde(rename = "ACRU")]
#[cfg_attr(feature = "serde", serde(rename = "ACRU"))]
Acru,
#[yaserde(rename = "SHAI")]
#[cfg_attr(feature = "serde", serde(rename = "SHAI"))]
Shai,
#[yaserde(rename = "ACRS")]
#[cfg_attr(feature = "serde", serde(rename = "ACRS"))]
Acrs,
#[yaserde(rename = "DEAS")]
#[cfg_attr(feature = "serde", serde(rename = "DEAS"))]
Deas,
#[yaserde(rename = "CATI")]
#[cfg_attr(feature = "serde", serde(rename = "CATI"))]
Cati,
#[yaserde(rename = "TACS")]
#[cfg_attr(feature = "serde", serde(rename = "TACS"))]
Tacs,
#[yaserde(rename = "DBNM")]
#[cfg_attr(feature = "serde", serde(rename = "DBNM"))]
Dbnm,
#[yaserde(rename = "MADA")]
#[cfg_attr(feature = "serde", serde(rename = "MADA"))]
Mada,
#[yaserde(rename = "OLID")]
#[cfg_attr(feature = "serde", serde(rename = "OLID"))]
Olid,
#[yaserde(rename = "TRSA")]
#[cfg_attr(feature = "serde", serde(rename = "TRSA"))]
Trsa,
#[yaserde(rename = "TRTE")]
#[cfg_attr(feature = "serde", serde(rename = "TRTE"))]
Trte,
#[yaserde(rename = "BOIA")]
#[cfg_attr(feature = "serde", serde(rename = "BOIA"))]
Boia,
#[yaserde(rename = "OPLI")]
#[cfg_attr(feature = "serde", serde(rename = "OPLI"))]
Opli,
#[yaserde(rename = "TRTR")]
#[cfg_attr(feature = "serde", serde(rename = "TRTR"))]
Trtr,
#[yaserde(rename = "LWCO")]
#[cfg_attr(feature = "serde", serde(rename = "LWCO"))]
Lwco,
#[yaserde(rename = "INTT")]
#[cfg_attr(feature = "serde", serde(rename = "INTT"))]
Intt,
#[yaserde(rename = "CUFC")]
#[cfg_attr(feature = "serde", serde(rename = "CUFC"))]
Cufc,
#[yaserde(rename = "LTME")]
#[cfg_attr(feature = "serde", serde(rename = "LTME"))]
Ltme,
#[yaserde(rename = "ENFC")]
#[cfg_attr(feature = "serde", serde(rename = "ENFC"))]
Enfc,
#[yaserde(rename = "CLSE")]
#[cfg_attr(feature = "serde", serde(rename = "CLSE"))]
Clse,
__Unknown__(String),
}
impl Default for UnmatchedReason4Code {
fn default() -> UnmatchedReason4Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for UnmatchedReason4Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct YesNoIndicator (pub bool);
crate::simple_type!(YesNoIndicator);
impl Validate for YesNoIndicator {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.044.001.04")]
pub struct YieldCalculation7 {
#[yaserde(rename = "Val")]
#[cfg_attr(feature = "serde", serde(rename = "Val"))]
pub val: PercentageRate,
#[yaserde(rename = "ClctnTp")]
#[cfg_attr(feature = "serde", serde(rename = "ClctnTp"))]
pub clctn_tp: CalculationType1Code,
#[yaserde(rename = "RedPric")]
#[cfg_attr(feature = "serde", serde(rename = "RedPric"))]
pub red_pric: Price14,
#[yaserde(rename = "ValDt")]
#[cfg_attr(feature = "serde", serde(rename = "ValDt"))]
pub val_dt: Isodate,
#[yaserde(rename = "ValPrd")]
#[cfg_attr(feature = "serde", serde(rename = "ValPrd"))]
pub val_prd: DateTimePeriod1Choice,
#[yaserde(rename = "ClctnDt")]
#[cfg_attr(feature = "serde", serde(rename = "ClctnDt"))]
pub clctn_dt: Isodate,
}
impl Validate for YieldCalculation7 {}
impl crate::MxMessage for Document {
const BUSINESS_AREA: crate::BusinessArea = crate::BusinessArea::setr;
const FUNCTIONALITY: &'static str = "044";
const VARIANT: &'static str = "001";
const VERSION: &'static str = "04";
const MESSAGE_NAME: &'static str = "setr.044.001.04";
const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:setr.044.001.04";
}