#![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)]
pub struct ActiveCurrencyAnd13DecimalAmountSimpleType (pub String);
crate::simple_type!(ActiveCurrencyAnd13DecimalAmountSimpleType);
impl Validate for ActiveCurrencyAnd13DecimalAmountSimpleType {
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:reda.006.001.01")]
pub struct ActiveCurrencyAnd13DecimalAmount {
#[yaserde(text)]
pub value: String,
#[yaserde(attribute, rename = "Ccy")]
#[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
pub ccy: ActiveCurrencyCode,
}
impl Validate for ActiveCurrencyAnd13DecimalAmount {}
#[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:reda.006.001.01")]
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:reda.006.001.01")]
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 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:reda.006.001.01")]
pub enum AddressType1Code {
#[yaserde(rename = "HOME")]
#[cfg_attr(feature = "serde", serde(rename = "HOME"))]
Home,
#[yaserde(rename = "BIZZ")]
#[cfg_attr(feature = "serde", serde(rename = "BIZZ"))]
Bizz,
__Unknown__(String),
}
impl Default for AddressType1Code {
fn default() -> AddressType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AddressType1Code {}
#[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:reda.006.001.01")]
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:reda.006.001.01")]
pub struct AmountOrPercentageRange1 {
#[yaserde(rename = "Opr")]
#[cfg_attr(feature = "serde", serde(rename = "Opr"))]
pub opr: Operation1Code,
#[yaserde(rename = "Term")]
#[cfg_attr(feature = "serde", serde(rename = "Term"))]
pub term: Vec<Term1>,
}
impl Validate for AmountOrPercentageRange1 {}
#[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:reda.006.001.01")]
pub enum Appearance1Code {
#[yaserde(rename = "DELI")]
#[cfg_attr(feature = "serde", serde(rename = "DELI"))]
Deli,
#[yaserde(rename = "NDEL")]
#[cfg_attr(feature = "serde", serde(rename = "NDEL"))]
Ndel,
#[yaserde(rename = "LIMI")]
#[cfg_attr(feature = "serde", serde(rename = "LIMI"))]
Limi,
#[yaserde(rename = "BENT")]
#[cfg_attr(feature = "serde", serde(rename = "BENT"))]
Bent,
#[yaserde(rename = "DFBE")]
#[cfg_attr(feature = "serde", serde(rename = "DFBE"))]
Dfbe,
#[yaserde(rename = "DLBE")]
#[cfg_attr(feature = "serde", serde(rename = "DLBE"))]
Dlbe,
#[yaserde(rename = "TMPG")]
#[cfg_attr(feature = "serde", serde(rename = "TMPG"))]
Tmpg,
#[yaserde(rename = "GLOB")]
#[cfg_attr(feature = "serde", serde(rename = "GLOB"))]
Glob,
__Unknown__(String),
}
impl Default for Appearance1Code {
fn default() -> Appearance1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for Appearance1Code {}
#[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:reda.006.001.01")]
pub struct Appearance3Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<Appearance1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for Appearance3Choice {}
#[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:reda.006.001.01")]
pub enum AssignmentMethod1Code {
#[yaserde(rename = "RAND")]
#[cfg_attr(feature = "serde", serde(rename = "RAND"))]
Rand,
#[yaserde(rename = "PROR")]
#[cfg_attr(feature = "serde", serde(rename = "PROR"))]
Pror,
__Unknown__(String),
}
impl Default for AssignmentMethod1Code {
fn default() -> AssignmentMethod1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AssignmentMethod1Code {}
#[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:reda.006.001.01")]
pub struct AssignmentMethod2Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<AssignmentMethod1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for AssignmentMethod2Choice {}
#[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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:reda.006.001.01")]
pub struct BenchmarkCurve6 {
#[yaserde(rename = "Sprd")]
#[cfg_attr(feature = "serde", serde(rename = "Sprd"))]
pub sprd: DecimalNumber,
#[yaserde(rename = "BchmkId")]
#[cfg_attr(feature = "serde", serde(rename = "BchmkId"))]
pub bchmk_id: SecurityIdentification39,
#[yaserde(rename = "BchmkPric")]
#[cfg_attr(feature = "serde", serde(rename = "BchmkPric"))]
pub bchmk_pric: Price8,
#[yaserde(rename = "BchmkCrvCcy")]
#[cfg_attr(feature = "serde", serde(rename = "BchmkCrvCcy"))]
pub bchmk_crv_ccy: ActiveOrHistoricCurrencyCode,
#[yaserde(rename = "BchmkCrvNm")]
#[cfg_attr(feature = "serde", serde(rename = "BchmkCrvNm"))]
pub bchmk_crv_nm: BenchmarkCurveName7Choice,
#[yaserde(rename = "BchmkCrvPt")]
#[cfg_attr(feature = "serde", serde(rename = "BchmkCrvPt"))]
pub bchmk_crv_pt: Max256Text,
}
impl Validate for BenchmarkCurve6 {}
#[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:reda.006.001.01")]
pub enum BenchmarkCurveName1Code {
#[yaserde(rename = "MAAA")]
#[cfg_attr(feature = "serde", serde(rename = "MAAA"))]
Maaa,
#[yaserde(rename = "FUSW")]
#[cfg_attr(feature = "serde", serde(rename = "FUSW"))]
Fusw,
#[yaserde(rename = "LIBI")]
#[cfg_attr(feature = "serde", serde(rename = "LIBI"))]
Libi,
#[yaserde(rename = "LIBO")]
#[cfg_attr(feature = "serde", serde(rename = "LIBO"))]
Libo,
#[yaserde(rename = "SWAP")]
#[cfg_attr(feature = "serde", serde(rename = "SWAP"))]
Swap,
#[yaserde(rename = "TREA")]
#[cfg_attr(feature = "serde", serde(rename = "TREA"))]
Trea,
#[yaserde(rename = "EURI")]
#[cfg_attr(feature = "serde", serde(rename = "EURI"))]
Euri,
#[yaserde(rename = "PFAN")]
#[cfg_attr(feature = "serde", serde(rename = "PFAN"))]
Pfan,
__Unknown__(String),
}
impl Default for BenchmarkCurveName1Code {
fn default() -> BenchmarkCurveName1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for BenchmarkCurveName1Code {}
#[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:reda.006.001.01")]
pub struct BenchmarkCurveName7Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<BenchmarkCurveName1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for BenchmarkCurveName7Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Cfioct2015Identifier (pub String);
crate::simple_type!(Cfioct2015Identifier);
impl Validate for Cfioct2015Identifier {}
#[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:reda.006.001.01")]
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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:reda.006.001.01")]
pub struct CalculationType3Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<CalculationType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for CalculationType3Choice {}
#[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:reda.006.001.01")]
pub enum CallType1Code {
#[yaserde(rename = "LOTT")]
#[cfg_attr(feature = "serde", serde(rename = "LOTT"))]
Lott,
#[yaserde(rename = "PRTA")]
#[cfg_attr(feature = "serde", serde(rename = "PRTA"))]
Prta,
__Unknown__(String),
}
impl Default for CallType1Code {
fn default() -> CallType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for CallType1Code {}
#[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:reda.006.001.01")]
pub struct CallType3Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<CallType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for CallType3Choice {}
#[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:reda.006.001.01")]
pub struct ClassificationType2 {
#[yaserde(rename = "ClssfctnFinInstrm")]
#[cfg_attr(feature = "serde", serde(rename = "ClssfctnFinInstrm"))]
pub clssfctn_fin_instrm: Cfioct2015Identifier,
#[yaserde(rename = "FinInstrmPdctTpCd")]
#[cfg_attr(feature = "serde", serde(rename = "FinInstrmPdctTpCd"))]
pub fin_instrm_pdct_tp_cd: ExternalFinancialInstrumentProductType1Code,
#[yaserde(rename = "AltrnClssfctn")]
#[cfg_attr(feature = "serde", serde(rename = "AltrnClssfctn"))]
pub altrn_clssfctn: Vec<GenericIdentification36>,
}
impl Validate for ClassificationType2 {}
#[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:reda.006.001.01")]
pub struct CommonFinancialInstrumentAttributes10 {
#[yaserde(rename = "SctySts")]
#[cfg_attr(feature = "serde", serde(rename = "SctySts"))]
pub scty_sts: SecurityStatus3Choice,
#[yaserde(rename = "ISOSctyLngNm")]
#[cfg_attr(feature = "serde", serde(rename = "ISOSctyLngNm"))]
pub iso_scty_lng_nm: Max350Text,
#[yaserde(rename = "ISOSctyShrtNm")]
#[cfg_attr(feature = "serde", serde(rename = "ISOSctyShrtNm"))]
pub iso_scty_shrt_nm: Max35Text,
#[yaserde(rename = "NmVldFr")]
#[cfg_attr(feature = "serde", serde(rename = "NmVldFr"))]
pub nm_vld_fr: DateAndDateTime2Choice,
#[yaserde(rename = "DnmtnCcy")]
#[cfg_attr(feature = "serde", serde(rename = "DnmtnCcy"))]
pub dnmtn_ccy: ActiveOrHistoricCurrencyCode,
#[yaserde(rename = "CertNb")]
#[cfg_attr(feature = "serde", serde(rename = "CertNb"))]
pub cert_nb: Max35Text,
#[yaserde(rename = "CtrctVrsnNb")]
#[cfg_attr(feature = "serde", serde(rename = "CtrctVrsnNb"))]
pub ctrct_vrsn_nb: Number,
#[yaserde(rename = "CpnAttchdNb")]
#[cfg_attr(feature = "serde", serde(rename = "CpnAttchdNb"))]
pub cpn_attchd_nb: Max3NumericText,
#[yaserde(rename = "TaxLotNb")]
#[cfg_attr(feature = "serde", serde(rename = "TaxLotNb"))]
pub tax_lot_nb: Max15NumericText,
#[yaserde(rename = "PoolNb")]
#[cfg_attr(feature = "serde", serde(rename = "PoolNb"))]
pub pool_nb: Max15NumericText,
#[yaserde(rename = "CvrdInd")]
#[cfg_attr(feature = "serde", serde(rename = "CvrdInd"))]
pub cvrd_ind: YesNoIndicator,
#[yaserde(rename = "LglRstrctns")]
#[cfg_attr(feature = "serde", serde(rename = "LglRstrctns"))]
pub lgl_rstrctns: LegalRestrictions4Choice,
#[yaserde(rename = "PosLmt")]
#[cfg_attr(feature = "serde", serde(rename = "PosLmt"))]
pub pos_lmt: FinancialInstrumentQuantity1Choice,
#[yaserde(rename = "NearTermPosLmt")]
#[cfg_attr(feature = "serde", serde(rename = "NearTermPosLmt"))]
pub near_term_pos_lmt: FinancialInstrumentQuantity1Choice,
#[yaserde(rename = "ListgDt")]
#[cfg_attr(feature = "serde", serde(rename = "ListgDt"))]
pub listg_dt: Isodate,
#[yaserde(rename = "RcrdDt")]
#[cfg_attr(feature = "serde", serde(rename = "RcrdDt"))]
pub rcrd_dt: IsodateTime,
#[yaserde(rename = "XpryDt")]
#[cfg_attr(feature = "serde", serde(rename = "XpryDt"))]
pub xpry_dt: Isodate,
#[yaserde(rename = "Purp")]
#[cfg_attr(feature = "serde", serde(rename = "Purp"))]
pub purp: Max256Text,
#[yaserde(rename = "ClssfctnTp")]
#[cfg_attr(feature = "serde", serde(rename = "ClssfctnTp"))]
pub clssfctn_tp: ClassificationType2,
#[yaserde(rename = "Issnc")]
#[cfg_attr(feature = "serde", serde(rename = "Issnc"))]
pub issnc: Issuance5,
#[yaserde(rename = "TradgMkt")]
#[cfg_attr(feature = "serde", serde(rename = "TradgMkt"))]
pub tradg_mkt: Vec<TradingParameters2>,
#[yaserde(rename = "SprdAndBchmkCrv")]
#[cfg_attr(feature = "serde", serde(rename = "SprdAndBchmkCrv"))]
pub sprd_and_bchmk_crv: Vec<BenchmarkCurve6>,
#[yaserde(rename = "PutTp")]
#[cfg_attr(feature = "serde", serde(rename = "PutTp"))]
pub put_tp: PutType3Choice,
#[yaserde(rename = "CallTp")]
#[cfg_attr(feature = "serde", serde(rename = "CallTp"))]
pub call_tp: CallType3Choice,
#[yaserde(rename = "FngbInd")]
#[cfg_attr(feature = "serde", serde(rename = "FngbInd"))]
pub fngb_ind: YesNoIndicator,
#[yaserde(rename = "Cnfdtl")]
#[cfg_attr(feature = "serde", serde(rename = "Cnfdtl"))]
pub cnfdtl: YesNoIndicator,
#[yaserde(rename = "PrvtPlcmnt")]
#[cfg_attr(feature = "serde", serde(rename = "PrvtPlcmnt"))]
pub prvt_plcmnt: YesNoIndicator,
#[yaserde(rename = "ConvtblInd")]
#[cfg_attr(feature = "serde", serde(rename = "ConvtblInd"))]
pub convtbl_ind: YesNoIndicator,
#[yaserde(rename = "ConvsPrd")]
#[cfg_attr(feature = "serde", serde(rename = "ConvsPrd"))]
pub convs_prd: DateTimePeriod1,
#[yaserde(rename = "ConvsRatioNmrtr")]
#[cfg_attr(feature = "serde", serde(rename = "ConvsRatioNmrtr"))]
pub convs_ratio_nmrtr: FinancialInstrumentQuantity1Choice,
#[yaserde(rename = "ConvsRatioDnmtr")]
#[cfg_attr(feature = "serde", serde(rename = "ConvsRatioDnmtr"))]
pub convs_ratio_dnmtr: FinancialInstrumentQuantity1Choice,
#[yaserde(rename = "PmryPlcOfDpst")]
#[cfg_attr(feature = "serde", serde(rename = "PmryPlcOfDpst"))]
pub pmry_plc_of_dpst: PartyIdentification136,
#[yaserde(rename = "TradgMtd")]
#[cfg_attr(feature = "serde", serde(rename = "TradgMtd"))]
pub tradg_mtd: UnitOrFaceAmount1Choice,
#[yaserde(rename = "TEFRARule")]
#[cfg_attr(feature = "serde", serde(rename = "TEFRARule"))]
pub tefra_rule: Tefrarules3Choice,
#[yaserde(rename = "SrNb")]
#[cfg_attr(feature = "serde", serde(rename = "SrNb"))]
pub sr_nb: Max16Text,
#[yaserde(rename = "Clss")]
#[cfg_attr(feature = "serde", serde(rename = "Clss"))]
pub clss: Max16Text,
#[yaserde(rename = "WhldgTaxRgm")]
#[cfg_attr(feature = "serde", serde(rename = "WhldgTaxRgm"))]
pub whldg_tax_rgm: Vec<SecurityWithHoldingTax1>,
#[yaserde(rename = "PmtSts")]
#[cfg_attr(feature = "serde", serde(rename = "PmtSts"))]
pub pmt_sts: SecuritiesPaymentStatus5Choice,
#[yaserde(rename = "InitlPhysForm")]
#[cfg_attr(feature = "serde", serde(rename = "InitlPhysForm"))]
pub initl_phys_form: InitialPhysicalForm4Choice,
#[yaserde(rename = "AftrXchgPhysForm")]
#[cfg_attr(feature = "serde", serde(rename = "AftrXchgPhysForm"))]
pub aftr_xchg_phys_form: InitialPhysicalForm3Choice,
#[yaserde(rename = "CmonSfkpr")]
#[cfg_attr(feature = "serde", serde(rename = "CmonSfkpr"))]
pub cmon_sfkpr: AnyBICDec2014Identifier,
#[yaserde(rename = "RedTp")]
#[cfg_attr(feature = "serde", serde(rename = "RedTp"))]
pub red_tp: MaturityRedemptionType3Choice,
#[yaserde(rename = "RedPmtCcy")]
#[cfg_attr(feature = "serde", serde(rename = "RedPmtCcy"))]
pub red_pmt_ccy: ActiveCurrencyCode,
#[yaserde(rename = "Rstrctn")]
#[cfg_attr(feature = "serde", serde(rename = "Rstrctn"))]
pub rstrctn: Vec<SecurityRestriction3>,
#[yaserde(rename = "SttlmInf")]
#[cfg_attr(feature = "serde", serde(rename = "SttlmInf"))]
pub sttlm_inf: Vec<SettlementInformation17>,
#[yaserde(rename = "FinInstrmForm")]
#[cfg_attr(feature = "serde", serde(rename = "FinInstrmForm"))]
pub fin_instrm_form: FinancialInstrumentForm2,
#[yaserde(rename = "CtctNm")]
#[cfg_attr(feature = "serde", serde(rename = "CtctNm"))]
pub ctct_nm: Organisation38,
#[yaserde(rename = "LeadMgr")]
#[cfg_attr(feature = "serde", serde(rename = "LeadMgr"))]
pub lead_mgr: Organisation38,
#[yaserde(rename = "PrncplPngAgt")]
#[cfg_attr(feature = "serde", serde(rename = "PrncplPngAgt"))]
pub prncpl_png_agt: Organisation38,
#[yaserde(rename = "PngAgt")]
#[cfg_attr(feature = "serde", serde(rename = "PngAgt"))]
pub png_agt: Organisation38,
#[yaserde(rename = "Dpstry")]
#[cfg_attr(feature = "serde", serde(rename = "Dpstry"))]
pub dpstry: Organisation38,
#[yaserde(rename = "UndrlygRsk")]
#[cfg_attr(feature = "serde", serde(rename = "UndrlygRsk"))]
pub undrlyg_rsk: Organisation38,
}
impl Validate for CommonFinancialInstrumentAttributes10 {}
#[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:reda.006.001.01")]
pub struct CommunicationAddress3 {
#[yaserde(rename = "Email")]
#[cfg_attr(feature = "serde", serde(rename = "Email"))]
pub email: Max256Text,
#[yaserde(rename = "Phne")]
#[cfg_attr(feature = "serde", serde(rename = "Phne"))]
pub phne: PhoneNumber,
#[yaserde(rename = "Mob")]
#[cfg_attr(feature = "serde", serde(rename = "Mob"))]
pub mob: PhoneNumber,
#[yaserde(rename = "FaxNb")]
#[cfg_attr(feature = "serde", serde(rename = "FaxNb"))]
pub fax_nb: PhoneNumber,
#[yaserde(rename = "TlxAdr")]
#[cfg_attr(feature = "serde", serde(rename = "TlxAdr"))]
pub tlx_adr: Max35Text,
#[yaserde(rename = "URLAdr")]
#[cfg_attr(feature = "serde", serde(rename = "URLAdr"))]
pub url_adr: Max256Text,
}
impl Validate for CommunicationAddress3 {}
#[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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:reda.006.001.01")]
pub struct DateAndDateTime2Choice {
#[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 DateAndDateTime2Choice {}
#[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:reda.006.001.01")]
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:reda.006.001.01")]
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:reda.006.001.01")]
pub struct DateTimePeriod2 {
#[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 DateTimePeriod2 {}
#[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:reda.006.001.01")]
pub struct Debt5 {
#[yaserde(rename = "PmtCcy")]
#[cfg_attr(feature = "serde", serde(rename = "PmtCcy"))]
pub pmt_ccy: ActiveCurrencyCode,
#[yaserde(rename = "FaceAmt")]
#[cfg_attr(feature = "serde", serde(rename = "FaceAmt"))]
pub face_amt: ActiveCurrencyAndAmount,
#[yaserde(rename = "PmtFrqcy")]
#[cfg_attr(feature = "serde", serde(rename = "PmtFrqcy"))]
pub pmt_frqcy: Frequency35Choice,
#[yaserde(rename = "IntrstFxgDt")]
#[cfg_attr(feature = "serde", serde(rename = "IntrstFxgDt"))]
pub intrst_fxg_dt: IsodateTime,
#[yaserde(rename = "DtdDt")]
#[cfg_attr(feature = "serde", serde(rename = "DtdDt"))]
pub dtd_dt: IsodateTime,
#[yaserde(rename = "FrstPmtDt")]
#[cfg_attr(feature = "serde", serde(rename = "FrstPmtDt"))]
pub frst_pmt_dt: IsodateTime,
#[yaserde(rename = "MtrtyDt")]
#[cfg_attr(feature = "serde", serde(rename = "MtrtyDt"))]
pub mtrty_dt: IsodateTime,
#[yaserde(rename = "NxtCpnDt")]
#[cfg_attr(feature = "serde", serde(rename = "NxtCpnDt"))]
pub nxt_cpn_dt: IsodateTime,
#[yaserde(rename = "PutblDt")]
#[cfg_attr(feature = "serde", serde(rename = "PutblDt"))]
pub putbl_dt: IsodateTime,
#[yaserde(rename = "NxtCllblDt")]
#[cfg_attr(feature = "serde", serde(rename = "NxtCllblDt"))]
pub nxt_cllbl_dt: IsodateTime,
#[yaserde(rename = "NxtFctrDt")]
#[cfg_attr(feature = "serde", serde(rename = "NxtFctrDt"))]
pub nxt_fctr_dt: IsodateTime,
#[yaserde(rename = "XprtnDt")]
#[cfg_attr(feature = "serde", serde(rename = "XprtnDt"))]
pub xprtn_dt: IsodateTime,
#[yaserde(rename = "PmtDrctnInd")]
#[cfg_attr(feature = "serde", serde(rename = "PmtDrctnInd"))]
pub pmt_drctn_ind: PaymentDirectionIndicator,
#[yaserde(rename = "IntrstRate")]
#[cfg_attr(feature = "serde", serde(rename = "IntrstRate"))]
pub intrst_rate: PercentageRate,
#[yaserde(rename = "NxtIntrstRate")]
#[cfg_attr(feature = "serde", serde(rename = "NxtIntrstRate"))]
pub nxt_intrst_rate: PercentageRate,
#[yaserde(rename = "OddCpnInd")]
#[cfg_attr(feature = "serde", serde(rename = "OddCpnInd"))]
pub odd_cpn_ind: YesNoIndicator,
#[yaserde(rename = "CllblInd")]
#[cfg_attr(feature = "serde", serde(rename = "CllblInd"))]
pub cllbl_ind: YesNoIndicator,
#[yaserde(rename = "CPPrgm")]
#[cfg_attr(feature = "serde", serde(rename = "CPPrgm"))]
pub cp_prgm: Number,
#[yaserde(rename = "CPRegnTp")]
#[cfg_attr(feature = "serde", serde(rename = "CPRegnTp"))]
pub cp_regn_tp: Max350Text,
#[yaserde(rename = "IntrstAcrlDt")]
#[cfg_attr(feature = "serde", serde(rename = "IntrstAcrlDt"))]
pub intrst_acrl_dt: IsodateTime,
#[yaserde(rename = "PutblInd")]
#[cfg_attr(feature = "serde", serde(rename = "PutblInd"))]
pub putbl_ind: YesNoIndicator,
#[yaserde(rename = "PreFnddInd")]
#[cfg_attr(feature = "serde", serde(rename = "PreFnddInd"))]
pub pre_fndd_ind: YesNoIndicator,
#[yaserde(rename = "EscrwdInd")]
#[cfg_attr(feature = "serde", serde(rename = "EscrwdInd"))]
pub escrwd_ind: YesNoIndicator,
#[yaserde(rename = "PerptlInd")]
#[cfg_attr(feature = "serde", serde(rename = "PerptlInd"))]
pub perptl_ind: YesNoIndicator,
#[yaserde(rename = "SubrdntdInd")]
#[cfg_attr(feature = "serde", serde(rename = "SubrdntdInd"))]
pub subrdntd_ind: YesNoIndicator,
#[yaserde(rename = "XtndblInd")]
#[cfg_attr(feature = "serde", serde(rename = "XtndblInd"))]
pub xtndbl_ind: YesNoIndicator,
#[yaserde(rename = "XtndblPrd")]
#[cfg_attr(feature = "serde", serde(rename = "XtndblPrd"))]
pub xtndbl_prd: DateTimePeriod1Choice,
#[yaserde(rename = "VarblRateInd")]
#[cfg_attr(feature = "serde", serde(rename = "VarblRateInd"))]
pub varbl_rate_ind: YesNoIndicator,
#[yaserde(rename = "OverAlltmtAmt")]
#[cfg_attr(feature = "serde", serde(rename = "OverAlltmtAmt"))]
pub over_alltmt_amt: ActiveCurrencyAndAmount,
#[yaserde(rename = "OverAlltmtRate")]
#[cfg_attr(feature = "serde", serde(rename = "OverAlltmtRate"))]
pub over_alltmt_rate: PercentageRate,
#[yaserde(rename = "AmtsblInd")]
#[cfg_attr(feature = "serde", serde(rename = "AmtsblInd"))]
pub amtsbl_ind: YesNoIndicator,
#[yaserde(rename = "IntrstClctnMtd")]
#[cfg_attr(feature = "serde", serde(rename = "IntrstClctnMtd"))]
pub intrst_clctn_mtd: Max70Text,
#[yaserde(rename = "CptlsdIntrst")]
#[cfg_attr(feature = "serde", serde(rename = "CptlsdIntrst"))]
pub cptlsd_intrst: DistributionPolicy2Choice,
#[yaserde(rename = "ActlDnmtnAmt")]
#[cfg_attr(feature = "serde", serde(rename = "ActlDnmtnAmt"))]
pub actl_dnmtn_amt: Vec<ActiveCurrencyAndAmount>,
#[yaserde(rename = "CurFctr")]
#[cfg_attr(feature = "serde", serde(rename = "CurFctr"))]
pub cur_fctr: PercentageRate,
#[yaserde(rename = "NxtFctr")]
#[cfg_attr(feature = "serde", serde(rename = "NxtFctr"))]
pub nxt_fctr: PercentageRate,
#[yaserde(rename = "PrvsFctr")]
#[cfg_attr(feature = "serde", serde(rename = "PrvsFctr"))]
pub prvs_fctr: PercentageRate,
#[yaserde(rename = "Pcs")]
#[cfg_attr(feature = "serde", serde(rename = "Pcs"))]
pub pcs: DecimalNumber,
#[yaserde(rename = "PlsMax")]
#[cfg_attr(feature = "serde", serde(rename = "PlsMax"))]
pub pls_max: DecimalNumber,
#[yaserde(rename = "PlsPerMln")]
#[cfg_attr(feature = "serde", serde(rename = "PlsPerMln"))]
pub pls_per_mln: DecimalNumber,
#[yaserde(rename = "PlsPerLot")]
#[cfg_attr(feature = "serde", serde(rename = "PlsPerLot"))]
pub pls_per_lot: DecimalNumber,
#[yaserde(rename = "PlsPerTrad")]
#[cfg_attr(feature = "serde", serde(rename = "PlsPerTrad"))]
pub pls_per_trad: DecimalNumber,
#[yaserde(rename = "CstPrePmtPnltyInd")]
#[cfg_attr(feature = "serde", serde(rename = "CstPrePmtPnltyInd"))]
pub cst_pre_pmt_pnlty_ind: YesNoIndicator,
#[yaserde(rename = "LotId")]
#[cfg_attr(feature = "serde", serde(rename = "LotId"))]
pub lot_id: Max35Text,
#[yaserde(rename = "CstPrePmtYld")]
#[cfg_attr(feature = "serde", serde(rename = "CstPrePmtYld"))]
pub cst_pre_pmt_yld: PercentageRate,
#[yaserde(rename = "WghtdAvrgCpn")]
#[cfg_attr(feature = "serde", serde(rename = "WghtdAvrgCpn"))]
pub wghtd_avrg_cpn: PercentageRate,
#[yaserde(rename = "WghtdAvrgLife")]
#[cfg_attr(feature = "serde", serde(rename = "WghtdAvrgLife"))]
pub wghtd_avrg_life: DecimalNumber,
#[yaserde(rename = "WghtdAvrgLn")]
#[cfg_attr(feature = "serde", serde(rename = "WghtdAvrgLn"))]
pub wghtd_avrg_ln: DecimalNumber,
#[yaserde(rename = "WghtdAvrgMtrty")]
#[cfg_attr(feature = "serde", serde(rename = "WghtdAvrgMtrty"))]
pub wghtd_avrg_mtrty: DecimalNumber,
#[yaserde(rename = "InsrdInd")]
#[cfg_attr(feature = "serde", serde(rename = "InsrdInd"))]
pub insrd_ind: YesNoIndicator,
#[yaserde(rename = "BkQlfdInd")]
#[cfg_attr(feature = "serde", serde(rename = "BkQlfdInd"))]
pub bk_qlfd_ind: YesNoIndicator,
#[yaserde(rename = "YldClctn")]
#[cfg_attr(feature = "serde", serde(rename = "YldClctn"))]
pub yld_clctn: Vec<YieldCalculation6>,
#[yaserde(rename = "IntrstTp")]
#[cfg_attr(feature = "serde", serde(rename = "IntrstTp"))]
pub intrst_tp: InterestType3Code,
#[yaserde(rename = "InstrmStrTp")]
#[cfg_attr(feature = "serde", serde(rename = "InstrmStrTp"))]
pub instrm_str_tp: InstrumentSubStructureType2Choice,
#[yaserde(rename = "GblTp")]
#[cfg_attr(feature = "serde", serde(rename = "GblTp"))]
pub gbl_tp: GlobalNote2Choice,
#[yaserde(rename = "PotntlEuroSysElgblty")]
#[cfg_attr(feature = "serde", serde(rename = "PotntlEuroSysElgblty"))]
pub potntl_euro_sys_elgblty: YesNoIndicator,
#[yaserde(rename = "Geogcs")]
#[cfg_attr(feature = "serde", serde(rename = "Geogcs"))]
pub geogcs: Max35Text,
#[yaserde(rename = "YldRg")]
#[cfg_attr(feature = "serde", serde(rename = "YldRg"))]
pub yld_rg: AmountOrPercentageRange1,
#[yaserde(rename = "CpnRg")]
#[cfg_attr(feature = "serde", serde(rename = "CpnRg"))]
pub cpn_rg: AmountOrPercentageRange1,
#[yaserde(rename = "Purp")]
#[cfg_attr(feature = "serde", serde(rename = "Purp"))]
pub purp: Max256Text,
#[yaserde(rename = "AltrntvMinTaxInd")]
#[cfg_attr(feature = "serde", serde(rename = "AltrntvMinTaxInd"))]
pub altrntv_min_tax_ind: YesNoIndicator,
#[yaserde(rename = "AutoRinvstmt")]
#[cfg_attr(feature = "serde", serde(rename = "AutoRinvstmt"))]
pub auto_rinvstmt: PercentageRate,
#[yaserde(rename = "Hrcut")]
#[cfg_attr(feature = "serde", serde(rename = "Hrcut"))]
pub hrcut: PercentageRate,
#[yaserde(rename = "TxConds")]
#[cfg_attr(feature = "serde", serde(rename = "TxConds"))]
pub tx_conds: TradeTransactionCondition7Choice,
#[yaserde(rename = "LookBck")]
#[cfg_attr(feature = "serde", serde(rename = "LookBck"))]
pub look_bck: Number,
#[yaserde(rename = "MaxSbstitn")]
#[cfg_attr(feature = "serde", serde(rename = "MaxSbstitn"))]
pub max_sbstitn: Number,
#[yaserde(rename = "MinIncrmt")]
#[cfg_attr(feature = "serde", serde(rename = "MinIncrmt"))]
pub min_incrmt: FinancialInstrumentQuantity1Choice,
#[yaserde(rename = "MinQty")]
#[cfg_attr(feature = "serde", serde(rename = "MinQty"))]
pub min_qty: FinancialInstrumentQuantity1Choice,
#[yaserde(rename = "Pdctn")]
#[cfg_attr(feature = "serde", serde(rename = "Pdctn"))]
pub pdctn: Max35Text,
#[yaserde(rename = "RstrctdInd")]
#[cfg_attr(feature = "serde", serde(rename = "RstrctdInd"))]
pub rstrctd_ind: YesNoIndicator,
#[yaserde(rename = "PricFrqcy")]
#[cfg_attr(feature = "serde", serde(rename = "PricFrqcy"))]
pub pric_frqcy: Frequency35Choice,
#[yaserde(rename = "Sctr")]
#[cfg_attr(feature = "serde", serde(rename = "Sctr"))]
pub sctr: Max35Text,
#[yaserde(rename = "SbstitnFrqcy")]
#[cfg_attr(feature = "serde", serde(rename = "SbstitnFrqcy"))]
pub sbstitn_frqcy: Frequency35Choice,
#[yaserde(rename = "SbstitnLft")]
#[cfg_attr(feature = "serde", serde(rename = "SbstitnLft"))]
pub sbstitn_lft: Number,
#[yaserde(rename = "WhlPoolInd")]
#[cfg_attr(feature = "serde", serde(rename = "WhlPoolInd"))]
pub whl_pool_ind: YesNoIndicator,
#[yaserde(rename = "PricSrc")]
#[cfg_attr(feature = "serde", serde(rename = "PricSrc"))]
pub pric_src: Max35Text,
#[yaserde(rename = "PricRg")]
#[cfg_attr(feature = "serde", serde(rename = "PricRg"))]
pub pric_rg: AmountOrPercentageRange1,
}
impl Validate for Debt5 {}
#[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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:reda.006.001.01")]
pub struct Derivative4 {
#[yaserde(rename = "Futr")]
#[cfg_attr(feature = "serde", serde(rename = "Futr"))]
pub futr: Future4,
#[yaserde(rename = "Optn")]
#[cfg_attr(feature = "serde", serde(rename = "Optn"))]
pub optn: Option15,
}
impl Validate for Derivative4 {}
#[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:reda.006.001.01")]
pub enum DistributionPolicy1Code {
#[yaserde(rename = "DIST")]
#[cfg_attr(feature = "serde", serde(rename = "DIST"))]
Dist,
#[yaserde(rename = "ACCU")]
#[cfg_attr(feature = "serde", serde(rename = "ACCU"))]
Accu,
__Unknown__(String),
}
impl Default for DistributionPolicy1Code {
fn default() -> DistributionPolicy1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for DistributionPolicy1Code {}
#[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:reda.006.001.01")]
pub struct DistributionPolicy2Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<DistributionPolicy1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for DistributionPolicy2Choice {}
#[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:reda.006.001.01")]
pub struct Document {
#[yaserde(rename = "SctyCreReq")]
#[cfg_attr(feature = "serde", serde(rename = "SctyCreReq"))]
pub scty_cre_req: SecurityCreationRequestV01,
}
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:reda.006.001.01")]
pub struct Equity3 {
#[yaserde(rename = "PrefToIncm")]
#[cfg_attr(feature = "serde", serde(rename = "PrefToIncm"))]
pub pref_to_incm: PreferenceToIncome5Choice,
#[yaserde(rename = "MtrtyDt")]
#[cfg_attr(feature = "serde", serde(rename = "MtrtyDt"))]
pub mtrty_dt: IsodateTime,
#[yaserde(rename = "NonPdAmt")]
#[cfg_attr(feature = "serde", serde(rename = "NonPdAmt"))]
pub non_pd_amt: ActiveCurrencyAndAmount,
#[yaserde(rename = "ParVal")]
#[cfg_attr(feature = "serde", serde(rename = "ParVal"))]
pub par_val: ActiveCurrencyAndAmount,
#[yaserde(rename = "VtngRghtsPerShr")]
#[cfg_attr(feature = "serde", serde(rename = "VtngRghtsPerShr"))]
pub vtng_rghts_per_shr: Number,
}
impl Validate for Equity3 {}
#[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 ExternalFinancialInstrumentProductType1Code (pub String);
crate::simple_type!(ExternalFinancialInstrumentProductType1Code);
impl Validate for ExternalFinancialInstrumentProductType1Code {
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:reda.006.001.01")]
pub struct FinancialInstrument97 {
#[yaserde(rename = "Eqty")]
#[cfg_attr(feature = "serde", serde(rename = "Eqty"))]
pub eqty: Equity3,
#[yaserde(rename = "Warrt")]
#[cfg_attr(feature = "serde", serde(rename = "Warrt"))]
pub warrt: Warrant4,
#[yaserde(rename = "Debt")]
#[cfg_attr(feature = "serde", serde(rename = "Debt"))]
pub debt: Debt5,
#[yaserde(rename = "Deriv")]
#[cfg_attr(feature = "serde", serde(rename = "Deriv"))]
pub deriv: Derivative4,
}
impl Validate for FinancialInstrument97 {}
#[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:reda.006.001.01")]
pub struct FinancialInstrumentForm2 {
#[yaserde(rename = "BookgApprnc")]
#[cfg_attr(feature = "serde", serde(rename = "BookgApprnc"))]
pub bookg_apprnc: Appearance3Choice,
#[yaserde(rename = "LglForm")]
#[cfg_attr(feature = "serde", serde(rename = "LglForm"))]
pub lgl_form: FormOfSecurity8Choice,
}
impl Validate for FinancialInstrumentForm2 {}
#[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:reda.006.001.01")]
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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:reda.006.001.01")]
pub enum FormOfSecurity1Code {
#[yaserde(rename = "BEAR")]
#[cfg_attr(feature = "serde", serde(rename = "BEAR"))]
Bear,
#[yaserde(rename = "REGD")]
#[cfg_attr(feature = "serde", serde(rename = "REGD"))]
Regd,
__Unknown__(String),
}
impl Default for FormOfSecurity1Code {
fn default() -> FormOfSecurity1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for FormOfSecurity1Code {}
#[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:reda.006.001.01")]
pub struct FormOfSecurity8Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<FormOfSecurity1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for FormOfSecurity8Choice {}
#[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:reda.006.001.01")]
pub struct Frequency35Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<Frequency5Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for Frequency35Choice {}
#[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:reda.006.001.01")]
pub enum Frequency5Code {
#[yaserde(rename = "YEAR")]
#[cfg_attr(feature = "serde", serde(rename = "YEAR"))]
Year,
#[yaserde(rename = "MNTH")]
#[cfg_attr(feature = "serde", serde(rename = "MNTH"))]
Mnth,
#[yaserde(rename = "QURT")]
#[cfg_attr(feature = "serde", serde(rename = "QURT"))]
Qurt,
#[yaserde(rename = "MIAN")]
#[cfg_attr(feature = "serde", serde(rename = "MIAN"))]
Mian,
#[yaserde(rename = "WEEK")]
#[cfg_attr(feature = "serde", serde(rename = "WEEK"))]
Week,
#[yaserde(rename = "DAIL")]
#[cfg_attr(feature = "serde", serde(rename = "DAIL"))]
Dail,
#[yaserde(rename = "ADHO")]
#[cfg_attr(feature = "serde", serde(rename = "ADHO"))]
Adho,
#[yaserde(rename = "INDA")]
#[cfg_attr(feature = "serde", serde(rename = "INDA"))]
Inda,
#[yaserde(rename = "OVNG")]
#[cfg_attr(feature = "serde", serde(rename = "OVNG"))]
Ovng,
#[yaserde(rename = "TEND")]
#[cfg_attr(feature = "serde", serde(rename = "TEND"))]
Tend,
__Unknown__(String),
}
impl Default for Frequency5Code {
fn default() -> Frequency5Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for Frequency5Code {}
#[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:reda.006.001.01")]
pub struct Future4 {
#[yaserde(rename = "CtrctSz")]
#[cfg_attr(feature = "serde", serde(rename = "CtrctSz"))]
pub ctrct_sz: BaseOneRate,
#[yaserde(rename = "ExrcPric")]
#[cfg_attr(feature = "serde", serde(rename = "ExrcPric"))]
pub exrc_pric: Price8,
#[yaserde(rename = "FutrDt")]
#[cfg_attr(feature = "serde", serde(rename = "FutrDt"))]
pub futr_dt: IsodateTime,
#[yaserde(rename = "MinSz")]
#[cfg_attr(feature = "serde", serde(rename = "MinSz"))]
pub min_sz: ActiveCurrencyAndAmount,
#[yaserde(rename = "UnitOfMeasr")]
#[cfg_attr(feature = "serde", serde(rename = "UnitOfMeasr"))]
pub unit_of_measr: UnitOfMeasure7Choice,
#[yaserde(rename = "TmUnit")]
#[cfg_attr(feature = "serde", serde(rename = "TmUnit"))]
pub tm_unit: TimeUnit3Choice,
#[yaserde(rename = "AddtlUndrlygAttrbts")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlUndrlygAttrbts"))]
pub addtl_undrlyg_attrbts: Vec<UnderlyingAttributes4>,
}
impl Validate for Future4 {}
#[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:reda.006.001.01")]
pub struct GenericIdentification1 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max35Text,
#[yaserde(rename = "SchmeNm")]
#[cfg_attr(feature = "serde", serde(rename = "SchmeNm"))]
pub schme_nm: Max35Text,
#[yaserde(rename = "Issr")]
#[cfg_attr(feature = "serde", serde(rename = "Issr"))]
pub issr: Max35Text,
}
impl Validate for GenericIdentification1 {}
#[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:reda.006.001.01")]
pub struct GenericIdentification13 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max4AlphaNumericText,
#[yaserde(rename = "SchmeNm")]
#[cfg_attr(feature = "serde", serde(rename = "SchmeNm"))]
pub schme_nm: Max35Text,
#[yaserde(rename = "Issr")]
#[cfg_attr(feature = "serde", serde(rename = "Issr"))]
pub issr: Max35Text,
}
impl Validate for GenericIdentification13 {}
#[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:reda.006.001.01")]
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:reda.006.001.01")]
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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:reda.006.001.01")]
pub enum GlobalNote1Code {
#[yaserde(rename = "NGNO")]
#[cfg_attr(feature = "serde", serde(rename = "NGNO"))]
Ngno,
#[yaserde(rename = "CGNO")]
#[cfg_attr(feature = "serde", serde(rename = "CGNO"))]
Cgno,
__Unknown__(String),
}
impl Default for GlobalNote1Code {
fn default() -> GlobalNote1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for GlobalNote1Code {}
#[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:reda.006.001.01")]
pub struct GlobalNote2Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<GlobalNote1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for GlobalNote2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Isin2021Identifier (pub String);
crate::simple_type!(Isin2021Identifier);
impl Validate for Isin2021Identifier {}
#[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)]
pub struct IsoyearMonth (pub String);
crate::simple_type!(IsoyearMonth);
impl Validate for IsoyearMonth {}
#[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:reda.006.001.01")]
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)]
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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:reda.006.001.01")]
pub enum InitialPhysicalForm1Code {
#[yaserde(rename = "GTGT")]
#[cfg_attr(feature = "serde", serde(rename = "GTGT"))]
Gtgt,
#[yaserde(rename = "GPGP")]
#[cfg_attr(feature = "serde", serde(rename = "GPGP"))]
Gpgp,
#[yaserde(rename = "DERN")]
#[cfg_attr(feature = "serde", serde(rename = "DERN"))]
Dern,
__Unknown__(String),
}
impl Default for InitialPhysicalForm1Code {
fn default() -> InitialPhysicalForm1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for InitialPhysicalForm1Code {}
#[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:reda.006.001.01")]
pub enum InitialPhysicalForm2Code {
#[yaserde(rename = "GPGP")]
#[cfg_attr(feature = "serde", serde(rename = "GPGP"))]
Gpgp,
#[yaserde(rename = "DERN")]
#[cfg_attr(feature = "serde", serde(rename = "DERN"))]
Dern,
__Unknown__(String),
}
impl Default for InitialPhysicalForm2Code {
fn default() -> InitialPhysicalForm2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for InitialPhysicalForm2Code {}
#[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:reda.006.001.01")]
pub struct InitialPhysicalForm3Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<InitialPhysicalForm2Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for InitialPhysicalForm3Choice {}
#[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:reda.006.001.01")]
pub struct InitialPhysicalForm4Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<InitialPhysicalForm1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for InitialPhysicalForm4Choice {}
#[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:reda.006.001.01")]
pub enum InstrumentSubStructureType1Code {
#[yaserde(rename = "ABSE")]
#[cfg_attr(feature = "serde", serde(rename = "ABSE"))]
Abse,
#[yaserde(rename = "AIRT")]
#[cfg_attr(feature = "serde", serde(rename = "AIRT"))]
Airt,
#[yaserde(rename = "AUTT")]
#[cfg_attr(feature = "serde", serde(rename = "AUTT"))]
Autt,
#[yaserde(rename = "CBOB")]
#[cfg_attr(feature = "serde", serde(rename = "CBOB"))]
Cbob,
#[yaserde(rename = "CDOB")]
#[cfg_attr(feature = "serde", serde(rename = "CDOB"))]
Cdob,
#[yaserde(rename = "CLNO")]
#[cfg_attr(feature = "serde", serde(rename = "CLNO"))]
Clno,
#[yaserde(rename = "CLOB")]
#[cfg_attr(feature = "serde", serde(rename = "CLOB"))]
Clob,
#[yaserde(rename = "CMBS")]
#[cfg_attr(feature = "serde", serde(rename = "CMBS"))]
Cmbs,
#[yaserde(rename = "CSMR")]
#[cfg_attr(feature = "serde", serde(rename = "CSMR"))]
Csmr,
#[yaserde(rename = "CRCT")]
#[cfg_attr(feature = "serde", serde(rename = "CRCT"))]
Crct,
#[yaserde(rename = "HELO")]
#[cfg_attr(feature = "serde", serde(rename = "HELO"))]
Helo,
#[yaserde(rename = "LPNO")]
#[cfg_attr(feature = "serde", serde(rename = "LPNO"))]
Lpno,
#[yaserde(rename = "PFAB")]
#[cfg_attr(feature = "serde", serde(rename = "PFAB"))]
Pfab,
#[yaserde(rename = "PYRT")]
#[cfg_attr(feature = "serde", serde(rename = "PYRT"))]
Pyrt,
#[yaserde(rename = "REPK")]
#[cfg_attr(feature = "serde", serde(rename = "REPK"))]
Repk,
#[yaserde(rename = "RMBS")]
#[cfg_attr(feature = "serde", serde(rename = "RMBS"))]
Rmbs,
#[yaserde(rename = "SCBO")]
#[cfg_attr(feature = "serde", serde(rename = "SCBO"))]
Scbo,
#[yaserde(rename = "STRB")]
#[cfg_attr(feature = "serde", serde(rename = "STRB"))]
Strb,
#[yaserde(rename = "STUT")]
#[cfg_attr(feature = "serde", serde(rename = "STUT"))]
Stut,
#[yaserde(rename = "WBSE")]
#[cfg_attr(feature = "serde", serde(rename = "WBSE"))]
Wbse,
__Unknown__(String),
}
impl Default for InstrumentSubStructureType1Code {
fn default() -> InstrumentSubStructureType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for InstrumentSubStructureType1Code {}
#[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:reda.006.001.01")]
pub struct InstrumentSubStructureType2Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<InstrumentSubStructureType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for InstrumentSubStructureType2Choice {}
#[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:reda.006.001.01")]
pub enum InterestType3Code {
#[yaserde(rename = "ZCPN")]
#[cfg_attr(feature = "serde", serde(rename = "ZCPN"))]
Zcpn,
#[yaserde(rename = "FIXD")]
#[cfg_attr(feature = "serde", serde(rename = "FIXD"))]
Fixd,
#[yaserde(rename = "FLRN")]
#[cfg_attr(feature = "serde", serde(rename = "FLRN"))]
Flrn,
#[yaserde(rename = "DUAL")]
#[cfg_attr(feature = "serde", serde(rename = "DUAL"))]
Dual,
#[yaserde(rename = "INDE")]
#[cfg_attr(feature = "serde", serde(rename = "INDE"))]
Inde,
#[yaserde(rename = "DSCO")]
#[cfg_attr(feature = "serde", serde(rename = "DSCO"))]
Dsco,
__Unknown__(String),
}
impl Default for InterestType3Code {
fn default() -> InterestType3Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for InterestType3Code {}
#[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:reda.006.001.01")]
pub enum InvestorRestrictionType1Code {
#[yaserde(rename = "LERE")]
#[cfg_attr(feature = "serde", serde(rename = "LERE"))]
Lere,
#[yaserde(rename = "CITI")]
#[cfg_attr(feature = "serde", serde(rename = "CITI"))]
Citi,
#[yaserde(rename = "INDV")]
#[cfg_attr(feature = "serde", serde(rename = "INDV"))]
Indv,
__Unknown__(String),
}
impl Default for InvestorRestrictionType1Code {
fn default() -> InvestorRestrictionType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for InvestorRestrictionType1Code {}
#[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:reda.006.001.01")]
pub struct InvestorRestrictionType3Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<InvestorRestrictionType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for InvestorRestrictionType3Choice {}
#[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:reda.006.001.01")]
pub enum InvestorType1Code {
#[yaserde(rename = "RETL")]
#[cfg_attr(feature = "serde", serde(rename = "RETL"))]
Retl,
#[yaserde(rename = "PROF")]
#[cfg_attr(feature = "serde", serde(rename = "PROF"))]
Prof,
#[yaserde(rename = "STAF")]
#[cfg_attr(feature = "serde", serde(rename = "STAF"))]
Staf,
#[yaserde(rename = "PPER")]
#[cfg_attr(feature = "serde", serde(rename = "PPER"))]
Pper,
__Unknown__(String),
}
impl Default for InvestorType1Code {
fn default() -> InvestorType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for InvestorType1Code {}
#[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:reda.006.001.01")]
pub struct InvestorType3Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<InvestorType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for InvestorType3Choice {}
#[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:reda.006.001.01")]
pub struct Issuance5 {
#[yaserde(rename = "IssePlc")]
#[cfg_attr(feature = "serde", serde(rename = "IssePlc"))]
pub isse_plc: Micidentifier,
#[yaserde(rename = "CtryOfIsse")]
#[cfg_attr(feature = "serde", serde(rename = "CtryOfIsse"))]
pub ctry_of_isse: CountryCode,
#[yaserde(rename = "IsseDt")]
#[cfg_attr(feature = "serde", serde(rename = "IsseDt"))]
pub isse_dt: Isodate,
#[yaserde(rename = "AnncmntDt")]
#[cfg_attr(feature = "serde", serde(rename = "AnncmntDt"))]
pub anncmnt_dt: IsodateTime,
#[yaserde(rename = "ISINVldFr")]
#[cfg_attr(feature = "serde", serde(rename = "ISINVldFr"))]
pub isin_vld_fr: Isodate,
#[yaserde(rename = "IssrOrg")]
#[cfg_attr(feature = "serde", serde(rename = "IssrOrg"))]
pub issr_org: Organisation38,
#[yaserde(rename = "IsseNmnlAmt")]
#[cfg_attr(feature = "serde", serde(rename = "IsseNmnlAmt"))]
pub isse_nmnl_amt: FinancialInstrumentQuantity1Choice,
#[yaserde(rename = "FullIssdAmt")]
#[cfg_attr(feature = "serde", serde(rename = "FullIssdAmt"))]
pub full_issd_amt: ActiveCurrencyAndAmount,
#[yaserde(rename = "IsseSz")]
#[cfg_attr(feature = "serde", serde(rename = "IsseSz"))]
pub isse_sz: Number,
#[yaserde(rename = "IssePric")]
#[cfg_attr(feature = "serde", serde(rename = "IssePric"))]
pub isse_pric: PriceValue1,
#[yaserde(rename = "IssncDstrbtn")]
#[cfg_attr(feature = "serde", serde(rename = "IssncDstrbtn"))]
pub issnc_dstrbtn: SecuritiesTransactionType31Choice,
#[yaserde(rename = "GovngLaw")]
#[cfg_attr(feature = "serde", serde(rename = "GovngLaw"))]
pub govng_law: Vec<Jurisdiction1>,
}
impl Validate for Issuance5 {}
#[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:reda.006.001.01")]
pub struct Jurisdiction1 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max70Text,
#[yaserde(rename = "Ctry")]
#[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
pub ctry: CountryCode,
}
impl Validate for Jurisdiction1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Leiidentifier (pub String);
crate::simple_type!(Leiidentifier);
impl Validate for Leiidentifier {}
#[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:reda.006.001.01")]
pub enum LegalRestrictions1Code {
#[yaserde(rename = "USLE")]
#[cfg_attr(feature = "serde", serde(rename = "USLE"))]
Usle,
#[yaserde(rename = "NORE")]
#[cfg_attr(feature = "serde", serde(rename = "NORE"))]
Nore,
#[yaserde(rename = "REST")]
#[cfg_attr(feature = "serde", serde(rename = "REST"))]
Rest,
__Unknown__(String),
}
impl Default for LegalRestrictions1Code {
fn default() -> LegalRestrictions1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for LegalRestrictions1Code {}
#[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:reda.006.001.01")]
pub enum LegalRestrictions2Code {
#[yaserde(rename = "JURO")]
#[cfg_attr(feature = "serde", serde(rename = "JURO"))]
Juro,
#[yaserde(rename = "PPLA")]
#[cfg_attr(feature = "serde", serde(rename = "PPLA"))]
Ppla,
#[yaserde(rename = "ACRI")]
#[cfg_attr(feature = "serde", serde(rename = "ACRI"))]
Acri,
#[yaserde(rename = "MARG")]
#[cfg_attr(feature = "serde", serde(rename = "MARG"))]
Marg,
#[yaserde(rename = "PRIV")]
#[cfg_attr(feature = "serde", serde(rename = "PRIV"))]
Priv,
__Unknown__(String),
}
impl Default for LegalRestrictions2Code {
fn default() -> LegalRestrictions2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for LegalRestrictions2Code {}
#[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:reda.006.001.01")]
pub struct LegalRestrictions4Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<LegalRestrictions1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for LegalRestrictions4Choice {}
#[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:reda.006.001.01")]
pub struct LegalRestrictions5Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<LegalRestrictions2Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for LegalRestrictions5Choice {}
#[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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:reda.006.001.01")]
pub enum MaturityRedemptionType1Code {
#[yaserde(rename = "FRED")]
#[cfg_attr(feature = "serde", serde(rename = "FRED"))]
Fred,
#[yaserde(rename = "PRNR")]
#[cfg_attr(feature = "serde", serde(rename = "PRNR"))]
Prnr,
#[yaserde(rename = "PRWR")]
#[cfg_attr(feature = "serde", serde(rename = "PRWR"))]
Prwr,
#[yaserde(rename = "RNDM")]
#[cfg_attr(feature = "serde", serde(rename = "RNDM"))]
Rndm,
#[yaserde(rename = "PRRA")]
#[cfg_attr(feature = "serde", serde(rename = "PRRA"))]
Prra,
#[yaserde(rename = "CALL")]
#[cfg_attr(feature = "serde", serde(rename = "CALL"))]
Call,
#[yaserde(rename = "PUUT")]
#[cfg_attr(feature = "serde", serde(rename = "PUUT"))]
Puut,
__Unknown__(String),
}
impl Default for MaturityRedemptionType1Code {
fn default() -> MaturityRedemptionType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for MaturityRedemptionType1Code {}
#[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:reda.006.001.01")]
pub struct MaturityRedemptionType3Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<MaturityRedemptionType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for MaturityRedemptionType3Choice {}
#[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 Max15NumericText (pub String);
crate::simple_type!(Max15NumericText);
impl Validate for Max15NumericText {}
#[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 Max256Text (pub String);
crate::simple_type!(Max256Text);
impl Validate for Max256Text {
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() > 256 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 256 \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 Max3NumericText (pub String);
crate::simple_type!(Max3NumericText);
impl Validate for Max3NumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max4AlphaNumericText (pub String);
crate::simple_type!(Max4AlphaNumericText);
impl Validate for Max4AlphaNumericText {
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 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:reda.006.001.01")]
pub struct MessageHeader1 {
#[yaserde(rename = "MsgId")]
#[cfg_attr(feature = "serde", serde(rename = "MsgId"))]
pub msg_id: Max35Text,
#[yaserde(rename = "CreDtTm")]
#[cfg_attr(feature = "serde", serde(rename = "CreDtTm"))]
pub cre_dt_tm: IsodateTime,
}
impl Validate for MessageHeader1 {}
#[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:reda.006.001.01")]
pub struct NameAndAddress4 {
#[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: PostalAddress1,
}
impl Validate for NameAndAddress4 {}
#[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:reda.006.001.01")]
pub struct NameAndAddress5 {
#[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: PostalAddress1,
}
impl Validate for NameAndAddress5 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Number (pub String);
crate::simple_type!(Number);
impl Validate for Number {}
#[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:reda.006.001.01")]
pub enum Operation1Code {
#[yaserde(rename = "TILL")]
#[cfg_attr(feature = "serde", serde(rename = "TILL"))]
Till,
#[yaserde(rename = "ORRR")]
#[cfg_attr(feature = "serde", serde(rename = "ORRR"))]
Orrr,
#[yaserde(rename = "ANDD")]
#[cfg_attr(feature = "serde", serde(rename = "ANDD"))]
Andd,
__Unknown__(String),
}
impl Default for Operation1Code {
fn default() -> Operation1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for Operation1Code {}
#[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:reda.006.001.01")]
pub enum Operator1Code {
#[yaserde(rename = "SMAL")]
#[cfg_attr(feature = "serde", serde(rename = "SMAL"))]
Smal,
#[yaserde(rename = "SMEQ")]
#[cfg_attr(feature = "serde", serde(rename = "SMEQ"))]
Smeq,
#[yaserde(rename = "GREA")]
#[cfg_attr(feature = "serde", serde(rename = "GREA"))]
Grea,
#[yaserde(rename = "GREQ")]
#[cfg_attr(feature = "serde", serde(rename = "GREQ"))]
Greq,
#[yaserde(rename = "EQAL")]
#[cfg_attr(feature = "serde", serde(rename = "EQAL"))]
Eqal,
__Unknown__(String),
}
impl Default for Operator1Code {
fn default() -> Operator1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for Operator1Code {}
#[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:reda.006.001.01")]
pub struct Option15 {
#[yaserde(rename = "OptnSttlmStyle")]
#[cfg_attr(feature = "serde", serde(rename = "OptnSttlmStyle"))]
pub optn_sttlm_style: SettleStyle2Choice,
#[yaserde(rename = "ConvsDt")]
#[cfg_attr(feature = "serde", serde(rename = "ConvsDt"))]
pub convs_dt: IsodateTime,
#[yaserde(rename = "StrkPric")]
#[cfg_attr(feature = "serde", serde(rename = "StrkPric"))]
pub strk_pric: Price8,
#[yaserde(rename = "MinExrcblQty")]
#[cfg_attr(feature = "serde", serde(rename = "MinExrcblQty"))]
pub min_exrcbl_qty: FinancialInstrumentQuantity1Choice,
#[yaserde(rename = "ConvsPrd")]
#[cfg_attr(feature = "serde", serde(rename = "ConvsPrd"))]
pub convs_prd: DateTimePeriod1Choice,
#[yaserde(rename = "OptnStyle")]
#[cfg_attr(feature = "serde", serde(rename = "OptnStyle"))]
pub optn_style: OptionStyle1Choice,
#[yaserde(rename = "OptnTp")]
#[cfg_attr(feature = "serde", serde(rename = "OptnTp"))]
pub optn_tp: OptionType8Choice,
#[yaserde(rename = "StrkVal")]
#[cfg_attr(feature = "serde", serde(rename = "StrkVal"))]
pub strk_val: Number,
#[yaserde(rename = "StrkMltplr")]
#[cfg_attr(feature = "serde", serde(rename = "StrkMltplr"))]
pub strk_mltplr: Number,
#[yaserde(rename = "InstrmAssgnmtMtd")]
#[cfg_attr(feature = "serde", serde(rename = "InstrmAssgnmtMtd"))]
pub instrm_assgnmt_mtd: AssignmentMethod2Choice,
#[yaserde(rename = "VrsnNb")]
#[cfg_attr(feature = "serde", serde(rename = "VrsnNb"))]
pub vrsn_nb: Number,
#[yaserde(rename = "XpryLctn")]
#[cfg_attr(feature = "serde", serde(rename = "XpryLctn"))]
pub xpry_lctn: Max4AlphaNumericText,
#[yaserde(rename = "Stdstn")]
#[cfg_attr(feature = "serde", serde(rename = "Stdstn"))]
pub stdstn: Standardisation3Choice,
#[yaserde(rename = "TradgPtyRole")]
#[cfg_attr(feature = "serde", serde(rename = "TradgPtyRole"))]
pub tradg_pty_role: OptionParty3Choice,
#[yaserde(rename = "CtrctSz")]
#[cfg_attr(feature = "serde", serde(rename = "CtrctSz"))]
pub ctrct_sz: BaseOneRate,
#[yaserde(rename = "AddtlUndrlygAttrbts")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlUndrlygAttrbts"))]
pub addtl_undrlyg_attrbts: Vec<UnderlyingAttributes4>,
}
impl Validate for Option15 {}
#[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:reda.006.001.01")]
pub enum OptionParty1Code {
#[yaserde(rename = "SLLR")]
#[cfg_attr(feature = "serde", serde(rename = "SLLR"))]
Sllr,
#[yaserde(rename = "BYER")]
#[cfg_attr(feature = "serde", serde(rename = "BYER"))]
Byer,
__Unknown__(String),
}
impl Default for OptionParty1Code {
fn default() -> OptionParty1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for OptionParty1Code {}
#[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:reda.006.001.01")]
pub struct OptionParty3Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Vec<OptionParty1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for OptionParty3Choice {}
#[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:reda.006.001.01")]
pub struct OptionStyle1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<OptionStyle1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification13>,
}
impl Validate for OptionStyle1Choice {}
#[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:reda.006.001.01")]
pub enum OptionStyle1Code {
#[yaserde(rename = "AMER")]
#[cfg_attr(feature = "serde", serde(rename = "AMER"))]
Amer,
#[yaserde(rename = "EURO")]
#[cfg_attr(feature = "serde", serde(rename = "EURO"))]
Euro,
#[yaserde(rename = "BERM")]
#[cfg_attr(feature = "serde", serde(rename = "BERM"))]
Berm,
#[yaserde(rename = "ASIA")]
#[cfg_attr(feature = "serde", serde(rename = "ASIA"))]
Asia,
#[yaserde(rename = "CANA")]
#[cfg_attr(feature = "serde", serde(rename = "CANA"))]
Cana,
__Unknown__(String),
}
impl Default for OptionStyle1Code {
fn default() -> OptionStyle1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for OptionStyle1Code {}
#[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:reda.006.001.01")]
pub enum OptionType1Code {
#[yaserde(rename = "CALL")]
#[cfg_attr(feature = "serde", serde(rename = "CALL"))]
Call,
#[yaserde(rename = "PUTO")]
#[cfg_attr(feature = "serde", serde(rename = "PUTO"))]
Puto,
__Unknown__(String),
}
impl Default for OptionType1Code {
fn default() -> OptionType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for OptionType1Code {}
#[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:reda.006.001.01")]
pub struct OptionType8Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Vec<OptionType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for OptionType8Choice {}
#[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:reda.006.001.01")]
pub struct Organisation38 {
#[yaserde(rename = "Nm")]
#[cfg_attr(feature = "serde", serde(rename = "Nm"))]
pub nm: Max140Text,
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: PartyIdentification177Choice,
#[yaserde(rename = "Purp")]
#[cfg_attr(feature = "serde", serde(rename = "Purp"))]
pub purp: Max35Text,
#[yaserde(rename = "TaxtnCtry")]
#[cfg_attr(feature = "serde", serde(rename = "TaxtnCtry"))]
pub taxtn_ctry: CountryCode,
#[yaserde(rename = "RegnCtry")]
#[cfg_attr(feature = "serde", serde(rename = "RegnCtry"))]
pub regn_ctry: CountryCode,
#[yaserde(rename = "RegnDt")]
#[cfg_attr(feature = "serde", serde(rename = "RegnDt"))]
pub regn_dt: Isodate,
#[yaserde(rename = "TaxIdNb")]
#[cfg_attr(feature = "serde", serde(rename = "TaxIdNb"))]
pub tax_id_nb: Max35Text,
#[yaserde(rename = "NtlRegnNb")]
#[cfg_attr(feature = "serde", serde(rename = "NtlRegnNb"))]
pub ntl_regn_nb: Max35Text,
#[yaserde(rename = "PstlAdr")]
#[cfg_attr(feature = "serde", serde(rename = "PstlAdr"))]
pub pstl_adr: Vec<PostalAddress3>,
#[yaserde(rename = "PmryComAdr")]
#[cfg_attr(feature = "serde", serde(rename = "PmryComAdr"))]
pub pmry_com_adr: CommunicationAddress3,
#[yaserde(rename = "ScndryComAdr")]
#[cfg_attr(feature = "serde", serde(rename = "ScndryComAdr"))]
pub scndry_com_adr: CommunicationAddress3,
}
impl Validate for Organisation38 {}
#[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:reda.006.001.01")]
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:reda.006.001.01")]
pub struct PartyIdentification120Choice {
#[yaserde(rename = "AnyBIC")]
#[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
pub any_b_i_c: 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<NameAndAddress5>,
}
impl Validate for PartyIdentification120Choice {}
#[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:reda.006.001.01")]
pub struct PartyIdentification136 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: PartyIdentification120Choice,
#[yaserde(rename = "LEI")]
#[cfg_attr(feature = "serde", serde(rename = "LEI"))]
pub lei: Leiidentifier,
}
impl Validate for PartyIdentification136 {}
#[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:reda.006.001.01")]
pub struct PartyIdentification177Choice {
#[yaserde(rename = "AnyBIC")]
#[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
pub any_b_i_c: Option<AnyBICDec2014Identifier>,
#[yaserde(rename = "PrtryId")]
#[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
pub prtry_id: Option<GenericIdentification1>,
}
impl Validate for PartyIdentification177Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct PaymentDirectionIndicator (pub bool);
crate::simple_type!(PaymentDirectionIndicator);
impl Validate for PaymentDirectionIndicator {}
#[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(Default, Clone, PartialEq, Debug)]
pub struct PhoneNumber (pub String);
crate::simple_type!(PhoneNumber);
impl Validate for PhoneNumber {}
#[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:reda.006.001.01")]
pub struct PostalAddress1 {
#[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 PostalAddress1 {}
#[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:reda.006.001.01")]
pub struct PostalAddress3 {
#[yaserde(rename = "AdrTp")]
#[cfg_attr(feature = "serde", serde(rename = "AdrTp"))]
pub adr_tp: AddressType1Code,
#[yaserde(rename = "MlngInd")]
#[cfg_attr(feature = "serde", serde(rename = "MlngInd"))]
pub mlng_ind: YesNoIndicator,
#[yaserde(rename = "RegnAdrInd")]
#[cfg_attr(feature = "serde", serde(rename = "RegnAdrInd"))]
pub regn_adr_ind: YesNoIndicator,
#[yaserde(rename = "NmAndAdr")]
#[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
pub nm_and_adr: NameAndAddress4,
}
impl Validate for PostalAddress3 {}
#[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:reda.006.001.01")]
pub enum PreferenceToIncome1Code {
#[yaserde(rename = "ORDN")]
#[cfg_attr(feature = "serde", serde(rename = "ORDN"))]
Ordn,
#[yaserde(rename = "PFRD")]
#[cfg_attr(feature = "serde", serde(rename = "PFRD"))]
Pfrd,
__Unknown__(String),
}
impl Default for PreferenceToIncome1Code {
fn default() -> PreferenceToIncome1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for PreferenceToIncome1Code {}
#[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:reda.006.001.01")]
pub struct PreferenceToIncome5Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<PreferenceToIncome1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for PreferenceToIncome5Choice {}
#[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:reda.006.001.01")]
pub struct Price8 {
#[yaserde(rename = "ValTp")]
#[cfg_attr(feature = "serde", serde(rename = "ValTp"))]
pub val_tp: PriceValueType3Code,
#[yaserde(rename = "Val")]
#[cfg_attr(feature = "serde", serde(rename = "Val"))]
pub val: PriceRateOrAmount3Choice,
#[yaserde(rename = "PricTp")]
#[cfg_attr(feature = "serde", serde(rename = "PricTp"))]
pub pric_tp: TypeOfPrice1Code,
}
impl Validate for Price8 {}
#[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:reda.006.001.01")]
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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:reda.006.001.01")]
pub struct PriceValue1 {
#[yaserde(rename = "Amt")]
#[cfg_attr(feature = "serde", serde(rename = "Amt"))]
pub amt: ActiveCurrencyAnd13DecimalAmount,
}
impl Validate for PriceValue1 {}
#[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:reda.006.001.01")]
pub enum PriceValueType3Code {
#[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,
__Unknown__(String),
}
impl Default for PriceValueType3Code {
fn default() -> PriceValueType3Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for PriceValueType3Code {}
#[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:reda.006.001.01")]
pub enum PutType1Code {
#[yaserde(rename = "MAND")]
#[cfg_attr(feature = "serde", serde(rename = "MAND"))]
Mand,
#[yaserde(rename = "OPTI")]
#[cfg_attr(feature = "serde", serde(rename = "OPTI"))]
Opti,
#[yaserde(rename = "TWOS")]
#[cfg_attr(feature = "serde", serde(rename = "TWOS"))]
Twos,
__Unknown__(String),
}
impl Default for PutType1Code {
fn default() -> PutType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for PutType1Code {}
#[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:reda.006.001.01")]
pub struct PutType3Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<PutType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for PutType3Choice {}
#[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:reda.006.001.01")]
pub struct RateAndAmountFormat1Choice {
#[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<ActiveCurrencyAndAmount>,
#[yaserde(rename = "NotSpcfdRate")]
#[cfg_attr(feature = "serde", serde(rename = "NotSpcfdRate"))]
pub not_spcfd_rate: Option<RateType12FormatChoice>,
}
impl Validate for RateAndAmountFormat1Choice {}
#[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:reda.006.001.01")]
pub struct RateOrAbsoluteValue1Choice {
#[yaserde(rename = "RateVal")]
#[cfg_attr(feature = "serde", serde(rename = "RateVal"))]
pub rate_val: Option<PercentageRate>,
#[yaserde(rename = "AbsVal")]
#[cfg_attr(feature = "serde", serde(rename = "AbsVal"))]
pub abs_val: Option<Number>,
}
impl Validate for RateOrAbsoluteValue1Choice {}
#[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:reda.006.001.01")]
pub enum RateType12Code {
#[yaserde(rename = "OPEN")]
#[cfg_attr(feature = "serde", serde(rename = "OPEN"))]
Open,
#[yaserde(rename = "UKWN")]
#[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
Ukwn,
#[yaserde(rename = "NILP")]
#[cfg_attr(feature = "serde", serde(rename = "NILP"))]
Nilp,
__Unknown__(String),
}
impl Default for RateType12Code {
fn default() -> RateType12Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for RateType12Code {}
#[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:reda.006.001.01")]
pub struct RateType12FormatChoice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<RateType12Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification13>,
}
impl Validate for RateType12FormatChoice {}
#[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:reda.006.001.01")]
pub enum RestrictionType1Code {
#[yaserde(rename = "SELR")]
#[cfg_attr(feature = "serde", serde(rename = "SELR"))]
Selr,
#[yaserde(rename = "BUYR")]
#[cfg_attr(feature = "serde", serde(rename = "BUYR"))]
Buyr,
#[yaserde(rename = "PLAR")]
#[cfg_attr(feature = "serde", serde(rename = "PLAR"))]
Plar,
#[yaserde(rename = "HOLR")]
#[cfg_attr(feature = "serde", serde(rename = "HOLR"))]
Holr,
#[yaserde(rename = "VOTR")]
#[cfg_attr(feature = "serde", serde(rename = "VOTR"))]
Votr,
__Unknown__(String),
}
impl Default for RestrictionType1Code {
fn default() -> RestrictionType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for RestrictionType1Code {}
#[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:reda.006.001.01")]
pub enum SecuritiesPaymentStatus1Code {
#[yaserde(rename = "FULL")]
#[cfg_attr(feature = "serde", serde(rename = "FULL"))]
Full,
#[yaserde(rename = "NILL")]
#[cfg_attr(feature = "serde", serde(rename = "NILL"))]
Nill,
#[yaserde(rename = "PART")]
#[cfg_attr(feature = "serde", serde(rename = "PART"))]
Part,
__Unknown__(String),
}
impl Default for SecuritiesPaymentStatus1Code {
fn default() -> SecuritiesPaymentStatus1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for SecuritiesPaymentStatus1Code {}
#[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:reda.006.001.01")]
pub struct SecuritiesPaymentStatus5Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<SecuritiesPaymentStatus1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for SecuritiesPaymentStatus5Choice {}
#[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:reda.006.001.01")]
pub enum SecuritiesTransactionType11Code {
#[yaserde(rename = "NSYN")]
#[cfg_attr(feature = "serde", serde(rename = "NSYN"))]
Nsyn,
#[yaserde(rename = "SYND")]
#[cfg_attr(feature = "serde", serde(rename = "SYND"))]
Synd,
__Unknown__(String),
}
impl Default for SecuritiesTransactionType11Code {
fn default() -> SecuritiesTransactionType11Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for SecuritiesTransactionType11Code {}
#[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:reda.006.001.01")]
pub struct SecuritiesTransactionType31Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<SecuritiesTransactionType11Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for SecuritiesTransactionType31Choice {}
#[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:reda.006.001.01")]
pub struct SecurityAttributes10 {
#[yaserde(rename = "FinInstrmId")]
#[cfg_attr(feature = "serde", serde(rename = "FinInstrmId"))]
pub fin_instrm_id: SecurityIdentification39,
#[yaserde(rename = "FinInstrmTp")]
#[cfg_attr(feature = "serde", serde(rename = "FinInstrmTp"))]
pub fin_instrm_tp: Vec<FinancialInstrument97>,
#[yaserde(rename = "FinInstrmAttrbts")]
#[cfg_attr(feature = "serde", serde(rename = "FinInstrmAttrbts"))]
pub fin_instrm_attrbts: Vec<CommonFinancialInstrumentAttributes10>,
}
impl Validate for SecurityAttributes10 {}
#[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:reda.006.001.01")]
pub struct SecurityCreationRequestV01 {
#[yaserde(rename = "MsgHdr")]
#[cfg_attr(feature = "serde", serde(rename = "MsgHdr"))]
pub msg_hdr: MessageHeader1,
#[yaserde(rename = "Scty")]
#[cfg_attr(feature = "serde", serde(rename = "Scty"))]
pub scty: SecurityAttributes10,
#[yaserde(rename = "SplmtryData")]
#[cfg_attr(feature = "serde", serde(rename = "SplmtryData"))]
pub splmtry_data: Vec<SupplementaryData1>,
}
impl Validate for SecurityCreationRequestV01 {}
#[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:reda.006.001.01")]
pub struct SecurityIdentification39 {
#[yaserde(rename = "ISIN")]
#[cfg_attr(feature = "serde", serde(rename = "ISIN"))]
pub isin: Isin2021Identifier,
#[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 SecurityIdentification39 {}
#[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:reda.006.001.01")]
pub struct SecurityRestriction3 {
#[yaserde(rename = "FctvPrd")]
#[cfg_attr(feature = "serde", serde(rename = "FctvPrd"))]
pub fctv_prd: DateTimePeriod2,
#[yaserde(rename = "RstrctnTp")]
#[cfg_attr(feature = "serde", serde(rename = "RstrctnTp"))]
pub rstrctn_tp: SecurityRestrictionType2Choice,
#[yaserde(rename = "LglRstrctnTp")]
#[cfg_attr(feature = "serde", serde(rename = "LglRstrctnTp"))]
pub lgl_rstrctn_tp: LegalRestrictions5Choice,
#[yaserde(rename = "InvstrRstrctnTp")]
#[cfg_attr(feature = "serde", serde(rename = "InvstrRstrctnTp"))]
pub invstr_rstrctn_tp: Vec<InvestorRestrictionType3Choice>,
#[yaserde(rename = "InvstrTp")]
#[cfg_attr(feature = "serde", serde(rename = "InvstrTp"))]
pub invstr_tp: Vec<InvestorType3Choice>,
}
impl Validate for SecurityRestriction3 {}
#[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:reda.006.001.01")]
pub struct SecurityRestrictionType2Choice {
#[yaserde(rename = "RstrctnTp")]
#[cfg_attr(feature = "serde", serde(rename = "RstrctnTp"))]
pub rstrctn_tp: Option<RestrictionType1Code>,
#[yaserde(rename = "PrtryRstrctn")]
#[cfg_attr(feature = "serde", serde(rename = "PrtryRstrctn"))]
pub prtry_rstrctn: Option<GenericIdentification30>,
}
impl Validate for SecurityRestrictionType2Choice {}
#[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:reda.006.001.01")]
pub enum SecurityStatus2Code {
#[yaserde(rename = "ACTV")]
#[cfg_attr(feature = "serde", serde(rename = "ACTV"))]
Actv,
#[yaserde(rename = "INAC")]
#[cfg_attr(feature = "serde", serde(rename = "INAC"))]
Inac,
#[yaserde(rename = "SUSP")]
#[cfg_attr(feature = "serde", serde(rename = "SUSP"))]
Susp,
__Unknown__(String),
}
impl Default for SecurityStatus2Code {
fn default() -> SecurityStatus2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for SecurityStatus2Code {}
#[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:reda.006.001.01")]
pub struct SecurityStatus3Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<SecurityStatus2Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for SecurityStatus3Choice {}
#[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:reda.006.001.01")]
pub struct SecurityWithHoldingTax1 {
#[yaserde(rename = "WhldgTaxVal")]
#[cfg_attr(feature = "serde", serde(rename = "WhldgTaxVal"))]
pub whldg_tax_val: RateAndAmountFormat1Choice,
#[yaserde(rename = "Ctry")]
#[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
pub ctry: CountryCode,
}
impl Validate for SecurityWithHoldingTax1 {}
#[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:reda.006.001.01")]
pub enum SettleStyle1Code {
#[yaserde(rename = "SETC")]
#[cfg_attr(feature = "serde", serde(rename = "SETC"))]
Setc,
#[yaserde(rename = "SETO")]
#[cfg_attr(feature = "serde", serde(rename = "SETO"))]
Seto,
__Unknown__(String),
}
impl Default for SettleStyle1Code {
fn default() -> SettleStyle1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for SettleStyle1Code {}
#[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:reda.006.001.01")]
pub struct SettleStyle2Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Vec<SettleStyle1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for SettleStyle2Choice {}
#[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:reda.006.001.01")]
pub struct SettlementInformation17 {
#[yaserde(rename = "SctiesQtyTp")]
#[cfg_attr(feature = "serde", serde(rename = "SctiesQtyTp"))]
pub scties_qty_tp: SettlementUnitType3Choice,
#[yaserde(rename = "CtrctSttlmMnth")]
#[cfg_attr(feature = "serde", serde(rename = "CtrctSttlmMnth"))]
pub ctrct_sttlm_mnth: IsoyearMonth,
#[yaserde(rename = "MinDnmtn")]
#[cfg_attr(feature = "serde", serde(rename = "MinDnmtn"))]
pub min_dnmtn: FinancialInstrumentQuantity1Choice,
#[yaserde(rename = "MinMltplQty")]
#[cfg_attr(feature = "serde", serde(rename = "MinMltplQty"))]
pub min_mltpl_qty: FinancialInstrumentQuantity1Choice,
#[yaserde(rename = "DevtgSttlmUnit")]
#[cfg_attr(feature = "serde", serde(rename = "DevtgSttlmUnit"))]
pub devtg_sttlm_unit: Vec<FinancialInstrumentQuantity1Choice>,
}
impl Validate for SettlementInformation17 {}
#[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:reda.006.001.01")]
pub enum SettlementType1Code {
#[yaserde(rename = "PRIN")]
#[cfg_attr(feature = "serde", serde(rename = "PRIN"))]
Prin,
#[yaserde(rename = "NETO")]
#[cfg_attr(feature = "serde", serde(rename = "NETO"))]
Neto,
__Unknown__(String),
}
impl Default for SettlementType1Code {
fn default() -> SettlementType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for SettlementType1Code {}
#[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:reda.006.001.01")]
pub struct SettlementType3Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<SettlementType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for SettlementType3Choice {}
#[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:reda.006.001.01")]
pub enum SettlementUnitType1Code {
#[yaserde(rename = "FAMT")]
#[cfg_attr(feature = "serde", serde(rename = "FAMT"))]
Famt,
#[yaserde(rename = "UNIT")]
#[cfg_attr(feature = "serde", serde(rename = "UNIT"))]
Unit,
__Unknown__(String),
}
impl Default for SettlementUnitType1Code {
fn default() -> SettlementUnitType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for SettlementUnitType1Code {}
#[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:reda.006.001.01")]
pub struct SettlementUnitType3Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<SettlementUnitType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for SettlementUnitType3Choice {}
#[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:reda.006.001.01")]
pub enum Standardisation1Code {
#[yaserde(rename = "FLEX")]
#[cfg_attr(feature = "serde", serde(rename = "FLEX"))]
Flex,
#[yaserde(rename = "NSTA")]
#[cfg_attr(feature = "serde", serde(rename = "NSTA"))]
Nsta,
#[yaserde(rename = "STAN")]
#[cfg_attr(feature = "serde", serde(rename = "STAN"))]
Stan,
__Unknown__(String),
}
impl Default for Standardisation1Code {
fn default() -> Standardisation1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for Standardisation1Code {}
#[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:reda.006.001.01")]
pub struct Standardisation3Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Vec<Standardisation1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for Standardisation3Choice {}
#[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:reda.006.001.01")]
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:reda.006.001.01")]
pub struct SupplementaryDataEnvelope1 {}
impl Validate for SupplementaryDataEnvelope1 {}
#[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:reda.006.001.01")]
pub enum Tefrarules1Code {
#[yaserde(rename = "RULC")]
#[cfg_attr(feature = "serde", serde(rename = "RULC"))]
Rulc,
#[yaserde(rename = "RULD")]
#[cfg_attr(feature = "serde", serde(rename = "RULD"))]
Ruld,
__Unknown__(String),
}
impl Default for Tefrarules1Code {
fn default() -> Tefrarules1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for Tefrarules1Code {}
#[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:reda.006.001.01")]
pub struct Tefrarules3Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<Tefrarules1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for Tefrarules3Choice {}
#[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:reda.006.001.01")]
pub struct Term1 {
#[yaserde(rename = "Oprtr")]
#[cfg_attr(feature = "serde", serde(rename = "Oprtr"))]
pub oprtr: Operator1Code,
#[yaserde(rename = "Val")]
#[cfg_attr(feature = "serde", serde(rename = "Val"))]
pub val: RateOrAbsoluteValue1Choice,
}
impl Validate for Term1 {}
#[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:reda.006.001.01")]
pub enum TimeUnit1Code {
#[yaserde(rename = "DAYC")]
#[cfg_attr(feature = "serde", serde(rename = "DAYC"))]
Dayc,
#[yaserde(rename = "HOUR")]
#[cfg_attr(feature = "serde", serde(rename = "HOUR"))]
Hour,
#[yaserde(rename = "MINU")]
#[cfg_attr(feature = "serde", serde(rename = "MINU"))]
Minu,
#[yaserde(rename = "MNTH")]
#[cfg_attr(feature = "serde", serde(rename = "MNTH"))]
Mnth,
#[yaserde(rename = "SECO")]
#[cfg_attr(feature = "serde", serde(rename = "SECO"))]
Seco,
#[yaserde(rename = "WEEK")]
#[cfg_attr(feature = "serde", serde(rename = "WEEK"))]
Week,
#[yaserde(rename = "YEAR")]
#[cfg_attr(feature = "serde", serde(rename = "YEAR"))]
Year,
__Unknown__(String),
}
impl Default for TimeUnit1Code {
fn default() -> TimeUnit1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for TimeUnit1Code {}
#[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:reda.006.001.01")]
pub struct TimeUnit3Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<TimeUnit1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for TimeUnit3Choice {}
#[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:reda.006.001.01")]
pub enum TradeTransactionCondition2Code {
#[yaserde(rename = "SPCC")]
#[cfg_attr(feature = "serde", serde(rename = "SPCC"))]
Spcc,
#[yaserde(rename = "SECN")]
#[cfg_attr(feature = "serde", serde(rename = "SECN"))]
Secn,
#[yaserde(rename = "SEBN")]
#[cfg_attr(feature = "serde", serde(rename = "SEBN"))]
Sebn,
#[yaserde(rename = "SCBN")]
#[cfg_attr(feature = "serde", serde(rename = "SCBN"))]
Scbn,
#[yaserde(rename = "SCRT")]
#[cfg_attr(feature = "serde", serde(rename = "SCRT"))]
Scrt,
#[yaserde(rename = "SERT")]
#[cfg_attr(feature = "serde", serde(rename = "SERT"))]
Sert,
#[yaserde(rename = "SCCR")]
#[cfg_attr(feature = "serde", serde(rename = "SCCR"))]
Sccr,
#[yaserde(rename = "SECR")]
#[cfg_attr(feature = "serde", serde(rename = "SECR"))]
Secr,
#[yaserde(rename = "CAST")]
#[cfg_attr(feature = "serde", serde(rename = "CAST"))]
Cast,
#[yaserde(rename = "SPPR")]
#[cfg_attr(feature = "serde", serde(rename = "SPPR"))]
Sppr,
#[yaserde(rename = "SPCU")]
#[cfg_attr(feature = "serde", serde(rename = "SPCU"))]
Spcu,
#[yaserde(rename = "SPEX")]
#[cfg_attr(feature = "serde", serde(rename = "SPEX"))]
Spex,
#[yaserde(rename = "GTDL")]
#[cfg_attr(feature = "serde", serde(rename = "GTDL"))]
Gtdl,
__Unknown__(String),
}
impl Default for TradeTransactionCondition2Code {
fn default() -> TradeTransactionCondition2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for TradeTransactionCondition2Code {}
#[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:reda.006.001.01")]
pub struct TradeTransactionCondition7Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<TradeTransactionCondition2Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for TradeTransactionCondition7Choice {}
#[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:reda.006.001.01")]
pub struct TradingParameters2 {
#[yaserde(rename = "MktId")]
#[cfg_attr(feature = "serde", serde(rename = "MktId"))]
pub mkt_id: Micidentifier,
#[yaserde(rename = "RndLot")]
#[cfg_attr(feature = "serde", serde(rename = "RndLot"))]
pub rnd_lot: FinancialInstrumentQuantity1Choice,
#[yaserde(rename = "TradLotSz")]
#[cfg_attr(feature = "serde", serde(rename = "TradLotSz"))]
pub trad_lot_sz: FinancialInstrumentQuantity1Choice,
#[yaserde(rename = "ScndryPlcOfListg")]
#[cfg_attr(feature = "serde", serde(rename = "ScndryPlcOfListg"))]
pub scndry_plc_of_listg: Vec<Micidentifier>,
#[yaserde(rename = "MinTraddNmnlQty")]
#[cfg_attr(feature = "serde", serde(rename = "MinTraddNmnlQty"))]
pub min_tradd_nmnl_qty: UnitOrFaceAmount1Choice,
#[yaserde(rename = "MaxTraddNmnlQty")]
#[cfg_attr(feature = "serde", serde(rename = "MaxTraddNmnlQty"))]
pub max_tradd_nmnl_qty: UnitOrFaceAmount1Choice,
#[yaserde(rename = "MinTradgPricgIncrmt")]
#[cfg_attr(feature = "serde", serde(rename = "MinTradgPricgIncrmt"))]
pub min_tradg_pricg_incrmt: Number,
#[yaserde(rename = "PmryPlcOfListgId")]
#[cfg_attr(feature = "serde", serde(rename = "PmryPlcOfListgId"))]
pub pmry_plc_of_listg_id: Micidentifier,
}
impl Validate for TradingParameters2 {}
#[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:reda.006.001.01")]
pub enum TypeOfPrice1Code {
#[yaserde(rename = "AVER")]
#[cfg_attr(feature = "serde", serde(rename = "AVER"))]
Aver,
#[yaserde(rename = "AVOV")]
#[cfg_attr(feature = "serde", serde(rename = "AVOV"))]
Avov,
#[yaserde(rename = "COMB")]
#[cfg_attr(feature = "serde", serde(rename = "COMB"))]
Comb,
#[yaserde(rename = "GREX")]
#[cfg_attr(feature = "serde", serde(rename = "GREX"))]
Grex,
#[yaserde(rename = "LIMI")]
#[cfg_attr(feature = "serde", serde(rename = "LIMI"))]
Limi,
#[yaserde(rename = "NET2")]
#[cfg_attr(feature = "serde", serde(rename = "NET2"))]
Net2,
#[yaserde(rename = "NDIS")]
#[cfg_attr(feature = "serde", serde(rename = "NDIS"))]
Ndis,
#[yaserde(rename = "NET1")]
#[cfg_attr(feature = "serde", serde(rename = "NET1"))]
Net1,
#[yaserde(rename = "NUND")]
#[cfg_attr(feature = "serde", serde(rename = "NUND"))]
Nund,
#[yaserde(rename = "NOGR")]
#[cfg_attr(feature = "serde", serde(rename = "NOGR"))]
Nogr,
#[yaserde(rename = "PARV")]
#[cfg_attr(feature = "serde", serde(rename = "PARV"))]
Parv,
#[yaserde(rename = "RDAV")]
#[cfg_attr(feature = "serde", serde(rename = "RDAV"))]
Rdav,
#[yaserde(rename = "STOP")]
#[cfg_attr(feature = "serde", serde(rename = "STOP"))]
Stop,
__Unknown__(String),
}
impl Default for TypeOfPrice1Code {
fn default() -> TypeOfPrice1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for TypeOfPrice1Code {}
#[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:reda.006.001.01")]
pub struct UnderlyingAttributes4 {
#[yaserde(rename = "AllcnPctg")]
#[cfg_attr(feature = "serde", serde(rename = "AllcnPctg"))]
pub allcn_pctg: PercentageRate,
#[yaserde(rename = "Qty")]
#[cfg_attr(feature = "serde", serde(rename = "Qty"))]
pub qty: UnitOrFaceAmount1Choice,
#[yaserde(rename = "SttlmTp")]
#[cfg_attr(feature = "serde", serde(rename = "SttlmTp"))]
pub sttlm_tp: SettlementType3Choice,
#[yaserde(rename = "CshAmt")]
#[cfg_attr(feature = "serde", serde(rename = "CshAmt"))]
pub csh_amt: ActiveCurrencyAndAmount,
#[yaserde(rename = "CshTp")]
#[cfg_attr(feature = "serde", serde(rename = "CshTp"))]
pub csh_tp: Max35Text,
#[yaserde(rename = "Pric")]
#[cfg_attr(feature = "serde", serde(rename = "Pric"))]
pub pric: Price8,
#[yaserde(rename = "DrtyPric")]
#[cfg_attr(feature = "serde", serde(rename = "DrtyPric"))]
pub drty_pric: Price8,
#[yaserde(rename = "EndPric")]
#[cfg_attr(feature = "serde", serde(rename = "EndPric"))]
pub end_pric: Price8,
#[yaserde(rename = "StartVal")]
#[cfg_attr(feature = "serde", serde(rename = "StartVal"))]
pub start_val: ActiveCurrencyAndAmount,
#[yaserde(rename = "CurVal")]
#[cfg_attr(feature = "serde", serde(rename = "CurVal"))]
pub cur_val: ActiveCurrencyAndAmount,
#[yaserde(rename = "EndVal")]
#[cfg_attr(feature = "serde", serde(rename = "EndVal"))]
pub end_val: ActiveCurrencyAndAmount,
#[yaserde(rename = "AdjstdQty")]
#[cfg_attr(feature = "serde", serde(rename = "AdjstdQty"))]
pub adjstd_qty: UnitOrFaceAmount1Choice,
#[yaserde(rename = "XchgRate")]
#[cfg_attr(feature = "serde", serde(rename = "XchgRate"))]
pub xchg_rate: PercentageRate,
#[yaserde(rename = "CapVal")]
#[cfg_attr(feature = "serde", serde(rename = "CapVal"))]
pub cap_val: ActiveCurrencyAndAmount,
}
impl Validate for UnderlyingAttributes4 {}
#[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:reda.006.001.01")]
pub struct UnitOfMeasure7Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<UnitOfMeasure9Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for UnitOfMeasure7Choice {}
#[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:reda.006.001.01")]
pub enum UnitOfMeasure9Code {
#[yaserde(rename = "BAGG")]
#[cfg_attr(feature = "serde", serde(rename = "BAGG"))]
Bagg,
#[yaserde(rename = "BALE")]
#[cfg_attr(feature = "serde", serde(rename = "BALE"))]
Bale,
#[yaserde(rename = "BOTL")]
#[cfg_attr(feature = "serde", serde(rename = "BOTL"))]
Botl,
#[yaserde(rename = "BOXX")]
#[cfg_attr(feature = "serde", serde(rename = "BOXX"))]
Boxx,
#[yaserde(rename = "CRTN")]
#[cfg_attr(feature = "serde", serde(rename = "CRTN"))]
Crtn,
#[yaserde(rename = "CELI")]
#[cfg_attr(feature = "serde", serde(rename = "CELI"))]
Celi,
#[yaserde(rename = "CMET")]
#[cfg_attr(feature = "serde", serde(rename = "CMET"))]
Cmet,
#[yaserde(rename = "CNTR")]
#[cfg_attr(feature = "serde", serde(rename = "CNTR"))]
Cntr,
#[yaserde(rename = "CRAT")]
#[cfg_attr(feature = "serde", serde(rename = "CRAT"))]
Crat,
#[yaserde(rename = "CBIN")]
#[cfg_attr(feature = "serde", serde(rename = "CBIN"))]
Cbin,
#[yaserde(rename = "CBME")]
#[cfg_attr(feature = "serde", serde(rename = "CBME"))]
Cbme,
#[yaserde(rename = "CBML")]
#[cfg_attr(feature = "serde", serde(rename = "CBML"))]
Cbml,
#[yaserde(rename = "PIEC")]
#[cfg_attr(feature = "serde", serde(rename = "PIEC"))]
Piec,
#[yaserde(rename = "FOOT")]
#[cfg_attr(feature = "serde", serde(rename = "FOOT"))]
Foot,
#[yaserde(rename = "GBFO")]
#[cfg_attr(feature = "serde", serde(rename = "GBFO"))]
Gbfo,
#[yaserde(rename = "GBGA")]
#[cfg_attr(feature = "serde", serde(rename = "GBGA"))]
Gbga,
#[yaserde(rename = "GBPI")]
#[cfg_attr(feature = "serde", serde(rename = "GBPI"))]
Gbpi,
#[yaserde(rename = "GBQA")]
#[cfg_attr(feature = "serde", serde(rename = "GBQA"))]
Gbqa,
#[yaserde(rename = "GBTN")]
#[cfg_attr(feature = "serde", serde(rename = "GBTN"))]
Gbtn,
#[yaserde(rename = "GRAM")]
#[cfg_attr(feature = "serde", serde(rename = "GRAM"))]
Gram,
#[yaserde(rename = "INCH")]
#[cfg_attr(feature = "serde", serde(rename = "INCH"))]
Inch,
#[yaserde(rename = "KILO")]
#[cfg_attr(feature = "serde", serde(rename = "KILO"))]
Kilo,
#[yaserde(rename = "KMET")]
#[cfg_attr(feature = "serde", serde(rename = "KMET"))]
Kmet,
#[yaserde(rename = "LITR")]
#[cfg_attr(feature = "serde", serde(rename = "LITR"))]
Litr,
#[yaserde(rename = "METR")]
#[cfg_attr(feature = "serde", serde(rename = "METR"))]
Metr,
#[yaserde(rename = "TONE")]
#[cfg_attr(feature = "serde", serde(rename = "TONE"))]
Tone,
#[yaserde(rename = "MILE")]
#[cfg_attr(feature = "serde", serde(rename = "MILE"))]
Mile,
#[yaserde(rename = "MMET")]
#[cfg_attr(feature = "serde", serde(rename = "MMET"))]
Mmet,
#[yaserde(rename = "MILI")]
#[cfg_attr(feature = "serde", serde(rename = "MILI"))]
Mili,
#[yaserde(rename = "PUND")]
#[cfg_attr(feature = "serde", serde(rename = "PUND"))]
Pund,
#[yaserde(rename = "USOU")]
#[cfg_attr(feature = "serde", serde(rename = "USOU"))]
Usou,
#[yaserde(rename = "SCMT")]
#[cfg_attr(feature = "serde", serde(rename = "SCMT"))]
Scmt,
#[yaserde(rename = "SQFO")]
#[cfg_attr(feature = "serde", serde(rename = "SQFO"))]
Sqfo,
#[yaserde(rename = "SQIN")]
#[cfg_attr(feature = "serde", serde(rename = "SQIN"))]
Sqin,
#[yaserde(rename = "SQKI")]
#[cfg_attr(feature = "serde", serde(rename = "SQKI"))]
Sqki,
#[yaserde(rename = "SMET")]
#[cfg_attr(feature = "serde", serde(rename = "SMET"))]
Smet,
#[yaserde(rename = "SQMI")]
#[cfg_attr(feature = "serde", serde(rename = "SQMI"))]
Sqmi,
#[yaserde(rename = "SMIL")]
#[cfg_attr(feature = "serde", serde(rename = "SMIL"))]
Smil,
#[yaserde(rename = "SQYA")]
#[cfg_attr(feature = "serde", serde(rename = "SQYA"))]
Sqya,
#[yaserde(rename = "USBA")]
#[cfg_attr(feature = "serde", serde(rename = "USBA"))]
Usba,
#[yaserde(rename = "USFO")]
#[cfg_attr(feature = "serde", serde(rename = "USFO"))]
Usfo,
#[yaserde(rename = "USGA")]
#[cfg_attr(feature = "serde", serde(rename = "USGA"))]
Usga,
#[yaserde(rename = "USPI")]
#[cfg_attr(feature = "serde", serde(rename = "USPI"))]
Uspi,
#[yaserde(rename = "USQA")]
#[cfg_attr(feature = "serde", serde(rename = "USQA"))]
Usqa,
#[yaserde(rename = "USTN")]
#[cfg_attr(feature = "serde", serde(rename = "USTN"))]
Ustn,
#[yaserde(rename = "YARD")]
#[cfg_attr(feature = "serde", serde(rename = "YARD"))]
Yard,
#[yaserde(rename = "GBOU")]
#[cfg_attr(feature = "serde", serde(rename = "GBOU"))]
Gbou,
#[yaserde(rename = "ACRE")]
#[cfg_attr(feature = "serde", serde(rename = "ACRE"))]
Acre,
#[yaserde(rename = "ARES")]
#[cfg_attr(feature = "serde", serde(rename = "ARES"))]
Ares,
#[yaserde(rename = "HECT")]
#[cfg_attr(feature = "serde", serde(rename = "HECT"))]
Hect,
__Unknown__(String),
}
impl Default for UnitOfMeasure9Code {
fn default() -> UnitOfMeasure9Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for UnitOfMeasure9Code {}
#[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:reda.006.001.01")]
pub struct UnitOrFaceAmount1Choice {
#[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<ActiveCurrencyAndAmount>,
}
impl Validate for UnitOrFaceAmount1Choice {}
#[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:reda.006.001.01")]
pub struct Warrant4 {
#[yaserde(rename = "Mltplr")]
#[cfg_attr(feature = "serde", serde(rename = "Mltplr"))]
pub mltplr: BaseOneRate,
#[yaserde(rename = "SbcptPric")]
#[cfg_attr(feature = "serde", serde(rename = "SbcptPric"))]
pub sbcpt_pric: Price8,
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: WarrantStyle3Choice,
#[yaserde(rename = "WarrtAgt")]
#[cfg_attr(feature = "serde", serde(rename = "WarrtAgt"))]
pub warrt_agt: Vec<Organisation38>,
}
impl Validate for Warrant4 {}
#[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:reda.006.001.01")]
pub enum WarrantStyle1Code {
#[yaserde(rename = "AMER")]
#[cfg_attr(feature = "serde", serde(rename = "AMER"))]
Amer,
#[yaserde(rename = "EURO")]
#[cfg_attr(feature = "serde", serde(rename = "EURO"))]
Euro,
#[yaserde(rename = "BERM")]
#[cfg_attr(feature = "serde", serde(rename = "BERM"))]
Berm,
__Unknown__(String),
}
impl Default for WarrantStyle1Code {
fn default() -> WarrantStyle1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for WarrantStyle1Code {}
#[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:reda.006.001.01")]
pub struct WarrantStyle3Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<WarrantStyle1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for WarrantStyle3Choice {}
#[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:reda.006.001.01")]
pub struct YieldCalculation6 {
#[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: CalculationType3Choice,
#[yaserde(rename = "RedPric")]
#[cfg_attr(feature = "serde", serde(rename = "RedPric"))]
pub red_pric: Price8,
#[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: IsodateTime,
}
impl Validate for YieldCalculation6 {}
impl crate::MxMessage for Document {
const BUSINESS_AREA: crate::BusinessArea = crate::BusinessArea::reda;
const FUNCTIONALITY: &'static str = "006";
const VARIANT: &'static str = "001";
const VERSION: &'static str = "01";
const MESSAGE_NAME: &'static str = "reda.006.001.01";
const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:reda.006.001.01";
}