#![allow(clippy::all)]
#![allow(non_snake_case, non_camel_case_types, dead_code, unused_imports)]
#![allow(non_local_definitions)]
use std::str::FromStr;
use crate::validate::Validate;
use yaserde_derive::{YaDeserialize, YaSerialize};
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.011.001.10")]
pub struct Account34 {
#[yaserde(rename = "AcctId")]
#[cfg_attr(feature = "serde", serde(rename = "AcctId"))]
pub acct_id: Max35Text,
#[yaserde(rename = "AcctDsgnt")]
#[cfg_attr(feature = "serde", serde(rename = "AcctDsgnt"))]
pub acct_dsgnt: Max35Text,
#[yaserde(rename = "AcctNm")]
#[cfg_attr(feature = "serde", serde(rename = "AcctNm"))]
pub acct_nm: Max35Text,
#[yaserde(rename = "AcctSvcr")]
#[cfg_attr(feature = "serde", serde(rename = "AcctSvcr"))]
pub acct_svcr: PartyIdentification132,
#[yaserde(rename = "RegnAdr")]
#[cfg_attr(feature = "serde", serde(rename = "RegnAdr"))]
pub regn_adr: PostalAddress1,
}
impl Validate for Account34 {}
#[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:sese.011.001.10")]
pub struct Account36 {
#[yaserde(rename = "OwnrId")]
#[cfg_attr(feature = "serde", serde(rename = "OwnrId"))]
pub ownr_id: PartyIdentification132,
#[yaserde(rename = "AcctId")]
#[cfg_attr(feature = "serde", serde(rename = "AcctId"))]
pub acct_id: Max35Text,
#[yaserde(rename = "AcctDsgnt")]
#[cfg_attr(feature = "serde", serde(rename = "AcctDsgnt"))]
pub acct_dsgnt: Max35Text,
#[yaserde(rename = "AcctNm")]
#[cfg_attr(feature = "serde", serde(rename = "AcctNm"))]
pub acct_nm: Max35Text,
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: GenericIdentification30,
#[yaserde(rename = "Svcr")]
#[cfg_attr(feature = "serde", serde(rename = "Svcr"))]
pub svcr: PartyIdentification132,
#[yaserde(rename = "SubAcctDtls")]
#[cfg_attr(feature = "serde", serde(rename = "SubAcctDtls"))]
pub sub_acct_dtls: SubAccount5,
#[yaserde(rename = "BlckChainAdrOrWllt")]
#[cfg_attr(feature = "serde", serde(rename = "BlckChainAdrOrWllt"))]
pub blck_chain_adr_or_wllt: BlockChainAddressWallet3,
}
impl Validate for Account36 {}
#[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:sese.011.001.10")]
pub struct AccountIdentificationAndName9 {
#[yaserde(rename = "Nm")]
#[cfg_attr(feature = "serde", serde(rename = "Nm"))]
pub nm: Max35Text,
#[yaserde(rename = "IBAN")]
#[cfg_attr(feature = "serde", serde(rename = "IBAN"))]
pub iban: Iban2007Identifier,
#[yaserde(rename = "BlckChainCshWllt")]
#[cfg_attr(feature = "serde", serde(rename = "BlckChainCshWllt"))]
pub blck_chain_csh_wllt: BlockChainAddressWallet3,
#[yaserde(rename = "Othr")]
#[cfg_attr(feature = "serde", serde(rename = "Othr"))]
pub othr: GenericAccountIdentification1,
}
impl Validate for AccountIdentificationAndName9 {}
#[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:sese.011.001.10")]
pub struct AccountSchemeName1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<ExternalAccountIdentification1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<Max35Text>,
}
impl Validate for AccountSchemeName1Choice {}
#[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:sese.011.001.10")]
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:sese.011.001.10")]
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:sese.011.001.10")]
pub struct ActiveOrHistoricCurrencyAnd13DecimalAmount {
#[yaserde(text)]
pub value: String,
#[yaserde(attribute, rename = "Ccy")]
#[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
pub ccy: ActiveOrHistoricCurrencyCode,
}
impl Validate for ActiveOrHistoricCurrencyAnd13DecimalAmount {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ActiveOrHistoricCurrencyAndAmountSimpleType (pub String);
crate::simple_type!(ActiveOrHistoricCurrencyAndAmountSimpleType);
impl Validate for ActiveOrHistoricCurrencyAndAmountSimpleType {
fn validate(&self) -> Result<(), String> {
if self.0 < "0".parse::<String>().unwrap() {
return Err(format!("MinInclusive validation error: invalid value of 0! \nExpected: 0 >= 0.\nActual: 0 == {}", self.0));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.011.001.10")]
pub struct ActiveOrHistoricCurrencyAndAmount {
#[yaserde(text)]
pub value: String,
#[yaserde(attribute, rename = "Ccy")]
#[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
pub ccy: ActiveOrHistoricCurrencyCode,
}
impl Validate for ActiveOrHistoricCurrencyAndAmount {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ActiveOrHistoricCurrencyCode (pub String);
crate::simple_type!(ActiveOrHistoricCurrencyCode);
impl Validate for ActiveOrHistoricCurrencyCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.011.001.10")]
pub struct AdditionalInformation15 {
#[yaserde(rename = "InfTp")]
#[cfg_attr(feature = "serde", serde(rename = "InfTp"))]
pub inf_tp: GenericIdentification36,
#[yaserde(rename = "InfVal")]
#[cfg_attr(feature = "serde", serde(rename = "InfVal"))]
pub inf_val: Max350Text,
}
impl Validate for AdditionalInformation15 {}
#[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:sese.011.001.10")]
pub struct AdditionalReference10 {
#[yaserde(rename = "Ref")]
#[cfg_attr(feature = "serde", serde(rename = "Ref"))]
pub _ref: Max35Text,
#[yaserde(rename = "RefIssr")]
#[cfg_attr(feature = "serde", serde(rename = "RefIssr"))]
pub ref_issr: PartyIdentification139,
#[yaserde(rename = "MsgNm")]
#[cfg_attr(feature = "serde", serde(rename = "MsgNm"))]
pub msg_nm: Max35Text,
}
impl Validate for AdditionalReference10 {}
#[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:sese.011.001.10")]
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:sese.011.001.10")]
pub struct AlternateSecurityIdentification7 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max35Text,
#[yaserde(rename = "IdSrc")]
#[cfg_attr(feature = "serde", serde(rename = "IdSrc"))]
pub id_src: IdentificationSource1Choice,
}
impl Validate for AlternateSecurityIdentification7 {}
#[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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.011.001.10")]
pub struct ApplicableRules1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<ApplicableRules1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification36>,
}
impl Validate for ApplicableRules1Choice {}
#[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:sese.011.001.10")]
pub enum ApplicableRules1Code {
#[yaserde(rename = "NPRE")]
#[cfg_attr(feature = "serde", serde(rename = "NPRE"))]
Npre,
#[yaserde(rename = "YPRE")]
#[cfg_attr(feature = "serde", serde(rename = "YPRE"))]
Ypre,
__Unknown__(String),
}
impl Default for ApplicableRules1Code {
fn default() -> ApplicableRules1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for ApplicableRules1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct AustrianBankleitzahlIdentifier (pub String);
crate::simple_type!(AustrianBankleitzahlIdentifier);
impl Validate for AustrianBankleitzahlIdentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Bicfidec2014Identifier (pub String);
crate::simple_type!(Bicfidec2014Identifier);
impl Validate for Bicfidec2014Identifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct BelgianIdentifier (pub String);
crate::simple_type!(BelgianIdentifier);
impl Validate for BelgianIdentifier {}
#[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:sese.011.001.10")]
pub struct BeneficiaryDrawdown2 {
#[yaserde(rename = "BnfcryTp")]
#[cfg_attr(feature = "serde", serde(rename = "BnfcryTp"))]
pub bnfcry_tp: BeneficiaryType1Choice,
#[yaserde(rename = "DthUdrLmt")]
#[cfg_attr(feature = "serde", serde(rename = "DthUdrLmt"))]
pub dth_udr_lmt: YesNoIndicator,
#[yaserde(rename = "DtOfDth")]
#[cfg_attr(feature = "serde", serde(rename = "DtOfDth"))]
pub dt_of_dth: Isodate,
#[yaserde(rename = "DtDsgntdToBnfcry")]
#[cfg_attr(feature = "serde", serde(rename = "DtDsgntdToBnfcry"))]
pub dt_dsgntd_to_bnfcry: Isodate,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: Vec<AdditionalInformation15>,
}
impl Validate for BeneficiaryDrawdown2 {}
#[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:sese.011.001.10")]
pub struct BeneficiaryType1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<BeneficiaryType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification36>,
}
impl Validate for BeneficiaryType1Choice {}
#[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:sese.011.001.10")]
pub enum BeneficiaryType1Code {
#[yaserde(rename = "DEPE")]
#[cfg_attr(feature = "serde", serde(rename = "DEPE"))]
Depe,
#[yaserde(rename = "NOMI")]
#[cfg_attr(feature = "serde", serde(rename = "NOMI"))]
Nomi,
#[yaserde(rename = "SUCC")]
#[cfg_attr(feature = "serde", serde(rename = "SUCC"))]
Succ,
__Unknown__(String),
}
impl Default for BeneficiaryType1Code {
fn default() -> BeneficiaryType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for BeneficiaryType1Code {}
#[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:sese.011.001.10")]
pub struct BenefitCrystallisationEvent2 {
#[yaserde(rename = "EvtTpNb")]
#[cfg_attr(feature = "serde", serde(rename = "EvtTpNb"))]
pub evt_tp_nb: Max35Text,
#[yaserde(rename = "EvtTpNm")]
#[cfg_attr(feature = "serde", serde(rename = "EvtTpNm"))]
pub evt_tp_nm: Max35Text,
#[yaserde(rename = "EvtDt")]
#[cfg_attr(feature = "serde", serde(rename = "EvtDt"))]
pub evt_dt: Isodate,
#[yaserde(rename = "CrstllstnAmt")]
#[cfg_attr(feature = "serde", serde(rename = "CrstllstnAmt"))]
pub crstllstn_amt: ActiveCurrencyAnd13DecimalAmount,
#[yaserde(rename = "PctgOfAllwnc")]
#[cfg_attr(feature = "serde", serde(rename = "PctgOfAllwnc"))]
pub pctg_of_allwnc: PercentageRate,
#[yaserde(rename = "LftmAllwncPrtcn")]
#[cfg_attr(feature = "serde", serde(rename = "LftmAllwncPrtcn"))]
pub lftm_allwnc_prtcn: YesNoIndicator,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: Vec<AdditionalInformation15>,
}
impl Validate for BenefitCrystallisationEvent2 {}
#[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:sese.011.001.10")]
pub struct BlockChainAddressWallet3 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max140Text,
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: GenericIdentification30,
#[yaserde(rename = "Nm")]
#[cfg_attr(feature = "serde", serde(rename = "Nm"))]
pub nm: Max70Text,
}
impl Validate for BlockChainAddressWallet3 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Bloomberg2Identifier (pub String);
crate::simple_type!(Bloomberg2Identifier);
impl Validate for Bloomberg2Identifier {}
#[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:sese.011.001.10")]
pub struct BranchData2 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max35Text,
#[yaserde(rename = "Nm")]
#[cfg_attr(feature = "serde", serde(rename = "Nm"))]
pub nm: Max140Text,
#[yaserde(rename = "PstlAdr")]
#[cfg_attr(feature = "serde", serde(rename = "PstlAdr"))]
pub pstl_adr: PostalAddress6,
}
impl Validate for BranchData2 {}
#[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(Default, Clone, PartialEq, Debug)]
pub struct ChipsparticipantIdentifier (pub String);
crate::simple_type!(ChipsparticipantIdentifier);
impl Validate for ChipsparticipantIdentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ChipsuniversalIdentifier (pub String);
crate::simple_type!(ChipsuniversalIdentifier);
impl Validate for ChipsuniversalIdentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Cusipidentifier (pub String);
crate::simple_type!(Cusipidentifier);
impl Validate for Cusipidentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct CanadianPaymentsARNIdentifier (pub String);
crate::simple_type!(CanadianPaymentsARNIdentifier);
impl Validate for CanadianPaymentsARNIdentifier {}
#[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:sese.011.001.10")]
pub struct CancellationPendingStatus7Choice {
#[yaserde(rename = "Rsn")]
#[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
pub rsn: Option<Max350Text>,
#[yaserde(rename = "DataSrcSchme")]
#[cfg_attr(feature = "serde", serde(rename = "DataSrcSchme"))]
pub data_src_schme: Option<GenericIdentification1>,
#[yaserde(rename = "NoSpcfdRsn")]
#[cfg_attr(feature = "serde", serde(rename = "NoSpcfdRsn"))]
pub no_spcfd_rsn: Option<NoReasonCode>,
}
impl Validate for CancellationPendingStatus7Choice {}
#[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:sese.011.001.10")]
pub struct CancelledStatus13Choice {
#[yaserde(rename = "NoSpcfdRsn")]
#[cfg_attr(feature = "serde", serde(rename = "NoSpcfdRsn"))]
pub no_spcfd_rsn: Option<NoReasonCode>,
#[yaserde(rename = "Rsn")]
#[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
pub rsn: Option<CancelledStatusReason3Code>,
#[yaserde(rename = "XtndedRsn")]
#[cfg_attr(feature = "serde", serde(rename = "XtndedRsn"))]
pub xtnded_rsn: Option<Extended350Code>,
#[yaserde(rename = "DataSrcSchme")]
#[cfg_attr(feature = "serde", serde(rename = "DataSrcSchme"))]
pub data_src_schme: Option<GenericIdentification1>,
}
impl Validate for CancelledStatus13Choice {}
#[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:sese.011.001.10")]
pub enum CancelledStatusReason3Code {
#[yaserde(rename = "CNTA")]
#[cfg_attr(feature = "serde", serde(rename = "CNTA"))]
Cnta,
#[yaserde(rename = "CNCL")]
#[cfg_attr(feature = "serde", serde(rename = "CNCL"))]
Cncl,
#[yaserde(rename = "CNIN")]
#[cfg_attr(feature = "serde", serde(rename = "CNIN"))]
Cnin,
__Unknown__(String),
}
impl Default for CancelledStatusReason3Code {
fn default() -> CancelledStatusReason3Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for CancelledStatusReason3Code {}
#[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:sese.011.001.10")]
pub struct Capped1 {
#[yaserde(rename = "StartDt")]
#[cfg_attr(feature = "serde", serde(rename = "StartDt"))]
pub start_dt: Isodate,
#[yaserde(rename = "IncmLmtCurPrd")]
#[cfg_attr(feature = "serde", serde(rename = "IncmLmtCurPrd"))]
pub incm_lmt_cur_prd: ActiveCurrencyAnd13DecimalAmount,
#[yaserde(rename = "IncmCurPrd")]
#[cfg_attr(feature = "serde", serde(rename = "IncmCurPrd"))]
pub incm_cur_prd: ActiveCurrencyAnd13DecimalAmount,
#[yaserde(rename = "IncmLmtNxtPrd")]
#[cfg_attr(feature = "serde", serde(rename = "IncmLmtNxtPrd"))]
pub incm_lmt_nxt_prd: ActiveCurrencyAnd13DecimalAmount,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: Vec<AdditionalInformation15>,
}
impl Validate for Capped1 {}
#[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:sese.011.001.10")]
pub struct CashAsset3 {
#[yaserde(rename = "CshAsstTp")]
#[cfg_attr(feature = "serde", serde(rename = "CshAsstTp"))]
pub csh_asst_tp: CashAssetType1Choice,
#[yaserde(rename = "HldgCcy")]
#[cfg_attr(feature = "serde", serde(rename = "HldgCcy"))]
pub hldg_ccy: ActiveCurrencyCode,
#[yaserde(rename = "TrfCcy")]
#[cfg_attr(feature = "serde", serde(rename = "TrfCcy"))]
pub trf_ccy: ActiveCurrencyCode,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: AdditionalInformation15,
}
impl Validate for CashAsset3 {}
#[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:sese.011.001.10")]
pub struct CashAssetType1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<CashAssetType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification36>,
}
impl Validate for CashAssetType1Choice {}
#[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:sese.011.001.10")]
pub enum CashAssetType1Code {
#[yaserde(rename = "CSH2")]
#[cfg_attr(feature = "serde", serde(rename = "CSH2"))]
Csh2,
#[yaserde(rename = "CSH1")]
#[cfg_attr(feature = "serde", serde(rename = "CSH1"))]
Csh1,
__Unknown__(String),
}
impl Default for CashAssetType1Code {
fn default() -> CashAssetType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for CashAssetType1Code {}
#[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:sese.011.001.10")]
pub struct ChargeBasis2Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<TaxationBasis5Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification47>,
}
impl Validate for ChargeBasis2Choice {}
#[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:sese.011.001.10")]
pub struct ChargeOrCommissionDiscount1 {
#[yaserde(rename = "Amt")]
#[cfg_attr(feature = "serde", serde(rename = "Amt"))]
pub amt: ActiveCurrencyAndAmount,
#[yaserde(rename = "Rate")]
#[cfg_attr(feature = "serde", serde(rename = "Rate"))]
pub rate: PercentageRate,
#[yaserde(rename = "Bsis")]
#[cfg_attr(feature = "serde", serde(rename = "Bsis"))]
pub bsis: WaivingInstruction2Choice,
}
impl Validate for ChargeOrCommissionDiscount1 {}
#[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:sese.011.001.10")]
pub struct ChargeType10Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<InvestmentFundFee3Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification47>,
}
impl Validate for ChargeType10Choice {}
#[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:sese.011.001.10")]
pub struct Cheque12 {
#[yaserde(rename = "Nb")]
#[cfg_attr(feature = "serde", serde(rename = "Nb"))]
pub nb: Max35Text,
#[yaserde(rename = "PyeeId")]
#[cfg_attr(feature = "serde", serde(rename = "PyeeId"))]
pub pyee_id: PartyIdentification139,
#[yaserde(rename = "DrweeId")]
#[cfg_attr(feature = "serde", serde(rename = "DrweeId"))]
pub drwee_id: FinancialInstitutionIdentification17,
#[yaserde(rename = "DrwrId")]
#[cfg_attr(feature = "serde", serde(rename = "DrwrId"))]
pub drwr_id: PartyIdentification139,
}
impl Validate for Cheque12 {}
#[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:sese.011.001.10")]
pub struct ClassificationType32Choice {
#[yaserde(rename = "ClssfctnFinInstrm")]
#[cfg_attr(feature = "serde", serde(rename = "ClssfctnFinInstrm"))]
pub clssfctn_fin_instrm: Option<Cfioct2015Identifier>,
#[yaserde(rename = "AltrnClssfctn")]
#[cfg_attr(feature = "serde", serde(rename = "AltrnClssfctn"))]
pub altrn_clssfctn: Option<GenericIdentification36>,
}
impl Validate for ClassificationType32Choice {}
#[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:sese.011.001.10")]
pub struct ClearingSystemMemberIdentification2Choice {
#[yaserde(rename = "USCHU")]
#[cfg_attr(feature = "serde", serde(rename = "USCHU"))]
pub uschu: Option<ChipsuniversalIdentifier>,
#[yaserde(rename = "NZNCC")]
#[cfg_attr(feature = "serde", serde(rename = "NZNCC"))]
pub nzncc: Option<NewZealandNCCIdentifier>,
#[yaserde(rename = "IENSC")]
#[cfg_attr(feature = "serde", serde(rename = "IENSC"))]
pub iensc: Option<IrishNSCIdentifier>,
#[yaserde(rename = "GBSC")]
#[cfg_attr(feature = "serde", serde(rename = "GBSC"))]
pub gbsc: Option<UkdomesticSortCodeIdentifier>,
#[yaserde(rename = "USCH")]
#[cfg_attr(feature = "serde", serde(rename = "USCH"))]
pub usch: Option<ChipsparticipantIdentifier>,
#[yaserde(rename = "CHBC")]
#[cfg_attr(feature = "serde", serde(rename = "CHBC"))]
pub chbc: Option<SwissBCIdentifier>,
#[yaserde(rename = "USFW")]
#[cfg_attr(feature = "serde", serde(rename = "USFW"))]
pub usfw: Option<FedwireRoutingNumberIdentifier>,
#[yaserde(rename = "PTNCC")]
#[cfg_attr(feature = "serde", serde(rename = "PTNCC"))]
pub ptncc: Option<PortugueseNCCIdentifier>,
#[yaserde(rename = "RUCB")]
#[cfg_attr(feature = "serde", serde(rename = "RUCB"))]
pub rucb: Option<RussianCentralBankIdentificationCodeIdentifier>,
#[yaserde(rename = "ITNCC")]
#[cfg_attr(feature = "serde", serde(rename = "ITNCC"))]
pub itncc: Option<ItalianDomesticIdentifier>,
#[yaserde(rename = "ATBLZ")]
#[cfg_attr(feature = "serde", serde(rename = "ATBLZ"))]
pub atblz: Option<AustrianBankleitzahlIdentifier>,
#[yaserde(rename = "CACPA")]
#[cfg_attr(feature = "serde", serde(rename = "CACPA"))]
pub cacpa: Option<CanadianPaymentsARNIdentifier>,
#[yaserde(rename = "CHSIC")]
#[cfg_attr(feature = "serde", serde(rename = "CHSIC"))]
pub chsic: Option<SwissSICIdentifier>,
#[yaserde(rename = "DEBLZ")]
#[cfg_attr(feature = "serde", serde(rename = "DEBLZ"))]
pub deblz: Option<GermanBankleitzahlIdentifier>,
#[yaserde(rename = "ESNCC")]
#[cfg_attr(feature = "serde", serde(rename = "ESNCC"))]
pub esncc: Option<SpanishDomesticInterbankingIdentifier>,
#[yaserde(rename = "ZANCC")]
#[cfg_attr(feature = "serde", serde(rename = "ZANCC"))]
pub zancc: Option<SouthAfricanNCCIdentifier>,
#[yaserde(rename = "HKNCC")]
#[cfg_attr(feature = "serde", serde(rename = "HKNCC"))]
pub hkncc: Option<HongKongBankIdentifier>,
#[yaserde(rename = "AUBSBx")]
#[cfg_attr(feature = "serde", serde(rename = "AUBSBx"))]
pub aubsbx: Option<ExtensiveBranchNetworkIdentifier>,
#[yaserde(rename = "AUBSBs")]
#[cfg_attr(feature = "serde", serde(rename = "AUBSBs"))]
pub aubsbs: Option<SmallNetworkIdentifier>,
#[yaserde(rename = "INIFSC")]
#[cfg_attr(feature = "serde", serde(rename = "INIFSC"))]
pub inifsc: Option<IndianFinancialSystemCodeIdentifier>,
#[yaserde(rename = "GRHEBIC")]
#[cfg_attr(feature = "serde", serde(rename = "GRHEBIC"))]
pub grhebic: Option<HellenicBankIdentificationCodeIdentifier>,
#[yaserde(rename = "PLKNR")]
#[cfg_attr(feature = "serde", serde(rename = "PLKNR"))]
pub plknr: Option<PolishNationalClearingCodeIdentifier>,
#[yaserde(rename = "OthrClrCdId")]
#[cfg_attr(feature = "serde", serde(rename = "OthrClrCdId"))]
pub othr_clr_cd_id: Option<Max35Text>,
}
impl Validate for ClearingSystemMemberIdentification2Choice {}
#[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:sese.011.001.10")]
pub struct ClearingSystemMemberIdentification4Choice {
#[yaserde(rename = "USCHU")]
#[cfg_attr(feature = "serde", serde(rename = "USCHU"))]
pub uschu: Option<ChipsuniversalIdentifier>,
#[yaserde(rename = "NZNCC")]
#[cfg_attr(feature = "serde", serde(rename = "NZNCC"))]
pub nzncc: Option<NewZealandNCCIdentifier>,
#[yaserde(rename = "IENSC")]
#[cfg_attr(feature = "serde", serde(rename = "IENSC"))]
pub iensc: Option<IrishNSCIdentifier>,
#[yaserde(rename = "GBSC")]
#[cfg_attr(feature = "serde", serde(rename = "GBSC"))]
pub gbsc: Option<UkdomesticSortCodeIdentifier>,
#[yaserde(rename = "USCH")]
#[cfg_attr(feature = "serde", serde(rename = "USCH"))]
pub usch: Option<ChipsparticipantIdentifier>,
#[yaserde(rename = "CHBC")]
#[cfg_attr(feature = "serde", serde(rename = "CHBC"))]
pub chbc: Option<SwissBCIdentifier>,
#[yaserde(rename = "USFW")]
#[cfg_attr(feature = "serde", serde(rename = "USFW"))]
pub usfw: Option<FedwireRoutingNumberIdentifier>,
#[yaserde(rename = "PTNCC")]
#[cfg_attr(feature = "serde", serde(rename = "PTNCC"))]
pub ptncc: Option<PortugueseNCCIdentifier>,
#[yaserde(rename = "RUCB")]
#[cfg_attr(feature = "serde", serde(rename = "RUCB"))]
pub rucb: Option<RussianCentralBankIdentificationCodeIdentifier>,
#[yaserde(rename = "ITNCC")]
#[cfg_attr(feature = "serde", serde(rename = "ITNCC"))]
pub itncc: Option<ItalianDomesticIdentifier>,
#[yaserde(rename = "ATBLZ")]
#[cfg_attr(feature = "serde", serde(rename = "ATBLZ"))]
pub atblz: Option<AustrianBankleitzahlIdentifier>,
#[yaserde(rename = "CACPA")]
#[cfg_attr(feature = "serde", serde(rename = "CACPA"))]
pub cacpa: Option<CanadianPaymentsARNIdentifier>,
#[yaserde(rename = "CHSIC")]
#[cfg_attr(feature = "serde", serde(rename = "CHSIC"))]
pub chsic: Option<SwissSICIdentifier>,
#[yaserde(rename = "DEBLZ")]
#[cfg_attr(feature = "serde", serde(rename = "DEBLZ"))]
pub deblz: Option<GermanBankleitzahlIdentifier>,
#[yaserde(rename = "ESNCC")]
#[cfg_attr(feature = "serde", serde(rename = "ESNCC"))]
pub esncc: Option<SpanishDomesticInterbankingIdentifier>,
#[yaserde(rename = "ZANCC")]
#[cfg_attr(feature = "serde", serde(rename = "ZANCC"))]
pub zancc: Option<SouthAfricanNCCIdentifier>,
#[yaserde(rename = "HKNCC")]
#[cfg_attr(feature = "serde", serde(rename = "HKNCC"))]
pub hkncc: Option<HongKongBankIdentifier>,
#[yaserde(rename = "AUBSBx")]
#[cfg_attr(feature = "serde", serde(rename = "AUBSBx"))]
pub aubsbx: Option<ExtensiveBranchNetworkIdentifier>,
#[yaserde(rename = "AUBSBs")]
#[cfg_attr(feature = "serde", serde(rename = "AUBSBs"))]
pub aubsbs: Option<SmallNetworkIdentifier>,
}
impl Validate for ClearingSystemMemberIdentification4Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ConsolidatedTapeAssociationIdentifier (pub String);
crate::simple_type!(ConsolidatedTapeAssociationIdentifier);
impl Validate for ConsolidatedTapeAssociationIdentifier {
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.011.001.10")]
pub struct ContactIdentification2 {
#[yaserde(rename = "NmPrfx")]
#[cfg_attr(feature = "serde", serde(rename = "NmPrfx"))]
pub nm_prfx: NamePrefix1Code,
#[yaserde(rename = "GvnNm")]
#[cfg_attr(feature = "serde", serde(rename = "GvnNm"))]
pub gvn_nm: Max35Text,
#[yaserde(rename = "Nm")]
#[cfg_attr(feature = "serde", serde(rename = "Nm"))]
pub nm: Max35Text,
#[yaserde(rename = "PhneNb")]
#[cfg_attr(feature = "serde", serde(rename = "PhneNb"))]
pub phne_nb: PhoneNumber,
#[yaserde(rename = "MobNb")]
#[cfg_attr(feature = "serde", serde(rename = "MobNb"))]
pub mob_nb: PhoneNumber,
#[yaserde(rename = "FaxNb")]
#[cfg_attr(feature = "serde", serde(rename = "FaxNb"))]
pub fax_nb: PhoneNumber,
#[yaserde(rename = "EmailAdr")]
#[cfg_attr(feature = "serde", serde(rename = "EmailAdr"))]
pub email_adr: Max256Text,
}
impl Validate for ContactIdentification2 {}
#[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:sese.011.001.10")]
pub struct Conversion4 {
#[yaserde(rename = "SrcScty")]
#[cfg_attr(feature = "serde", serde(rename = "SrcScty"))]
pub src_scty: FinancialInstrumentIdentification7,
#[yaserde(rename = "TtlUnitsNb")]
#[cfg_attr(feature = "serde", serde(rename = "TtlUnitsNb"))]
pub ttl_units_nb: DecimalNumber,
#[yaserde(rename = "UnitsDtls")]
#[cfg_attr(feature = "serde", serde(rename = "UnitsDtls"))]
pub units_dtls: Vec<Unit15>,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: Vec<AdditionalInformation15>,
}
impl Validate for Conversion4 {}
#[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:sese.011.001.10")]
pub struct CreditTransfer13 {
#[yaserde(rename = "Dbtr")]
#[cfg_attr(feature = "serde", serde(rename = "Dbtr"))]
pub dbtr: PartyIdentification132,
#[yaserde(rename = "DbtrAcct")]
#[cfg_attr(feature = "serde", serde(rename = "DbtrAcct"))]
pub dbtr_acct: AccountIdentificationAndName9,
#[yaserde(rename = "DbtrAgt")]
#[cfg_attr(feature = "serde", serde(rename = "DbtrAgt"))]
pub dbtr_agt: FinancialInstitutionIdentification16,
#[yaserde(rename = "DbtrAgtAcct")]
#[cfg_attr(feature = "serde", serde(rename = "DbtrAgtAcct"))]
pub dbtr_agt_acct: AccountIdentificationAndName9,
#[yaserde(rename = "IntrmyAgt1")]
#[cfg_attr(feature = "serde", serde(rename = "IntrmyAgt1"))]
pub intrmy_agt_1: FinancialInstitutionIdentification16,
#[yaserde(rename = "IntrmyAgt1Acct")]
#[cfg_attr(feature = "serde", serde(rename = "IntrmyAgt1Acct"))]
pub intrmy_agt_1_acct: AccountIdentificationAndName9,
#[yaserde(rename = "IntrmyAgt2")]
#[cfg_attr(feature = "serde", serde(rename = "IntrmyAgt2"))]
pub intrmy_agt_2: FinancialInstitutionIdentification16,
#[yaserde(rename = "IntrmyAgt2Acct")]
#[cfg_attr(feature = "serde", serde(rename = "IntrmyAgt2Acct"))]
pub intrmy_agt_2_acct: AccountIdentificationAndName9,
#[yaserde(rename = "CdtrAgt")]
#[cfg_attr(feature = "serde", serde(rename = "CdtrAgt"))]
pub cdtr_agt: FinancialInstitutionIdentification16,
#[yaserde(rename = "CdtrAgtAcct")]
#[cfg_attr(feature = "serde", serde(rename = "CdtrAgtAcct"))]
pub cdtr_agt_acct: AccountIdentificationAndName9,
#[yaserde(rename = "Cdtr")]
#[cfg_attr(feature = "serde", serde(rename = "Cdtr"))]
pub cdtr: PartyIdentification132,
#[yaserde(rename = "CdtrAcct")]
#[cfg_attr(feature = "serde", serde(rename = "CdtrAcct"))]
pub cdtr_acct: AccountIdentificationAndName9,
}
impl Validate for CreditTransfer13 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Dti2024Identifier (pub String);
crate::simple_type!(Dti2024Identifier);
impl Validate for Dti2024Identifier {}
#[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:sese.011.001.10")]
pub struct DateFormat42Choice {
#[yaserde(rename = "YrMnth")]
#[cfg_attr(feature = "serde", serde(rename = "YrMnth"))]
pub yr_mnth: Option<IsoyearMonth>,
#[yaserde(rename = "YrMnthDay")]
#[cfg_attr(feature = "serde", serde(rename = "YrMnthDay"))]
pub yr_mnth_day: Option<Isodate>,
}
impl Validate for DateFormat42Choice {}
#[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:sese.011.001.10")]
pub struct DigitalPaymentSettlement3 {
#[yaserde(rename = "FinInstrmId")]
#[cfg_attr(feature = "serde", serde(rename = "FinInstrmId"))]
pub fin_instrm_id: SecurityIdentification50,
#[yaserde(rename = "Qty")]
#[cfg_attr(feature = "serde", serde(rename = "Qty"))]
pub qty: Quantity48Choice,
#[yaserde(rename = "DgtlLdgrId")]
#[cfg_attr(feature = "serde", serde(rename = "DgtlLdgrId"))]
pub dgtl_ldgr_id: Dti2024Identifier,
}
impl Validate for DigitalPaymentSettlement3 {}
#[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:sese.011.001.10")]
pub struct Document {
#[yaserde(rename = "TrfInstrStsRpt")]
#[cfg_attr(feature = "serde", serde(rename = "TrfInstrStsRpt"))]
pub trf_instr_sts_rpt: TransferInstructionStatusReportV10,
}
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:sese.011.001.10")]
pub struct Drawdown04 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max140Text,
#[yaserde(rename = "TrchTp")]
#[cfg_attr(feature = "serde", serde(rename = "TrchTp"))]
pub trch_tp: DrawdownType2Choice,
#[yaserde(rename = "AplblRules")]
#[cfg_attr(feature = "serde", serde(rename = "AplblRules"))]
pub aplbl_rules: ApplicableRules1Choice,
#[yaserde(rename = "InvstrTaxRef")]
#[cfg_attr(feature = "serde", serde(rename = "InvstrTaxRef"))]
pub invstr_tax_ref: TaxReference2,
#[yaserde(rename = "PctgOfTtlTrfVal")]
#[cfg_attr(feature = "serde", serde(rename = "PctgOfTtlTrfVal"))]
pub pctg_of_ttl_trf_val: PercentageRate,
#[yaserde(rename = "TtlAmtNetDrwdwn")]
#[cfg_attr(feature = "serde", serde(rename = "TtlAmtNetDrwdwn"))]
pub ttl_amt_net_drwdwn: ActiveCurrencyAnd13DecimalAmount,
#[yaserde(rename = "AddtlFndsDsgntd")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlFndsDsgntd"))]
pub addtl_fnds_dsgntd: YesNoIndicator,
#[yaserde(rename = "PnsnCmcmntLumpSumRmng")]
#[cfg_attr(feature = "serde", serde(rename = "PnsnCmcmntLumpSumRmng"))]
pub pnsn_cmcmnt_lump_sum_rmng: ActiveCurrencyAnd13DecimalAmount,
#[yaserde(rename = "PnsnCmcmntLumpSumDt")]
#[cfg_attr(feature = "serde", serde(rename = "PnsnCmcmntLumpSumDt"))]
pub pnsn_cmcmnt_lump_sum_dt: Isodate,
#[yaserde(rename = "MltplPnsnCmcmntLumpSums")]
#[cfg_attr(feature = "serde", serde(rename = "MltplPnsnCmcmntLumpSums"))]
pub mltpl_pnsn_cmcmnt_lump_sums: YesNoIndicator,
#[yaserde(rename = "LftmAllwnc")]
#[cfg_attr(feature = "serde", serde(rename = "LftmAllwnc"))]
pub lftm_allwnc: PercentageRate,
#[yaserde(rename = "RcptOfDrwdwnInd")]
#[cfg_attr(feature = "serde", serde(rename = "RcptOfDrwdwnInd"))]
pub rcpt_of_drwdwn_ind: YesNoIndicator,
#[yaserde(rename = "BnfcryDtls")]
#[cfg_attr(feature = "serde", serde(rename = "BnfcryDtls"))]
pub bnfcry_dtls: BeneficiaryDrawdown2,
#[yaserde(rename = "CapdLmts")]
#[cfg_attr(feature = "serde", serde(rename = "CapdLmts"))]
pub capd_lmts: Capped1,
#[yaserde(rename = "FlxblDrwdwnTrggrdDt")]
#[cfg_attr(feature = "serde", serde(rename = "FlxblDrwdwnTrggrdDt"))]
pub flxbl_drwdwn_trggrd_dt: Isodate,
#[yaserde(rename = "TrchDt")]
#[cfg_attr(feature = "serde", serde(rename = "TrchDt"))]
pub trch_dt: Isodate,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: Vec<AdditionalInformation15>,
}
impl Validate for Drawdown04 {}
#[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:sese.011.001.10")]
pub struct Drawdown3 {
#[yaserde(rename = "MplymntDtls")]
#[cfg_attr(feature = "serde", serde(rename = "MplymntDtls"))]
pub mplymnt_dtls: EmploymentDetails1,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: Vec<AdditionalInformation15>,
}
impl Validate for Drawdown3 {}
#[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:sese.011.001.10")]
pub struct DrawdownType2Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<DrawdownType2Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification36>,
}
impl Validate for DrawdownType2Choice {}
#[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:sese.011.001.10")]
pub enum DrawdownType2Code {
#[yaserde(rename = "BOTH")]
#[cfg_attr(feature = "serde", serde(rename = "BOTH"))]
Both,
#[yaserde(rename = "CAPP")]
#[cfg_attr(feature = "serde", serde(rename = "CAPP"))]
Capp,
#[yaserde(rename = "FLEX")]
#[cfg_attr(feature = "serde", serde(rename = "FLEX"))]
Flex,
__Unknown__(String),
}
impl Default for DrawdownType2Code {
fn default() -> DrawdownType2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for DrawdownType2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct DutchIdentifier (pub String);
crate::simple_type!(DutchIdentifier);
impl Validate for DutchIdentifier {}
#[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:sese.011.001.10")]
pub struct EmploymentDetails1 {
#[yaserde(rename = "TaxCd")]
#[cfg_attr(feature = "serde", serde(rename = "TaxCd"))]
pub tax_cd: GenericIdentification36,
#[yaserde(rename = "OthrTaxCdInd")]
#[cfg_attr(feature = "serde", serde(rename = "OthrTaxCdInd"))]
pub othr_tax_cd_ind: YesNoIndicator,
#[yaserde(rename = "CmltvTaxInd")]
#[cfg_attr(feature = "serde", serde(rename = "CmltvTaxInd"))]
pub cmltv_tax_ind: YesNoIndicator,
#[yaserde(rename = "PrvsPay")]
#[cfg_attr(feature = "serde", serde(rename = "PrvsPay"))]
pub prvs_pay: ActiveCurrencyAndAmount,
#[yaserde(rename = "PrvsTax")]
#[cfg_attr(feature = "serde", serde(rename = "PrvsTax"))]
pub prvs_tax: ActiveCurrencyAndAmount,
#[yaserde(rename = "StartDt")]
#[cfg_attr(feature = "serde", serde(rename = "StartDt"))]
pub start_dt: DateFormat42Choice,
#[yaserde(rename = "EndDt")]
#[cfg_attr(feature = "serde", serde(rename = "EndDt"))]
pub end_dt: DateFormat42Choice,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: Vec<AdditionalInformation15>,
}
impl Validate for EmploymentDetails1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct EuroclearClearstreamIdentifier (pub String);
crate::simple_type!(EuroclearClearstreamIdentifier);
impl Validate for EuroclearClearstreamIdentifier {
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() > 12 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 12 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[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 Extended350Code (pub String);
crate::simple_type!(Extended350Code);
impl Validate for Extended350Code {
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.011.001.10")]
pub struct Extension1 {
#[yaserde(rename = "PlcAndNm")]
#[cfg_attr(feature = "serde", serde(rename = "PlcAndNm"))]
pub plc_and_nm: Max350Text,
#[yaserde(rename = "Txt")]
#[cfg_attr(feature = "serde", serde(rename = "Txt"))]
pub txt: Max350Text,
}
impl Validate for Extension1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ExtensiveBranchNetworkIdentifier (pub String);
crate::simple_type!(ExtensiveBranchNetworkIdentifier);
impl Validate for ExtensiveBranchNetworkIdentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ExternalAccountIdentification1Code (pub String);
crate::simple_type!(ExternalAccountIdentification1Code);
impl Validate for ExternalAccountIdentification1Code {
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:sese.011.001.10")]
pub struct FailedSettlementStatus2Choice {
#[yaserde(rename = "Rsn")]
#[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
pub rsn: Option<Max350Text>,
#[yaserde(rename = "DataSrcSchme")]
#[cfg_attr(feature = "serde", serde(rename = "DataSrcSchme"))]
pub data_src_schme: Option<GenericIdentification1>,
#[yaserde(rename = "NoSpcfdRsn")]
#[cfg_attr(feature = "serde", serde(rename = "NoSpcfdRsn"))]
pub no_spcfd_rsn: Option<NoReasonCode>,
}
impl Validate for FailedSettlementStatus2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct FedwireRoutingNumberIdentifier (pub String);
crate::simple_type!(FedwireRoutingNumberIdentifier);
impl Validate for FedwireRoutingNumberIdentifier {}
#[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:sese.011.001.10")]
pub struct Fee11 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: ChargeType10Choice,
#[yaserde(rename = "Bsis")]
#[cfg_attr(feature = "serde", serde(rename = "Bsis"))]
pub bsis: ChargeBasis2Choice,
#[yaserde(rename = "StdAmt")]
#[cfg_attr(feature = "serde", serde(rename = "StdAmt"))]
pub std_amt: ActiveCurrencyAndAmount,
#[yaserde(rename = "StdRate")]
#[cfg_attr(feature = "serde", serde(rename = "StdRate"))]
pub std_rate: PercentageRate,
#[yaserde(rename = "DscntDtls")]
#[cfg_attr(feature = "serde", serde(rename = "DscntDtls"))]
pub dscnt_dtls: ChargeOrCommissionDiscount1,
#[yaserde(rename = "ApldAmt")]
#[cfg_attr(feature = "serde", serde(rename = "ApldAmt"))]
pub apld_amt: ActiveCurrencyAndAmount,
#[yaserde(rename = "ApldRate")]
#[cfg_attr(feature = "serde", serde(rename = "ApldRate"))]
pub apld_rate: PercentageRate,
#[yaserde(rename = "NonStdSLARef")]
#[cfg_attr(feature = "serde", serde(rename = "NonStdSLARef"))]
pub non_std_sla_ref: Max35Text,
#[yaserde(rename = "RcptId")]
#[cfg_attr(feature = "serde", serde(rename = "RcptId"))]
pub rcpt_id: PartyIdentification139,
#[yaserde(rename = "InftvInd")]
#[cfg_attr(feature = "serde", serde(rename = "InftvInd"))]
pub inftv_ind: YesNoIndicator,
}
impl Validate for Fee11 {}
#[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:sese.011.001.10")]
pub struct FinancialInstitutionIdentification10Choice {
#[yaserde(rename = "NmAndAdr")]
#[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
pub nm_and_adr: Option<NameAndAddress5>,
#[yaserde(rename = "BICFI")]
#[cfg_attr(feature = "serde", serde(rename = "BICFI"))]
pub bicfi: Option<Bicfidec2014Identifier>,
#[yaserde(rename = "ClrSysMmbId")]
#[cfg_attr(feature = "serde", serde(rename = "ClrSysMmbId"))]
pub clr_sys_mmb_id: Option<ClearingSystemMemberIdentification2Choice>,
#[yaserde(rename = "PrtryId")]
#[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
pub prtry_id: Option<Max35Text>,
}
impl Validate for FinancialInstitutionIdentification10Choice {}
#[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:sese.011.001.10")]
pub struct FinancialInstitutionIdentification16 {
#[yaserde(rename = "BICFI")]
#[cfg_attr(feature = "serde", serde(rename = "BICFI"))]
pub bicfi: Bicfidec2014Identifier,
#[yaserde(rename = "ClrSysMmbId")]
#[cfg_attr(feature = "serde", serde(rename = "ClrSysMmbId"))]
pub clr_sys_mmb_id: ClearingSystemMemberIdentification4Choice,
#[yaserde(rename = "NmAndAdr")]
#[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
pub nm_and_adr: NameAndAddress5,
#[yaserde(rename = "LEI")]
#[cfg_attr(feature = "serde", serde(rename = "LEI"))]
pub lei: Leiidentifier,
#[yaserde(rename = "PrtryId")]
#[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
pub prtry_id: Max35Text,
#[yaserde(rename = "BrnchId")]
#[cfg_attr(feature = "serde", serde(rename = "BrnchId"))]
pub brnch_id: BranchData2,
}
impl Validate for FinancialInstitutionIdentification16 {}
#[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:sese.011.001.10")]
pub struct FinancialInstitutionIdentification17 {
#[yaserde(rename = "Pty")]
#[cfg_attr(feature = "serde", serde(rename = "Pty"))]
pub pty: FinancialInstitutionIdentification10Choice,
#[yaserde(rename = "LEI")]
#[cfg_attr(feature = "serde", serde(rename = "LEI"))]
pub lei: Leiidentifier,
}
impl Validate for FinancialInstitutionIdentification17 {}
#[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:sese.011.001.10")]
pub struct FinancialInstrument101Choice {
#[yaserde(rename = "Scty")]
#[cfg_attr(feature = "serde", serde(rename = "Scty"))]
pub scty: Option<FinancialInstrumentIdentification6>,
#[yaserde(rename = "CshAsst")]
#[cfg_attr(feature = "serde", serde(rename = "CshAsst"))]
pub csh_asst: Option<CashAsset3>,
#[yaserde(rename = "OthrAsst")]
#[cfg_attr(feature = "serde", serde(rename = "OthrAsst"))]
pub othr_asst: Option<OtherAsset2>,
}
impl Validate for FinancialInstrument101Choice {}
#[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:sese.011.001.10")]
pub struct FinancialInstrumentIdentification6 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: SecurityIdentification46Choice,
#[yaserde(rename = "Nm")]
#[cfg_attr(feature = "serde", serde(rename = "Nm"))]
pub nm: Max350Text,
#[yaserde(rename = "ShrtNm")]
#[cfg_attr(feature = "serde", serde(rename = "ShrtNm"))]
pub shrt_nm: Max35Text,
#[yaserde(rename = "ClssfctnTp")]
#[cfg_attr(feature = "serde", serde(rename = "ClssfctnTp"))]
pub clssfctn_tp: ClassificationType32Choice,
}
impl Validate for FinancialInstrumentIdentification6 {}
#[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:sese.011.001.10")]
pub struct FinancialInstrumentIdentification7 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: SecurityIdentification46Choice,
#[yaserde(rename = "Nm")]
#[cfg_attr(feature = "serde", serde(rename = "Nm"))]
pub nm: Max350Text,
#[yaserde(rename = "ShrtNm")]
#[cfg_attr(feature = "serde", serde(rename = "ShrtNm"))]
pub shrt_nm: Max35Text,
}
impl Validate for FinancialInstrumentIdentification7 {}
#[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:sese.011.001.10")]
pub enum FinancialInstrumentIdentificationType1Code {
#[yaserde(rename = "BELC")]
#[cfg_attr(feature = "serde", serde(rename = "BELC"))]
Belc,
#[yaserde(rename = "BLOM")]
#[cfg_attr(feature = "serde", serde(rename = "BLOM"))]
Blom,
#[yaserde(rename = "CCCD")]
#[cfg_attr(feature = "serde", serde(rename = "CCCD"))]
Cccd,
#[yaserde(rename = "CMED")]
#[cfg_attr(feature = "serde", serde(rename = "CMED"))]
Cmed,
#[yaserde(rename = "COMM")]
#[cfg_attr(feature = "serde", serde(rename = "COMM"))]
Comm,
#[yaserde(rename = "CTAC")]
#[cfg_attr(feature = "serde", serde(rename = "CTAC"))]
Ctac,
#[yaserde(rename = "CUSP")]
#[cfg_attr(feature = "serde", serde(rename = "CUSP"))]
Cusp,
#[yaserde(rename = "FIGC")]
#[cfg_attr(feature = "serde", serde(rename = "FIGC"))]
Figc,
#[yaserde(rename = "FIGG")]
#[cfg_attr(feature = "serde", serde(rename = "FIGG"))]
Figg,
#[yaserde(rename = "FIGI")]
#[cfg_attr(feature = "serde", serde(rename = "FIGI"))]
Figi,
#[yaserde(rename = "ISDU")]
#[cfg_attr(feature = "serde", serde(rename = "ISDU"))]
Isdu,
#[yaserde(rename = "ISDX")]
#[cfg_attr(feature = "serde", serde(rename = "ISDX"))]
Isdx,
#[yaserde(rename = "LCHD")]
#[cfg_attr(feature = "serde", serde(rename = "LCHD"))]
Lchd,
#[yaserde(rename = "OCCS")]
#[cfg_attr(feature = "serde", serde(rename = "OCCS"))]
Occs,
#[yaserde(rename = "OPRA")]
#[cfg_attr(feature = "serde", serde(rename = "OPRA"))]
Opra,
#[yaserde(rename = "RCMD")]
#[cfg_attr(feature = "serde", serde(rename = "RCMD"))]
Rcmd,
#[yaserde(rename = "RICC")]
#[cfg_attr(feature = "serde", serde(rename = "RICC"))]
Ricc,
#[yaserde(rename = "SEDL")]
#[cfg_attr(feature = "serde", serde(rename = "SEDL"))]
Sedl,
#[yaserde(rename = "SICC")]
#[cfg_attr(feature = "serde", serde(rename = "SICC"))]
Sicc,
#[yaserde(rename = "TIKR")]
#[cfg_attr(feature = "serde", serde(rename = "TIKR"))]
Tikr,
#[yaserde(rename = "VALO")]
#[cfg_attr(feature = "serde", serde(rename = "VALO"))]
Valo,
#[yaserde(rename = "WKNR")]
#[cfg_attr(feature = "serde", serde(rename = "WKNR"))]
Wknr,
#[yaserde(rename = "CCDC")]
#[cfg_attr(feature = "serde", serde(rename = "CCDC"))]
Ccdc,
#[yaserde(rename = "DTID")]
#[cfg_attr(feature = "serde", serde(rename = "DTID"))]
Dtid,
__Unknown__(String),
}
impl Default for FinancialInstrumentIdentificationType1Code {
fn default() -> FinancialInstrumentIdentificationType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for FinancialInstrumentIdentificationType1Code {}
#[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:sese.011.001.10")]
pub struct FinancialInstrumentQuantity33Choice {
#[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>,
#[yaserde(rename = "DgtlTknUnit")]
#[cfg_attr(feature = "serde", serde(rename = "DgtlTknUnit"))]
pub dgtl_tkn_unit: Option<Max30DecimalNumber>,
}
impl Validate for FinancialInstrumentQuantity33Choice {}
#[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:sese.011.001.10")]
pub struct GenericAccountIdentification1 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max34Text,
#[yaserde(rename = "SchmeNm")]
#[cfg_attr(feature = "serde", serde(rename = "SchmeNm"))]
pub schme_nm: AccountSchemeName1Choice,
#[yaserde(rename = "Issr")]
#[cfg_attr(feature = "serde", serde(rename = "Issr"))]
pub issr: Max35Text,
}
impl Validate for GenericAccountIdentification1 {}
#[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:sese.011.001.10")]
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:sese.011.001.10")]
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:sese.011.001.10")]
pub struct GenericIdentification36 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max35Text,
#[yaserde(rename = "Issr")]
#[cfg_attr(feature = "serde", serde(rename = "Issr"))]
pub issr: Max35Text,
#[yaserde(rename = "SchmeNm")]
#[cfg_attr(feature = "serde", serde(rename = "SchmeNm"))]
pub schme_nm: Max35Text,
}
impl Validate for GenericIdentification36 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.011.001.10")]
pub struct GenericIdentification47 {
#[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: Max4AlphaNumericText,
#[yaserde(rename = "SchmeNm")]
#[cfg_attr(feature = "serde", serde(rename = "SchmeNm"))]
pub schme_nm: Max4AlphaNumericText,
}
impl Validate for GenericIdentification47 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct GermanBankleitzahlIdentifier (pub String);
crate::simple_type!(GermanBankleitzahlIdentifier);
impl Validate for GermanBankleitzahlIdentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct HellenicBankIdentificationCodeIdentifier (pub String);
crate::simple_type!(HellenicBankIdentificationCodeIdentifier);
impl Validate for HellenicBankIdentificationCodeIdentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct HongKongBankIdentifier (pub String);
crate::simple_type!(HongKongBankIdentifier);
impl Validate for HongKongBankIdentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Iban2007Identifier (pub String);
crate::simple_type!(Iban2007Identifier);
impl Validate for Iban2007Identifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Isinoct2015Identifier (pub String);
crate::simple_type!(Isinoct2015Identifier);
impl Validate for Isinoct2015Identifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct 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:sese.011.001.10")]
pub struct IdentificationSource1Choice {
#[yaserde(rename = "Dmst")]
#[cfg_attr(feature = "serde", serde(rename = "Dmst"))]
pub dmst: Option<CountryCode>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<Max35Text>,
}
impl Validate for IdentificationSource1Choice {}
#[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:sese.011.001.10")]
pub struct IdentificationSource6Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<FinancialInstrumentIdentificationType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<Max35Text>,
}
impl Validate for IdentificationSource6Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ImpliedCurrencyAndAmount (pub String);
crate::simple_type!(ImpliedCurrencyAndAmount);
impl Validate for ImpliedCurrencyAndAmount {
fn validate(&self) -> Result<(), String> {
if self.0 < "0".parse::<String>().unwrap() {
return Err(format!("MinInclusive validation error: invalid value of 0! \nExpected: 0 >= 0.\nActual: 0 == {}", self.0));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.011.001.10")]
pub struct InRepairStatus4Choice {
#[yaserde(rename = "Rsn")]
#[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
pub rsn: Option<Max350Text>,
#[yaserde(rename = "DataSrcSchme")]
#[cfg_attr(feature = "serde", serde(rename = "DataSrcSchme"))]
pub data_src_schme: Option<GenericIdentification1>,
#[yaserde(rename = "NoSpcfdRsn")]
#[cfg_attr(feature = "serde", serde(rename = "NoSpcfdRsn"))]
pub no_spcfd_rsn: Option<NoReasonCode>,
}
impl Validate for InRepairStatus4Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct IndianFinancialSystemCodeIdentifier (pub String);
crate::simple_type!(IndianFinancialSystemCodeIdentifier);
impl Validate for IndianFinancialSystemCodeIdentifier {}
#[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:sese.011.001.10")]
pub struct Intermediary48 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: PartyIdentification132,
#[yaserde(rename = "Acct")]
#[cfg_attr(feature = "serde", serde(rename = "Acct"))]
pub acct: Account34,
#[yaserde(rename = "Role")]
#[cfg_attr(feature = "serde", serde(rename = "Role"))]
pub role: Role8Choice,
#[yaserde(rename = "CtctPrsn")]
#[cfg_attr(feature = "serde", serde(rename = "CtctPrsn"))]
pub ctct_prsn: ContactIdentification2,
}
impl Validate for Intermediary48 {}
#[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:sese.011.001.10")]
pub enum InvestmentFundFee3Code {
#[yaserde(rename = "BEND")]
#[cfg_attr(feature = "serde", serde(rename = "BEND"))]
Bend,
#[yaserde(rename = "BRKF")]
#[cfg_attr(feature = "serde", serde(rename = "BRKF"))]
Brkf,
#[yaserde(rename = "CDSC")]
#[cfg_attr(feature = "serde", serde(rename = "CDSC"))]
Cdsc,
#[yaserde(rename = "CBCH")]
#[cfg_attr(feature = "serde", serde(rename = "CBCH"))]
Cbch,
#[yaserde(rename = "DLEV")]
#[cfg_attr(feature = "serde", serde(rename = "DLEV"))]
Dlev,
#[yaserde(rename = "FEND")]
#[cfg_attr(feature = "serde", serde(rename = "FEND"))]
Fend,
#[yaserde(rename = "INIT")]
#[cfg_attr(feature = "serde", serde(rename = "INIT"))]
Init,
#[yaserde(rename = "PREM")]
#[cfg_attr(feature = "serde", serde(rename = "PREM"))]
Prem,
#[yaserde(rename = "CHAR")]
#[cfg_attr(feature = "serde", serde(rename = "CHAR"))]
Char,
#[yaserde(rename = "SWIT")]
#[cfg_attr(feature = "serde", serde(rename = "SWIT"))]
Swit,
#[yaserde(rename = "UCIC")]
#[cfg_attr(feature = "serde", serde(rename = "UCIC"))]
Ucic,
#[yaserde(rename = "COMM")]
#[cfg_attr(feature = "serde", serde(rename = "COMM"))]
Comm,
#[yaserde(rename = "SHIP")]
#[cfg_attr(feature = "serde", serde(rename = "SHIP"))]
Ship,
#[yaserde(rename = "POST")]
#[cfg_attr(feature = "serde", serde(rename = "POST"))]
Post,
#[yaserde(rename = "CDPL")]
#[cfg_attr(feature = "serde", serde(rename = "CDPL"))]
Cdpl,
#[yaserde(rename = "ADDF")]
#[cfg_attr(feature = "serde", serde(rename = "ADDF"))]
Addf,
#[yaserde(rename = "REGF")]
#[cfg_attr(feature = "serde", serde(rename = "REGF"))]
Regf,
#[yaserde(rename = "PENA")]
#[cfg_attr(feature = "serde", serde(rename = "PENA"))]
Pena,
#[yaserde(rename = "NTWK")]
#[cfg_attr(feature = "serde", serde(rename = "NTWK"))]
Ntwk,
__Unknown__(String),
}
impl Default for InvestmentFundFee3Code {
fn default() -> InvestmentFundFee3Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for InvestmentFundFee3Code {}
#[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:sese.011.001.10")]
pub enum InvestmentFundRole8Code {
#[yaserde(rename = "CUST")]
#[cfg_attr(feature = "serde", serde(rename = "CUST"))]
Cust,
#[yaserde(rename = "DIST")]
#[cfg_attr(feature = "serde", serde(rename = "DIST"))]
Dist,
#[yaserde(rename = "FMCO")]
#[cfg_attr(feature = "serde", serde(rename = "FMCO"))]
Fmco,
#[yaserde(rename = "INTR")]
#[cfg_attr(feature = "serde", serde(rename = "INTR"))]
Intr,
#[yaserde(rename = "INVE")]
#[cfg_attr(feature = "serde", serde(rename = "INVE"))]
Inve,
#[yaserde(rename = "INVS")]
#[cfg_attr(feature = "serde", serde(rename = "INVS"))]
Invs,
#[yaserde(rename = "TRAG")]
#[cfg_attr(feature = "serde", serde(rename = "TRAG"))]
Trag,
#[yaserde(rename = "TRAN")]
#[cfg_attr(feature = "serde", serde(rename = "TRAN"))]
Tran,
#[yaserde(rename = "UCL1")]
#[cfg_attr(feature = "serde", serde(rename = "UCL1"))]
Ucl1,
#[yaserde(rename = "UCL2")]
#[cfg_attr(feature = "serde", serde(rename = "UCL2"))]
Ucl2,
#[yaserde(rename = "REGI")]
#[cfg_attr(feature = "serde", serde(rename = "REGI"))]
Regi,
#[yaserde(rename = "CACO")]
#[cfg_attr(feature = "serde", serde(rename = "CACO"))]
Caco,
#[yaserde(rename = "CONC")]
#[cfg_attr(feature = "serde", serde(rename = "CONC"))]
Conc,
#[yaserde(rename = "DATP")]
#[cfg_attr(feature = "serde", serde(rename = "DATP"))]
Datp,
__Unknown__(String),
}
impl Default for InvestmentFundRole8Code {
fn default() -> InvestmentFundRole8Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for InvestmentFundRole8Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct IrishNSCIdentifier (pub String);
crate::simple_type!(IrishNSCIdentifier);
impl Validate for IrishNSCIdentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ItalianDomesticIdentifier (pub String);
crate::simple_type!(ItalianDomesticIdentifier);
impl Validate for ItalianDomesticIdentifier {}
#[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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.011.001.10")]
pub struct MarketPracticeVersion1 {
#[yaserde(rename = "Nm")]
#[cfg_attr(feature = "serde", serde(rename = "Nm"))]
pub nm: Max35Text,
#[yaserde(rename = "Dt")]
#[cfg_attr(feature = "serde", serde(rename = "Dt"))]
pub dt: IsoyearMonth,
#[yaserde(rename = "Nb")]
#[cfg_attr(feature = "serde", serde(rename = "Nb"))]
pub nb: Max35Text,
}
impl Validate for MarketPracticeVersion1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max140Text (pub String);
crate::simple_type!(Max140Text);
impl Validate for Max140Text {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 140 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 140 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max16Text (pub String);
crate::simple_type!(Max16Text);
impl Validate for Max16Text {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 16 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 16 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct 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 Max30DecimalNumber (pub String);
crate::simple_type!(Max30DecimalNumber);
impl Validate for Max30DecimalNumber {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max34Text (pub String);
crate::simple_type!(Max34Text);
impl Validate for Max34Text {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 34 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 34 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max350Text (pub String);
crate::simple_type!(Max350Text);
impl Validate for Max350Text {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 350 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 350 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max35Text (pub String);
crate::simple_type!(Max35Text);
impl Validate for Max35Text {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 35 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 35 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct 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:sese.011.001.10")]
pub struct MessageIdentification1 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max35Text,
#[yaserde(rename = "CreDtTm")]
#[cfg_attr(feature = "serde", serde(rename = "CreDtTm"))]
pub cre_dt_tm: IsodateTime,
}
impl Validate for MessageIdentification1 {}
#[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:sese.011.001.10")]
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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.011.001.10")]
pub enum NamePrefix1Code {
#[yaserde(rename = "DOCT")]
#[cfg_attr(feature = "serde", serde(rename = "DOCT"))]
Doct,
#[yaserde(rename = "MIST")]
#[cfg_attr(feature = "serde", serde(rename = "MIST"))]
Mist,
#[yaserde(rename = "MISS")]
#[cfg_attr(feature = "serde", serde(rename = "MISS"))]
Miss,
#[yaserde(rename = "MADM")]
#[cfg_attr(feature = "serde", serde(rename = "MADM"))]
Madm,
__Unknown__(String),
}
impl Default for NamePrefix1Code {
fn default() -> NamePrefix1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for NamePrefix1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct NewZealandNCCIdentifier (pub String);
crate::simple_type!(NewZealandNCCIdentifier);
impl Validate for NewZealandNCCIdentifier {}
#[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:sese.011.001.10")]
pub enum NoReasonCode {
#[yaserde(rename = "NORE")]
#[cfg_attr(feature = "serde", serde(rename = "NORE"))]
Nore,
__Unknown__(String),
}
impl Default for NoReasonCode {
fn default() -> NoReasonCode {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for NoReasonCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Number (pub String);
crate::simple_type!(Number);
impl Validate for Number {}
#[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:sese.011.001.10")]
pub struct OtherAmount1 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: OtherAmountType1Choice,
#[yaserde(rename = "Amt")]
#[cfg_attr(feature = "serde", serde(rename = "Amt"))]
pub amt: ActiveCurrencyAndAmount,
}
impl Validate for OtherAmount1 {}
#[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:sese.011.001.10")]
pub struct OtherAmountType1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<OtherAmountType1Code>,
#[yaserde(rename = "PrtryCd")]
#[cfg_attr(feature = "serde", serde(rename = "PrtryCd"))]
pub prtry_cd: Option<GenericIdentification1>,
}
impl Validate for OtherAmountType1Choice {}
#[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:sese.011.001.10")]
pub enum OtherAmountType1Code {
#[yaserde(rename = "PINT")]
#[cfg_attr(feature = "serde", serde(rename = "PINT"))]
Pint,
#[yaserde(rename = "SINT")]
#[cfg_attr(feature = "serde", serde(rename = "SINT"))]
Sint,
__Unknown__(String),
}
impl Default for OtherAmountType1Code {
fn default() -> OtherAmountType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for OtherAmountType1Code {}
#[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:sese.011.001.10")]
pub struct OtherAsset2 {
#[yaserde(rename = "OthrAsstTp")]
#[cfg_attr(feature = "serde", serde(rename = "OthrAsstTp"))]
pub othr_asst_tp: OtherAsset2Choice,
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max35Text,
#[yaserde(rename = "Nm")]
#[cfg_attr(feature = "serde", serde(rename = "Nm"))]
pub nm: Max35Text,
#[yaserde(rename = "Desc")]
#[cfg_attr(feature = "serde", serde(rename = "Desc"))]
pub desc: Max35Text,
#[yaserde(rename = "OthrId")]
#[cfg_attr(feature = "serde", serde(rename = "OthrId"))]
pub othr_id: Vec<Max35Text>,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: Vec<AdditionalInformation15>,
}
impl Validate for OtherAsset2 {}
#[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:sese.011.001.10")]
pub struct OtherAsset2Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<OtherAsset2Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification36>,
}
impl Validate for OtherAsset2Choice {}
#[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:sese.011.001.10")]
pub enum OtherAsset2Code {
#[yaserde(rename = "DIMA")]
#[cfg_attr(feature = "serde", serde(rename = "DIMA"))]
Dima,
#[yaserde(rename = "EXIA")]
#[cfg_attr(feature = "serde", serde(rename = "EXIA"))]
Exia,
#[yaserde(rename = "MOVE")]
#[cfg_attr(feature = "serde", serde(rename = "MOVE"))]
Move,
#[yaserde(rename = "PROP")]
#[cfg_attr(feature = "serde", serde(rename = "PROP"))]
Prop,
#[yaserde(rename = "TIPP")]
#[cfg_attr(feature = "serde", serde(rename = "TIPP"))]
Tipp,
__Unknown__(String),
}
impl Default for OtherAsset2Code {
fn default() -> OtherAsset2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for OtherAsset2Code {}
#[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:sese.011.001.10")]
pub struct OtherIdentification8 {
#[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: IdentificationSource6Choice,
}
impl Validate for OtherIdentification8 {}
#[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:sese.011.001.10")]
pub struct PartyIdentification125Choice {
#[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>,
#[yaserde(rename = "NmAndAdr")]
#[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
pub nm_and_adr: Option<NameAndAddress5>,
}
impl Validate for PartyIdentification125Choice {}
#[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:sese.011.001.10")]
pub struct PartyIdentification132 {
#[yaserde(rename = "AnyBIC")]
#[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
pub any_bic: AnyBICDec2014Identifier,
#[yaserde(rename = "ClrSysMmbId")]
#[cfg_attr(feature = "serde", serde(rename = "ClrSysMmbId"))]
pub clr_sys_mmb_id: ClearingSystemMemberIdentification2Choice,
#[yaserde(rename = "NmAndAdr")]
#[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
pub nm_and_adr: NameAndAddress5,
#[yaserde(rename = "PrtryId")]
#[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
pub prtry_id: GenericIdentification1,
#[yaserde(rename = "LEI")]
#[cfg_attr(feature = "serde", serde(rename = "LEI"))]
pub lei: Leiidentifier,
}
impl Validate for PartyIdentification132 {}
#[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:sese.011.001.10")]
pub struct PartyIdentification139 {
#[yaserde(rename = "Pty")]
#[cfg_attr(feature = "serde", serde(rename = "Pty"))]
pub pty: PartyIdentification125Choice,
#[yaserde(rename = "LEI")]
#[cfg_attr(feature = "serde", serde(rename = "LEI"))]
pub lei: Leiidentifier,
}
impl Validate for PartyIdentification139 {}
#[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:sese.011.001.10")]
pub struct PaymentInstrument23 {
#[yaserde(rename = "Ref")]
#[cfg_attr(feature = "serde", serde(rename = "Ref"))]
pub _ref: Max35Text,
#[yaserde(rename = "Amt")]
#[cfg_attr(feature = "serde", serde(rename = "Amt"))]
pub amt: ActiveCurrencyAnd13DecimalAmount,
#[yaserde(rename = "PmtDt")]
#[cfg_attr(feature = "serde", serde(rename = "PmtDt"))]
pub pmt_dt: Isodate,
#[yaserde(rename = "CshSttlmDtls")]
#[cfg_attr(feature = "serde", serde(rename = "CshSttlmDtls"))]
pub csh_sttlm_dtls: PaymentInstrument31Choice,
}
impl Validate for PaymentInstrument23 {}
#[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:sese.011.001.10")]
pub struct PaymentInstrument31Choice {
#[yaserde(rename = "CdtTrfDtls")]
#[cfg_attr(feature = "serde", serde(rename = "CdtTrfDtls"))]
pub cdt_trf_dtls: Option<CreditTransfer13>,
#[yaserde(rename = "ChqDtls")]
#[cfg_attr(feature = "serde", serde(rename = "ChqDtls"))]
pub chq_dtls: Option<Cheque12>,
}
impl Validate for PaymentInstrument31Choice {}
#[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:sese.011.001.10")]
pub struct PendingSettlementStatus3Choice {
#[yaserde(rename = "Rsn")]
#[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
pub rsn: Option<PendingSettlementStatusReason2Code>,
#[yaserde(rename = "XtndedRsn")]
#[cfg_attr(feature = "serde", serde(rename = "XtndedRsn"))]
pub xtnded_rsn: Option<Extended350Code>,
#[yaserde(rename = "DataSrcSchme")]
#[cfg_attr(feature = "serde", serde(rename = "DataSrcSchme"))]
pub data_src_schme: Option<GenericIdentification1>,
#[yaserde(rename = "NoSpcfdRsn")]
#[cfg_attr(feature = "serde", serde(rename = "NoSpcfdRsn"))]
pub no_spcfd_rsn: Option<NoReasonCode>,
}
impl Validate for PendingSettlementStatus3Choice {}
#[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:sese.011.001.10")]
pub enum PendingSettlementStatusReason2Code {
#[yaserde(rename = "AWSH")]
#[cfg_attr(feature = "serde", serde(rename = "AWSH"))]
Awsh,
#[yaserde(rename = "BLOC")]
#[cfg_attr(feature = "serde", serde(rename = "BLOC"))]
Bloc,
#[yaserde(rename = "CAIS")]
#[cfg_attr(feature = "serde", serde(rename = "CAIS"))]
Cais,
#[yaserde(rename = "CLAC")]
#[cfg_attr(feature = "serde", serde(rename = "CLAC"))]
Clac,
#[yaserde(rename = "DOCC")]
#[cfg_attr(feature = "serde", serde(rename = "DOCC"))]
Docc,
#[yaserde(rename = "DOCY")]
#[cfg_attr(feature = "serde", serde(rename = "DOCY"))]
Docy,
#[yaserde(rename = "IAAD")]
#[cfg_attr(feature = "serde", serde(rename = "IAAD"))]
Iaad,
#[yaserde(rename = "LACK")]
#[cfg_attr(feature = "serde", serde(rename = "LACK"))]
Lack,
#[yaserde(rename = "LINK")]
#[cfg_attr(feature = "serde", serde(rename = "LINK"))]
Link,
#[yaserde(rename = "PHCK")]
#[cfg_attr(feature = "serde", serde(rename = "PHCK"))]
Phck,
#[yaserde(rename = "PHSE")]
#[cfg_attr(feature = "serde", serde(rename = "PHSE"))]
Phse,
#[yaserde(rename = "SBLO")]
#[cfg_attr(feature = "serde", serde(rename = "SBLO"))]
Sblo,
#[yaserde(rename = "MINF")]
#[cfg_attr(feature = "serde", serde(rename = "MINF"))]
Minf,
#[yaserde(rename = "ACOP")]
#[cfg_attr(feature = "serde", serde(rename = "ACOP"))]
Acop,
#[yaserde(rename = "IINV")]
#[cfg_attr(feature = "serde", serde(rename = "IINV"))]
Iinv,
#[yaserde(rename = "CINV")]
#[cfg_attr(feature = "serde", serde(rename = "CINV"))]
Cinv,
#[yaserde(rename = "AINV")]
#[cfg_attr(feature = "serde", serde(rename = "AINV"))]
Ainv,
#[yaserde(rename = "WTRF")]
#[cfg_attr(feature = "serde", serde(rename = "WTRF"))]
Wtrf,
#[yaserde(rename = "USUA")]
#[cfg_attr(feature = "serde", serde(rename = "USUA"))]
Usua,
#[yaserde(rename = "ASTA")]
#[cfg_attr(feature = "serde", serde(rename = "ASTA"))]
Asta,
#[yaserde(rename = "AFST")]
#[cfg_attr(feature = "serde", serde(rename = "AFST"))]
Afst,
#[yaserde(rename = "STST")]
#[cfg_attr(feature = "serde", serde(rename = "STST"))]
Stst,
#[yaserde(rename = "LPRO")]
#[cfg_attr(feature = "serde", serde(rename = "LPRO"))]
Lpro,
#[yaserde(rename = "ADRQ")]
#[cfg_attr(feature = "serde", serde(rename = "ADRQ"))]
Adrq,
#[yaserde(rename = "ADS1")]
#[cfg_attr(feature = "serde", serde(rename = "ADS1"))]
Ads1,
#[yaserde(rename = "ADS2")]
#[cfg_attr(feature = "serde", serde(rename = "ADS2"))]
Ads2,
#[yaserde(rename = "DRJC")]
#[cfg_attr(feature = "serde", serde(rename = "DRJC"))]
Drjc,
#[yaserde(rename = "CYIN")]
#[cfg_attr(feature = "serde", serde(rename = "CYIN"))]
Cyin,
#[yaserde(rename = "CYDV")]
#[cfg_attr(feature = "serde", serde(rename = "CYDV"))]
Cydv,
#[yaserde(rename = "OVER")]
#[cfg_attr(feature = "serde", serde(rename = "OVER"))]
Over,
#[yaserde(rename = "WCPA")]
#[cfg_attr(feature = "serde", serde(rename = "WCPA"))]
Wcpa,
#[yaserde(rename = "SDUT")]
#[cfg_attr(feature = "serde", serde(rename = "SDUT"))]
Sdut,
#[yaserde(rename = "TAPR")]
#[cfg_attr(feature = "serde", serde(rename = "TAPR"))]
Tapr,
#[yaserde(rename = "XCNF")]
#[cfg_attr(feature = "serde", serde(rename = "XCNF"))]
Xcnf,
#[yaserde(rename = "ESCA")]
#[cfg_attr(feature = "serde", serde(rename = "ESCA"))]
Esca,
#[yaserde(rename = "NRCP")]
#[cfg_attr(feature = "serde", serde(rename = "NRCP"))]
Nrcp,
#[yaserde(rename = "FVER")]
#[cfg_attr(feature = "serde", serde(rename = "FVER"))]
Fver,
__Unknown__(String),
}
impl Default for PendingSettlementStatusReason2Code {
fn default() -> PendingSettlementStatusReason2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for PendingSettlementStatusReason2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct PercentageRate (pub String);
crate::simple_type!(PercentageRate);
impl Validate for PercentageRate {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.011.001.10")]
pub enum PersonIdentificationType7Code {
#[yaserde(rename = "ATIN")]
#[cfg_attr(feature = "serde", serde(rename = "ATIN"))]
Atin,
#[yaserde(rename = "GTIN")]
#[cfg_attr(feature = "serde", serde(rename = "GTIN"))]
Gtin,
#[yaserde(rename = "ITIN")]
#[cfg_attr(feature = "serde", serde(rename = "ITIN"))]
Itin,
__Unknown__(String),
}
impl Default for PersonIdentificationType7Code {
fn default() -> PersonIdentificationType7Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for PersonIdentificationType7Code {}
#[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)]
pub struct PolishNationalClearingCodeIdentifier (pub String);
crate::simple_type!(PolishNationalClearingCodeIdentifier);
impl Validate for PolishNationalClearingCodeIdentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct PortugueseNCCIdentifier (pub String);
crate::simple_type!(PortugueseNCCIdentifier);
impl Validate for PortugueseNCCIdentifier {}
#[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:sese.011.001.10")]
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:sese.011.001.10")]
pub struct PostalAddress6 {
#[yaserde(rename = "AdrTp")]
#[cfg_attr(feature = "serde", serde(rename = "AdrTp"))]
pub adr_tp: AddressType2Code,
#[yaserde(rename = "Dept")]
#[cfg_attr(feature = "serde", serde(rename = "Dept"))]
pub dept: Max70Text,
#[yaserde(rename = "SubDept")]
#[cfg_attr(feature = "serde", serde(rename = "SubDept"))]
pub sub_dept: 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,
#[yaserde(rename = "AdrLine")]
#[cfg_attr(feature = "serde", serde(rename = "AdrLine"))]
pub adr_line: Vec<Max70Text>,
}
impl Validate for PostalAddress6 {}
#[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:sese.011.001.10")]
pub enum PriceMethod1Code {
#[yaserde(rename = "FORW")]
#[cfg_attr(feature = "serde", serde(rename = "FORW"))]
Forw,
#[yaserde(rename = "HIST")]
#[cfg_attr(feature = "serde", serde(rename = "HIST"))]
Hist,
__Unknown__(String),
}
impl Default for PriceMethod1Code {
fn default() -> PriceMethod1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for PriceMethod1Code {}
#[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:sese.011.001.10")]
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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.011.001.10")]
pub struct ProprietaryQuantity8 {
#[yaserde(rename = "Qty")]
#[cfg_attr(feature = "serde", serde(rename = "Qty"))]
pub qty: DecimalNumber,
#[yaserde(rename = "QtyTp")]
#[cfg_attr(feature = "serde", serde(rename = "QtyTp"))]
pub qty_tp: 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 ProprietaryQuantity8 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Quickidentifier (pub String);
crate::simple_type!(Quickidentifier);
impl Validate for Quickidentifier {}
#[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:sese.011.001.10")]
pub struct Quantity48Choice {
#[yaserde(rename = "Qty")]
#[cfg_attr(feature = "serde", serde(rename = "Qty"))]
pub qty: Option<FinancialInstrumentQuantity33Choice>,
#[yaserde(rename = "PrtryQty")]
#[cfg_attr(feature = "serde", serde(rename = "PrtryQty"))]
pub prtry_qty: Option<ProprietaryQuantity8>,
}
impl Validate for Quantity48Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Ricidentifier (pub String);
crate::simple_type!(Ricidentifier);
impl Validate for Ricidentifier {
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.011.001.10")]
pub struct References64Choice {
#[yaserde(rename = "RltdRef")]
#[cfg_attr(feature = "serde", serde(rename = "RltdRef"))]
pub rltd_ref: Vec<AdditionalReference10>,
#[yaserde(rename = "OthrRef")]
#[cfg_attr(feature = "serde", serde(rename = "OthrRef"))]
pub othr_ref: Vec<AdditionalReference10>,
}
impl Validate for References64Choice {}
#[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:sese.011.001.10")]
pub struct RejectedReason45Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<RejectedStatusReason13Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification36>,
}
impl Validate for RejectedReason45Choice {}
#[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:sese.011.001.10")]
pub enum RejectedStatusReason13Code {
#[yaserde(rename = "BLCA")]
#[cfg_attr(feature = "serde", serde(rename = "BLCA"))]
Blca,
#[yaserde(rename = "DOCC")]
#[cfg_attr(feature = "serde", serde(rename = "DOCC"))]
Docc,
#[yaserde(rename = "IAQD")]
#[cfg_attr(feature = "serde", serde(rename = "IAQD"))]
Iaqd,
#[yaserde(rename = "ICTN")]
#[cfg_attr(feature = "serde", serde(rename = "ICTN"))]
Ictn,
#[yaserde(rename = "CYPA")]
#[cfg_attr(feature = "serde", serde(rename = "CYPA"))]
Cypa,
#[yaserde(rename = "TREF")]
#[cfg_attr(feature = "serde", serde(rename = "TREF"))]
Tref,
#[yaserde(rename = "DSEC")]
#[cfg_attr(feature = "serde", serde(rename = "DSEC"))]
Dsec,
#[yaserde(rename = "IDNA")]
#[cfg_attr(feature = "serde", serde(rename = "IDNA"))]
Idna,
#[yaserde(rename = "DQUA")]
#[cfg_attr(feature = "serde", serde(rename = "DQUA"))]
Dqua,
#[yaserde(rename = "FTAX")]
#[cfg_attr(feature = "serde", serde(rename = "FTAX"))]
Ftax,
#[yaserde(rename = "INID")]
#[cfg_attr(feature = "serde", serde(rename = "INID"))]
Inid,
#[yaserde(rename = "INAC")]
#[cfg_attr(feature = "serde", serde(rename = "INAC"))]
Inac,
#[yaserde(rename = "CASH")]
#[cfg_attr(feature = "serde", serde(rename = "CASH"))]
Cash,
#[yaserde(rename = "INPM")]
#[cfg_attr(feature = "serde", serde(rename = "INPM"))]
Inpm,
#[yaserde(rename = "INNA")]
#[cfg_attr(feature = "serde", serde(rename = "INNA"))]
Inna,
#[yaserde(rename = "SAFE")]
#[cfg_attr(feature = "serde", serde(rename = "SAFE"))]
Safe,
#[yaserde(rename = "INUK")]
#[cfg_attr(feature = "serde", serde(rename = "INUK"))]
Inuk,
#[yaserde(rename = "LEGL")]
#[cfg_attr(feature = "serde", serde(rename = "LEGL"))]
Legl,
#[yaserde(rename = "NSLA")]
#[cfg_attr(feature = "serde", serde(rename = "NSLA"))]
Nsla,
#[yaserde(rename = "SECU")]
#[cfg_attr(feature = "serde", serde(rename = "SECU"))]
Secu,
#[yaserde(rename = "PTNS")]
#[cfg_attr(feature = "serde", serde(rename = "PTNS"))]
Ptns,
#[yaserde(rename = "DLVY")]
#[cfg_attr(feature = "serde", serde(rename = "DLVY"))]
Dlvy,
#[yaserde(rename = "DDAT")]
#[cfg_attr(feature = "serde", serde(rename = "DDAT"))]
Ddat,
#[yaserde(rename = "ISTP")]
#[cfg_attr(feature = "serde", serde(rename = "ISTP"))]
Istp,
#[yaserde(rename = "DEPT")]
#[cfg_attr(feature = "serde", serde(rename = "DEPT"))]
Dept,
#[yaserde(rename = "ISAT")]
#[cfg_attr(feature = "serde", serde(rename = "ISAT"))]
Isat,
#[yaserde(rename = "OTHR")]
#[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
Othr,
#[yaserde(rename = "NCON")]
#[cfg_attr(feature = "serde", serde(rename = "NCON"))]
Ncon,
#[yaserde(rename = "ACLO")]
#[cfg_attr(feature = "serde", serde(rename = "ACLO"))]
Aclo,
#[yaserde(rename = "NASS")]
#[cfg_attr(feature = "serde", serde(rename = "NASS"))]
Nass,
#[yaserde(rename = "NQTY")]
#[cfg_attr(feature = "serde", serde(rename = "NQTY"))]
Nqty,
#[yaserde(rename = "BLTR")]
#[cfg_attr(feature = "serde", serde(rename = "BLTR"))]
Bltr,
#[yaserde(rename = "COSE")]
#[cfg_attr(feature = "serde", serde(rename = "COSE"))]
Cose,
#[yaserde(rename = "ILLI")]
#[cfg_attr(feature = "serde", serde(rename = "ILLI"))]
Illi,
#[yaserde(rename = "BMRV")]
#[cfg_attr(feature = "serde", serde(rename = "BMRV"))]
Bmrv,
#[yaserde(rename = "DINV")]
#[cfg_attr(feature = "serde", serde(rename = "DINV"))]
Dinv,
#[yaserde(rename = "ICAG")]
#[cfg_attr(feature = "serde", serde(rename = "ICAG"))]
Icag,
#[yaserde(rename = "IPAC")]
#[cfg_attr(feature = "serde", serde(rename = "IPAC"))]
Ipac,
#[yaserde(rename = "INTE")]
#[cfg_attr(feature = "serde", serde(rename = "INTE"))]
Inte,
#[yaserde(rename = "DMON")]
#[cfg_attr(feature = "serde", serde(rename = "DMON"))]
Dmon,
#[yaserde(rename = "PRCT")]
#[cfg_attr(feature = "serde", serde(rename = "PRCT"))]
Prct,
#[yaserde(rename = "IVAG")]
#[cfg_attr(feature = "serde", serde(rename = "IVAG"))]
Ivag,
#[yaserde(rename = "NCRR")]
#[cfg_attr(feature = "serde", serde(rename = "NCRR"))]
Ncrr,
#[yaserde(rename = "DTRD")]
#[cfg_attr(feature = "serde", serde(rename = "DTRD"))]
Dtrd,
#[yaserde(rename = "UPAY")]
#[cfg_attr(feature = "serde", serde(rename = "UPAY"))]
Upay,
#[yaserde(rename = "URSC")]
#[cfg_attr(feature = "serde", serde(rename = "URSC"))]
Ursc,
#[yaserde(rename = "NCMP")]
#[cfg_attr(feature = "serde", serde(rename = "NCMP"))]
Ncmp,
__Unknown__(String),
}
impl Default for RejectedStatusReason13Code {
fn default() -> RejectedStatusReason13Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for RejectedStatusReason13Code {}
#[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:sese.011.001.10")]
pub struct RejectionReason56 {
#[yaserde(rename = "Rsn")]
#[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
pub rsn: RejectedReason45Choice,
#[yaserde(rename = "AddtlRsnInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlRsnInf"))]
pub addtl_rsn_inf: Max350Text,
}
impl Validate for RejectionReason56 {}
#[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:sese.011.001.10")]
pub struct ReversedStatus2Choice {
#[yaserde(rename = "Rsn")]
#[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
pub rsn: Option<Max350Text>,
#[yaserde(rename = "DataSrcSchme")]
#[cfg_attr(feature = "serde", serde(rename = "DataSrcSchme"))]
pub data_src_schme: Option<GenericIdentification1>,
#[yaserde(rename = "NoSpcfdRsn")]
#[cfg_attr(feature = "serde", serde(rename = "NoSpcfdRsn"))]
pub no_spcfd_rsn: Option<NoReasonCode>,
}
impl Validate for ReversedStatus2Choice {}
#[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:sese.011.001.10")]
pub struct Role8Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<InvestmentFundRole8Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification36>,
}
impl Validate for Role8Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct RussianCentralBankIdentificationCodeIdentifier (pub String);
crate::simple_type!(RussianCentralBankIdentificationCodeIdentifier);
impl Validate for RussianCentralBankIdentificationCodeIdentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Sedolidentifier (pub String);
crate::simple_type!(Sedolidentifier);
impl Validate for Sedolidentifier {}
#[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:sese.011.001.10")]
pub struct SecurityIdentification46Choice {
#[yaserde(rename = "ISIN")]
#[cfg_attr(feature = "serde", serde(rename = "ISIN"))]
pub isin: Option<Isinoct2015Identifier>,
#[yaserde(rename = "SEDOL")]
#[cfg_attr(feature = "serde", serde(rename = "SEDOL"))]
pub sedol: Option<Sedolidentifier>,
#[yaserde(rename = "CUSIP")]
#[cfg_attr(feature = "serde", serde(rename = "CUSIP"))]
pub cusip: Option<Cusipidentifier>,
#[yaserde(rename = "RIC")]
#[cfg_attr(feature = "serde", serde(rename = "RIC"))]
pub ric: Option<Ricidentifier>,
#[yaserde(rename = "TckrSymb")]
#[cfg_attr(feature = "serde", serde(rename = "TckrSymb"))]
pub tckr_symb: Option<TickerIdentifier>,
#[yaserde(rename = "Blmbrg")]
#[cfg_attr(feature = "serde", serde(rename = "Blmbrg"))]
pub blmbrg: Option<Bloomberg2Identifier>,
#[yaserde(rename = "CTA")]
#[cfg_attr(feature = "serde", serde(rename = "CTA"))]
pub cta: Option<ConsolidatedTapeAssociationIdentifier>,
#[yaserde(rename = "QUICK")]
#[cfg_attr(feature = "serde", serde(rename = "QUICK"))]
pub quick: Option<Quickidentifier>,
#[yaserde(rename = "Wrtppr")]
#[cfg_attr(feature = "serde", serde(rename = "Wrtppr"))]
pub wrtppr: Option<WertpapierIdentifier>,
#[yaserde(rename = "Dtch")]
#[cfg_attr(feature = "serde", serde(rename = "Dtch"))]
pub dtch: Option<DutchIdentifier>,
#[yaserde(rename = "Vlrn")]
#[cfg_attr(feature = "serde", serde(rename = "Vlrn"))]
pub vlrn: Option<ValorenIdentifier>,
#[yaserde(rename = "SCVM")]
#[cfg_attr(feature = "serde", serde(rename = "SCVM"))]
pub scvm: Option<SicovamIdentifier>,
#[yaserde(rename = "Belgn")]
#[cfg_attr(feature = "serde", serde(rename = "Belgn"))]
pub belgn: Option<BelgianIdentifier>,
#[yaserde(rename = "Cmon")]
#[cfg_attr(feature = "serde", serde(rename = "Cmon"))]
pub cmon: Option<EuroclearClearstreamIdentifier>,
#[yaserde(rename = "DTI")]
#[cfg_attr(feature = "serde", serde(rename = "DTI"))]
pub dti: Option<Dti2024Identifier>,
#[yaserde(rename = "OthrPrtryId")]
#[cfg_attr(feature = "serde", serde(rename = "OthrPrtryId"))]
pub othr_prtry_id: Option<AlternateSecurityIdentification7>,
}
impl Validate for SecurityIdentification46Choice {}
#[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:sese.011.001.10")]
pub struct SecurityIdentification50 {
#[yaserde(rename = "ISIN")]
#[cfg_attr(feature = "serde", serde(rename = "ISIN"))]
pub isin: Isinoct2015Identifier,
#[yaserde(rename = "OthrId")]
#[cfg_attr(feature = "serde", serde(rename = "OthrId"))]
pub othr_id: Vec<OtherIdentification8>,
#[yaserde(rename = "Desc")]
#[cfg_attr(feature = "serde", serde(rename = "Desc"))]
pub desc: Max140Text,
}
impl Validate for SecurityIdentification50 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct SicovamIdentifier (pub String);
crate::simple_type!(SicovamIdentifier);
impl Validate for SicovamIdentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct SmallNetworkIdentifier (pub String);
crate::simple_type!(SmallNetworkIdentifier);
impl Validate for SmallNetworkIdentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct SouthAfricanNCCIdentifier (pub String);
crate::simple_type!(SouthAfricanNCCIdentifier);
impl Validate for SouthAfricanNCCIdentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct SpanishDomesticInterbankingIdentifier (pub String);
crate::simple_type!(SpanishDomesticInterbankingIdentifier);
impl Validate for SpanishDomesticInterbankingIdentifier {}
#[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:sese.011.001.10")]
pub struct SubAccount5 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max35Text,
#[yaserde(rename = "Nm")]
#[cfg_attr(feature = "serde", serde(rename = "Nm"))]
pub nm: Max35Text,
#[yaserde(rename = "Chrtc")]
#[cfg_attr(feature = "serde", serde(rename = "Chrtc"))]
pub chrtc: Max35Text,
}
impl Validate for SubAccount5 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct SwissBCIdentifier (pub String);
crate::simple_type!(SwissBCIdentifier);
impl Validate for SwissBCIdentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct SwissSICIdentifier (pub String);
crate::simple_type!(SwissSICIdentifier);
impl Validate for SwissSICIdentifier {}
#[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:sese.011.001.10")]
pub struct Tax35 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: TaxType3Choice,
#[yaserde(rename = "ApldAmt")]
#[cfg_attr(feature = "serde", serde(rename = "ApldAmt"))]
pub apld_amt: ActiveCurrencyAndAmount,
#[yaserde(rename = "ApldRate")]
#[cfg_attr(feature = "serde", serde(rename = "ApldRate"))]
pub apld_rate: PercentageRate,
#[yaserde(rename = "Ctry")]
#[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
pub ctry: CountryCode,
#[yaserde(rename = "RcptId")]
#[cfg_attr(feature = "serde", serde(rename = "RcptId"))]
pub rcpt_id: PartyIdentification139,
#[yaserde(rename = "TaxClctnDtls")]
#[cfg_attr(feature = "serde", serde(rename = "TaxClctnDtls"))]
pub tax_clctn_dtls: TaxCalculationInformation10,
}
impl Validate for Tax35 {}
#[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:sese.011.001.10")]
pub struct TaxBasis1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<TaxationBasis2Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification47>,
}
impl Validate for TaxBasis1Choice {}
#[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:sese.011.001.10")]
pub struct TaxCalculationInformation10 {
#[yaserde(rename = "Bsis")]
#[cfg_attr(feature = "serde", serde(rename = "Bsis"))]
pub bsis: TaxBasis1Choice,
#[yaserde(rename = "TaxblAmt")]
#[cfg_attr(feature = "serde", serde(rename = "TaxblAmt"))]
pub taxbl_amt: ActiveCurrencyAndAmount,
}
impl Validate for TaxCalculationInformation10 {}
#[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:sese.011.001.10")]
pub struct TaxReference2 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: TaxReferenceType1Choice,
#[yaserde(rename = "Ref")]
#[cfg_attr(feature = "serde", serde(rename = "Ref"))]
pub _ref: Max35Text,
}
impl Validate for TaxReference2 {}
#[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:sese.011.001.10")]
pub struct TaxReferenceType1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<PersonIdentificationType7Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification36>,
}
impl Validate for TaxReferenceType1Choice {}
#[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:sese.011.001.10")]
pub enum TaxType17Code {
#[yaserde(rename = "PROV")]
#[cfg_attr(feature = "serde", serde(rename = "PROV"))]
Prov,
#[yaserde(rename = "NATI")]
#[cfg_attr(feature = "serde", serde(rename = "NATI"))]
Nati,
#[yaserde(rename = "STAT")]
#[cfg_attr(feature = "serde", serde(rename = "STAT"))]
Stat,
#[yaserde(rename = "WITH")]
#[cfg_attr(feature = "serde", serde(rename = "WITH"))]
With,
#[yaserde(rename = "KAPA")]
#[cfg_attr(feature = "serde", serde(rename = "KAPA"))]
Kapa,
#[yaserde(rename = "NKAP")]
#[cfg_attr(feature = "serde", serde(rename = "NKAP"))]
Nkap,
#[yaserde(rename = "INPO")]
#[cfg_attr(feature = "serde", serde(rename = "INPO"))]
Inpo,
#[yaserde(rename = "STAM")]
#[cfg_attr(feature = "serde", serde(rename = "STAM"))]
Stam,
#[yaserde(rename = "WTAX")]
#[cfg_attr(feature = "serde", serde(rename = "WTAX"))]
Wtax,
#[yaserde(rename = "INHT")]
#[cfg_attr(feature = "serde", serde(rename = "INHT"))]
Inht,
#[yaserde(rename = "SOSU")]
#[cfg_attr(feature = "serde", serde(rename = "SOSU"))]
Sosu,
#[yaserde(rename = "CTAX")]
#[cfg_attr(feature = "serde", serde(rename = "CTAX"))]
Ctax,
#[yaserde(rename = "GIFT")]
#[cfg_attr(feature = "serde", serde(rename = "GIFT"))]
Gift,
#[yaserde(rename = "COAX")]
#[cfg_attr(feature = "serde", serde(rename = "COAX"))]
Coax,
#[yaserde(rename = "EUTR")]
#[cfg_attr(feature = "serde", serde(rename = "EUTR"))]
Eutr,
#[yaserde(rename = "AKT1")]
#[cfg_attr(feature = "serde", serde(rename = "AKT1"))]
Akt1,
#[yaserde(rename = "AKT2")]
#[cfg_attr(feature = "serde", serde(rename = "AKT2"))]
Akt2,
#[yaserde(rename = "ZWIS")]
#[cfg_attr(feature = "serde", serde(rename = "ZWIS"))]
Zwis,
__Unknown__(String),
}
impl Default for TaxType17Code {
fn default() -> TaxType17Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for TaxType17Code {}
#[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:sese.011.001.10")]
pub struct TaxType3Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<TaxType17Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification47>,
}
impl Validate for TaxType3Choice {}
#[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:sese.011.001.10")]
pub struct TaxableIncomePerShareCalculated2Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<TaxableIncomePerShareCalculated2Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification47>,
}
impl Validate for TaxableIncomePerShareCalculated2Choice {}
#[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:sese.011.001.10")]
pub enum TaxableIncomePerShareCalculated2Code {
#[yaserde(rename = "TSIY")]
#[cfg_attr(feature = "serde", serde(rename = "TSIY"))]
Tsiy,
#[yaserde(rename = "TSIN")]
#[cfg_attr(feature = "serde", serde(rename = "TSIN"))]
Tsin,
#[yaserde(rename = "UKWN")]
#[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
Ukwn,
__Unknown__(String),
}
impl Default for TaxableIncomePerShareCalculated2Code {
fn default() -> TaxableIncomePerShareCalculated2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for TaxableIncomePerShareCalculated2Code {}
#[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:sese.011.001.10")]
pub enum TaxationBasis2Code {
#[yaserde(rename = "FLAT")]
#[cfg_attr(feature = "serde", serde(rename = "FLAT"))]
Flat,
#[yaserde(rename = "PERU")]
#[cfg_attr(feature = "serde", serde(rename = "PERU"))]
Peru,
__Unknown__(String),
}
impl Default for TaxationBasis2Code {
fn default() -> TaxationBasis2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for TaxationBasis2Code {}
#[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:sese.011.001.10")]
pub enum TaxationBasis5Code {
#[yaserde(rename = "FLAT")]
#[cfg_attr(feature = "serde", serde(rename = "FLAT"))]
Flat,
#[yaserde(rename = "GRAM")]
#[cfg_attr(feature = "serde", serde(rename = "GRAM"))]
Gram,
#[yaserde(rename = "NEAM")]
#[cfg_attr(feature = "serde", serde(rename = "NEAM"))]
Neam,
#[yaserde(rename = "NAVP")]
#[cfg_attr(feature = "serde", serde(rename = "NAVP"))]
Navp,
#[yaserde(rename = "PERU")]
#[cfg_attr(feature = "serde", serde(rename = "PERU"))]
Peru,
__Unknown__(String),
}
impl Default for TaxationBasis5Code {
fn default() -> TaxationBasis5Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for TaxationBasis5Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct TickerIdentifier (pub String);
crate::simple_type!(TickerIdentifier);
impl Validate for TickerIdentifier {
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.011.001.10")]
pub struct TotalFeesAndTaxes44 {
#[yaserde(rename = "TtlOvrhdApld")]
#[cfg_attr(feature = "serde", serde(rename = "TtlOvrhdApld"))]
pub ttl_ovrhd_apld: ActiveCurrencyAndAmount,
#[yaserde(rename = "TtlFees")]
#[cfg_attr(feature = "serde", serde(rename = "TtlFees"))]
pub ttl_fees: ActiveCurrencyAndAmount,
#[yaserde(rename = "TtlTaxs")]
#[cfg_attr(feature = "serde", serde(rename = "TtlTaxs"))]
pub ttl_taxs: ActiveCurrencyAndAmount,
#[yaserde(rename = "ComrclAgrmtRef")]
#[cfg_attr(feature = "serde", serde(rename = "ComrclAgrmtRef"))]
pub comrcl_agrmt_ref: Max35Text,
#[yaserde(rename = "IndvFee")]
#[cfg_attr(feature = "serde", serde(rename = "IndvFee"))]
pub indv_fee: Vec<Fee11>,
#[yaserde(rename = "IndvTax")]
#[cfg_attr(feature = "serde", serde(rename = "IndvTax"))]
pub indv_tax: Vec<Tax35>,
#[yaserde(rename = "DgtlNtwkFee")]
#[cfg_attr(feature = "serde", serde(rename = "DgtlNtwkFee"))]
pub dgtl_ntwk_fee: Vec<DigitalPaymentSettlement3>,
}
impl Validate for TotalFeesAndTaxes44 {}
#[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:sese.011.001.10")]
pub struct TransferInstructionStatus5 {
#[yaserde(rename = "Sts")]
#[cfg_attr(feature = "serde", serde(rename = "Sts"))]
pub sts: TransferStatus6Code,
#[yaserde(rename = "Rsn")]
#[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
pub rsn: Max350Text,
}
impl Validate for TransferInstructionStatus5 {}
#[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:sese.011.001.10")]
pub struct TransferInstructionStatusReportV10 {
#[yaserde(rename = "MsgId")]
#[cfg_attr(feature = "serde", serde(rename = "MsgId"))]
pub msg_id: MessageIdentification1,
#[yaserde(rename = "CtrPtyRef")]
#[cfg_attr(feature = "serde", serde(rename = "CtrPtyRef"))]
pub ctr_pty_ref: AdditionalReference10,
#[yaserde(rename = "Ref")]
#[cfg_attr(feature = "serde", serde(rename = "Ref"))]
pub _ref: References64Choice,
#[yaserde(rename = "StsRpt")]
#[cfg_attr(feature = "serde", serde(rename = "StsRpt"))]
pub sts_rpt: TransferStatusAndReason09,
#[yaserde(rename = "MktPrctcVrsn")]
#[cfg_attr(feature = "serde", serde(rename = "MktPrctcVrsn"))]
pub mkt_prctc_vrsn: MarketPracticeVersion1,
#[yaserde(rename = "Xtnsn")]
#[cfg_attr(feature = "serde", serde(rename = "Xtnsn"))]
pub xtnsn: Vec<Extension1>,
}
impl Validate for TransferInstructionStatusReportV10 {}
#[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:sese.011.001.10")]
pub struct TransferStatus5Choice {
#[yaserde(rename = "Sts")]
#[cfg_attr(feature = "serde", serde(rename = "Sts"))]
pub sts: Option<TransferInstructionStatus5>,
#[yaserde(rename = "PdgSttlm")]
#[cfg_attr(feature = "serde", serde(rename = "PdgSttlm"))]
pub pdg_sttlm: Option<PendingSettlementStatus3Choice>,
#[yaserde(rename = "Umtchd")]
#[cfg_attr(feature = "serde", serde(rename = "Umtchd"))]
pub umtchd: Option<TransferUnmatchedStatus4Choice>,
#[yaserde(rename = "InRpr")]
#[cfg_attr(feature = "serde", serde(rename = "InRpr"))]
pub in_rpr: Option<InRepairStatus4Choice>,
#[yaserde(rename = "Rjctd")]
#[cfg_attr(feature = "serde", serde(rename = "Rjctd"))]
pub rjctd: Vec<RejectionReason56>,
#[yaserde(rename = "FaildSttlm")]
#[cfg_attr(feature = "serde", serde(rename = "FaildSttlm"))]
pub faild_sttlm: Option<FailedSettlementStatus2Choice>,
#[yaserde(rename = "Canc")]
#[cfg_attr(feature = "serde", serde(rename = "Canc"))]
pub canc: Option<CancelledStatus13Choice>,
#[yaserde(rename = "Rvsd")]
#[cfg_attr(feature = "serde", serde(rename = "Rvsd"))]
pub rvsd: Option<ReversedStatus2Choice>,
#[yaserde(rename = "CxlPdg")]
#[cfg_attr(feature = "serde", serde(rename = "CxlPdg"))]
pub cxl_pdg: Option<CancellationPendingStatus7Choice>,
}
impl Validate for TransferStatus5Choice {}
#[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:sese.011.001.10")]
pub enum TransferStatus6Code {
#[yaserde(rename = "PACK")]
#[cfg_attr(feature = "serde", serde(rename = "PACK"))]
Pack,
#[yaserde(rename = "COSE")]
#[cfg_attr(feature = "serde", serde(rename = "COSE"))]
Cose,
#[yaserde(rename = "COMP")]
#[cfg_attr(feature = "serde", serde(rename = "COMP"))]
Comp,
#[yaserde(rename = "DELY")]
#[cfg_attr(feature = "serde", serde(rename = "DELY"))]
Dely,
#[yaserde(rename = "MACH")]
#[cfg_attr(feature = "serde", serde(rename = "MACH"))]
Mach,
#[yaserde(rename = "RECE")]
#[cfg_attr(feature = "serde", serde(rename = "RECE"))]
Rece,
#[yaserde(rename = "STNP")]
#[cfg_attr(feature = "serde", serde(rename = "STNP"))]
Stnp,
#[yaserde(rename = "SETT")]
#[cfg_attr(feature = "serde", serde(rename = "SETT"))]
Sett,
__Unknown__(String),
}
impl Default for TransferStatus6Code {
fn default() -> TransferStatus6Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for TransferStatus6Code {}
#[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:sese.011.001.10")]
pub struct TransferStatusAndReason09 {
#[yaserde(rename = "MstrRef")]
#[cfg_attr(feature = "serde", serde(rename = "MstrRef"))]
pub mstr_ref: Max35Text,
#[yaserde(rename = "TrfRef")]
#[cfg_attr(feature = "serde", serde(rename = "TrfRef"))]
pub trf_ref: AdditionalReference10,
#[yaserde(rename = "ClntRef")]
#[cfg_attr(feature = "serde", serde(rename = "ClntRef"))]
pub clnt_ref: AdditionalReference10,
#[yaserde(rename = "CxlRef")]
#[cfg_attr(feature = "serde", serde(rename = "CxlRef"))]
pub cxl_ref: Max35Text,
#[yaserde(rename = "TrfEvtTp")]
#[cfg_attr(feature = "serde", serde(rename = "TrfEvtTp"))]
pub trf_evt_tp: Vec<TransferStatusType3Choice>,
#[yaserde(rename = "TrfSts")]
#[cfg_attr(feature = "serde", serde(rename = "TrfSts"))]
pub trf_sts: TransferStatus5Choice,
#[yaserde(rename = "Instrm")]
#[cfg_attr(feature = "serde", serde(rename = "Instrm"))]
pub instrm: FinancialInstrument101Choice,
#[yaserde(rename = "InvstmtAcctDtls")]
#[cfg_attr(feature = "serde", serde(rename = "InvstmtAcctDtls"))]
pub invstmt_acct_dtls: Account36,
#[yaserde(rename = "IntrmyInf")]
#[cfg_attr(feature = "serde", serde(rename = "IntrmyInf"))]
pub intrmy_inf: Vec<Intermediary48>,
#[yaserde(rename = "TradDt")]
#[cfg_attr(feature = "serde", serde(rename = "TradDt"))]
pub trad_dt: Isodate,
#[yaserde(rename = "SttlmDt")]
#[cfg_attr(feature = "serde", serde(rename = "SttlmDt"))]
pub sttlm_dt: Isodate,
#[yaserde(rename = "SndOutDt")]
#[cfg_attr(feature = "serde", serde(rename = "SndOutDt"))]
pub snd_out_dt: Isodate,
#[yaserde(rename = "CshSttlmDt")]
#[cfg_attr(feature = "serde", serde(rename = "CshSttlmDt"))]
pub csh_sttlm_dt: Isodate,
#[yaserde(rename = "TtlUnitsNb")]
#[cfg_attr(feature = "serde", serde(rename = "TtlUnitsNb"))]
pub ttl_units_nb: DecimalNumber,
#[yaserde(rename = "AvrgPric")]
#[cfg_attr(feature = "serde", serde(rename = "AvrgPric"))]
pub avrg_pric: ActiveOrHistoricCurrencyAnd13DecimalAmount,
#[yaserde(rename = "UnitsDtls")]
#[cfg_attr(feature = "serde", serde(rename = "UnitsDtls"))]
pub units_dtls: Vec<Unit14>,
#[yaserde(rename = "Convs")]
#[cfg_attr(feature = "serde", serde(rename = "Convs"))]
pub convs: Conversion4,
#[yaserde(rename = "TtlTrfVal")]
#[cfg_attr(feature = "serde", serde(rename = "TtlTrfVal"))]
pub ttl_trf_val: ActiveCurrencyAnd13DecimalAmount,
#[yaserde(rename = "PmtDtls")]
#[cfg_attr(feature = "serde", serde(rename = "PmtDtls"))]
pub pmt_dtls: Vec<PaymentInstrument23>,
#[yaserde(rename = "BnftCrstllstnEvt")]
#[cfg_attr(feature = "serde", serde(rename = "BnftCrstllstnEvt"))]
pub bnft_crstllstn_evt: Vec<BenefitCrystallisationEvent2>,
#[yaserde(rename = "DrwdwnTrch")]
#[cfg_attr(feature = "serde", serde(rename = "DrwdwnTrch"))]
pub drwdwn_trch: Vec<Drawdown04>,
#[yaserde(rename = "OthrDrwdwnInf")]
#[cfg_attr(feature = "serde", serde(rename = "OthrDrwdwnInf"))]
pub othr_drwdwn_inf: Drawdown3,
#[yaserde(rename = "QryRspn")]
#[cfg_attr(feature = "serde", serde(rename = "QryRspn"))]
pub qry_rspn: Vec<Max350Text>,
#[yaserde(rename = "StsInitr")]
#[cfg_attr(feature = "serde", serde(rename = "StsInitr"))]
pub sts_initr: PartyIdentification139,
#[yaserde(rename = "StsIssr")]
#[cfg_attr(feature = "serde", serde(rename = "StsIssr"))]
pub sts_issr: PartyIdentification139,
#[yaserde(rename = "StsRcpt")]
#[cfg_attr(feature = "serde", serde(rename = "StsRcpt"))]
pub sts_rcpt: PartyIdentification139,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: Vec<AdditionalInformation15>,
}
impl Validate for TransferStatusAndReason09 {}
#[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:sese.011.001.10")]
pub enum TransferStatusType2Code {
S019,
#[yaserde(rename = "BCEV")]
#[cfg_attr(feature = "serde", serde(rename = "BCEV"))]
Bcev,
#[yaserde(rename = "SETT")]
#[cfg_attr(feature = "serde", serde(rename = "SETT"))]
Sett,
#[yaserde(rename = "DRAW")]
#[cfg_attr(feature = "serde", serde(rename = "DRAW"))]
Draw,
#[yaserde(rename = "PAYA")]
#[cfg_attr(feature = "serde", serde(rename = "PAYA"))]
Paya,
S012,
#[yaserde(rename = "INFO")]
#[cfg_attr(feature = "serde", serde(rename = "INFO"))]
Info,
#[yaserde(rename = "STAT")]
#[cfg_attr(feature = "serde", serde(rename = "STAT"))]
Stat,
S005,
S001,
#[yaserde(rename = "CONV")]
#[cfg_attr(feature = "serde", serde(rename = "CONV"))]
Conv,
__Unknown__(String),
}
impl Default for TransferStatusType2Code {
fn default() -> TransferStatusType2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for TransferStatusType2Code {}
#[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:sese.011.001.10")]
pub struct TransferStatusType3Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<TransferStatusType2Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification1>,
}
impl Validate for TransferStatusType3Choice {}
#[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:sese.011.001.10")]
pub enum TransferUnmatchedReason3Code {
#[yaserde(rename = "CMIS")]
#[cfg_attr(feature = "serde", serde(rename = "CMIS"))]
Cmis,
#[yaserde(rename = "CPCA")]
#[cfg_attr(feature = "serde", serde(rename = "CPCA"))]
Cpca,
#[yaserde(rename = "DELN")]
#[cfg_attr(feature = "serde", serde(rename = "DELN"))]
Deln,
#[yaserde(rename = "DSEC")]
#[cfg_attr(feature = "serde", serde(rename = "DSEC"))]
Dsec,
#[yaserde(rename = "PHYS")]
#[cfg_attr(feature = "serde", serde(rename = "PHYS"))]
Phys,
#[yaserde(rename = "PODU")]
#[cfg_attr(feature = "serde", serde(rename = "PODU"))]
Podu,
#[yaserde(rename = "DEPT")]
#[cfg_attr(feature = "serde", serde(rename = "DEPT"))]
Dept,
#[yaserde(rename = "DDAT")]
#[cfg_attr(feature = "serde", serde(rename = "DDAT"))]
Ddat,
#[yaserde(rename = "DQUA")]
#[cfg_attr(feature = "serde", serde(rename = "DQUA"))]
Dqua,
#[yaserde(rename = "ICUS")]
#[cfg_attr(feature = "serde", serde(rename = "ICUS"))]
Icus,
#[yaserde(rename = "SAFE")]
#[cfg_attr(feature = "serde", serde(rename = "SAFE"))]
Safe,
__Unknown__(String),
}
impl Default for TransferUnmatchedReason3Code {
fn default() -> TransferUnmatchedReason3Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for TransferUnmatchedReason3Code {}
#[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:sese.011.001.10")]
pub struct TransferUnmatchedStatus4Choice {
#[yaserde(rename = "NoSpcfdRsn")]
#[cfg_attr(feature = "serde", serde(rename = "NoSpcfdRsn"))]
pub no_spcfd_rsn: Option<NoReasonCode>,
#[yaserde(rename = "Rsn")]
#[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
pub rsn: Option<TransferUnmatchedReason3Code>,
#[yaserde(rename = "XtndedRsn")]
#[cfg_attr(feature = "serde", serde(rename = "XtndedRsn"))]
pub xtnded_rsn: Option<Extended350Code>,
#[yaserde(rename = "DataSrcSchme")]
#[cfg_attr(feature = "serde", serde(rename = "DataSrcSchme"))]
pub data_src_schme: Option<GenericIdentification1>,
}
impl Validate for TransferUnmatchedStatus4Choice {}
#[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:sese.011.001.10")]
pub enum TypeOfPrice10Code {
#[yaserde(rename = "BIDE")]
#[cfg_attr(feature = "serde", serde(rename = "BIDE"))]
Bide,
#[yaserde(rename = "OFFR")]
#[cfg_attr(feature = "serde", serde(rename = "OFFR"))]
Offr,
#[yaserde(rename = "NAVL")]
#[cfg_attr(feature = "serde", serde(rename = "NAVL"))]
Navl,
#[yaserde(rename = "CREA")]
#[cfg_attr(feature = "serde", serde(rename = "CREA"))]
Crea,
#[yaserde(rename = "CANC")]
#[cfg_attr(feature = "serde", serde(rename = "CANC"))]
Canc,
#[yaserde(rename = "INTE")]
#[cfg_attr(feature = "serde", serde(rename = "INTE"))]
Inte,
#[yaserde(rename = "SWNG")]
#[cfg_attr(feature = "serde", serde(rename = "SWNG"))]
Swng,
#[yaserde(rename = "MIDD")]
#[cfg_attr(feature = "serde", serde(rename = "MIDD"))]
Midd,
#[yaserde(rename = "RINV")]
#[cfg_attr(feature = "serde", serde(rename = "RINV"))]
Rinv,
#[yaserde(rename = "SWIC")]
#[cfg_attr(feature = "serde", serde(rename = "SWIC"))]
Swic,
#[yaserde(rename = "DDVR")]
#[cfg_attr(feature = "serde", serde(rename = "DDVR"))]
Ddvr,
#[yaserde(rename = "ACTU")]
#[cfg_attr(feature = "serde", serde(rename = "ACTU"))]
Actu,
__Unknown__(String),
}
impl Default for TypeOfPrice10Code {
fn default() -> TypeOfPrice10Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for TypeOfPrice10Code {}
#[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:sese.011.001.10")]
pub struct TypeOfPrice46Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<TypeOfPrice10Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification47>,
}
impl Validate for TypeOfPrice46Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct UkdomesticSortCodeIdentifier (pub String);
crate::simple_type!(UkdomesticSortCodeIdentifier);
impl Validate for UkdomesticSortCodeIdentifier {}
#[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:sese.011.001.10")]
pub enum UktaxGroupUnit1Code {
#[yaserde(rename = "GRP1")]
#[cfg_attr(feature = "serde", serde(rename = "GRP1"))]
Grp1,
#[yaserde(rename = "GRP2")]
#[cfg_attr(feature = "serde", serde(rename = "GRP2"))]
Grp2,
__Unknown__(String),
}
impl Default for UktaxGroupUnit1Code {
fn default() -> UktaxGroupUnit1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for UktaxGroupUnit1Code {}
#[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:sese.011.001.10")]
pub struct Unit14 {
#[yaserde(rename = "Units")]
#[cfg_attr(feature = "serde", serde(rename = "Units"))]
pub units: Unit1Choice,
#[yaserde(rename = "OrdrDt")]
#[cfg_attr(feature = "serde", serde(rename = "OrdrDt"))]
pub ordr_dt: Isodate,
#[yaserde(rename = "AcqstnDt")]
#[cfg_attr(feature = "serde", serde(rename = "AcqstnDt"))]
pub acqstn_dt: Isodate,
#[yaserde(rename = "CertNb")]
#[cfg_attr(feature = "serde", serde(rename = "CertNb"))]
pub cert_nb: Vec<Max35Text>,
#[yaserde(rename = "Grp1Or2Units")]
#[cfg_attr(feature = "serde", serde(rename = "Grp1Or2Units"))]
pub grp_1_or_2_units: UktaxGroupUnit1Code,
#[yaserde(rename = "Ref")]
#[cfg_attr(feature = "serde", serde(rename = "Ref"))]
pub _ref: Max35Text,
#[yaserde(rename = "PricDtls")]
#[cfg_attr(feature = "serde", serde(rename = "PricDtls"))]
pub pric_dtls: UnitPrice23,
#[yaserde(rename = "TxOvrhd")]
#[cfg_attr(feature = "serde", serde(rename = "TxOvrhd"))]
pub tx_ovrhd: TotalFeesAndTaxes44,
#[yaserde(rename = "OthrAmt")]
#[cfg_attr(feature = "serde", serde(rename = "OthrAmt"))]
pub othr_amt: Vec<OtherAmount1>,
}
impl Validate for Unit14 {}
#[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:sese.011.001.10")]
pub struct Unit15 {
#[yaserde(rename = "Units")]
#[cfg_attr(feature = "serde", serde(rename = "Units"))]
pub units: Unit1Choice,
#[yaserde(rename = "OrdrDt")]
#[cfg_attr(feature = "serde", serde(rename = "OrdrDt"))]
pub ordr_dt: Isodate,
#[yaserde(rename = "AcqstnDt")]
#[cfg_attr(feature = "serde", serde(rename = "AcqstnDt"))]
pub acqstn_dt: Isodate,
#[yaserde(rename = "CertNb")]
#[cfg_attr(feature = "serde", serde(rename = "CertNb"))]
pub cert_nb: Vec<Max35Text>,
#[yaserde(rename = "Grp1Or2Units")]
#[cfg_attr(feature = "serde", serde(rename = "Grp1Or2Units"))]
pub grp_1_or_2_units: UktaxGroupUnit1Code,
#[yaserde(rename = "Ref")]
#[cfg_attr(feature = "serde", serde(rename = "Ref"))]
pub _ref: Max35Text,
}
impl Validate for Unit15 {}
#[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:sese.011.001.10")]
pub struct Unit1Choice {
#[yaserde(rename = "UnitsNb")]
#[cfg_attr(feature = "serde", serde(rename = "UnitsNb"))]
pub units_nb: Option<DecimalNumber>,
#[yaserde(rename = "DgtlTknUnit")]
#[cfg_attr(feature = "serde", serde(rename = "DgtlTknUnit"))]
pub dgtl_tkn_unit: Option<Max30DecimalNumber>,
}
impl Validate for Unit1Choice {}
#[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:sese.011.001.10")]
pub struct UnitPrice23 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: TypeOfPrice46Choice,
#[yaserde(rename = "Val")]
#[cfg_attr(feature = "serde", serde(rename = "Val"))]
pub val: PriceValue1,
#[yaserde(rename = "PricMtd")]
#[cfg_attr(feature = "serde", serde(rename = "PricMtd"))]
pub pric_mtd: PriceMethod1Code,
#[yaserde(rename = "AcrdIntrstNAV")]
#[cfg_attr(feature = "serde", serde(rename = "AcrdIntrstNAV"))]
pub acrd_intrst_nav: ActiveOrHistoricCurrencyAndAmount,
#[yaserde(rename = "NbOfDaysAcrd")]
#[cfg_attr(feature = "serde", serde(rename = "NbOfDaysAcrd"))]
pub nb_of_days_acrd: Number,
#[yaserde(rename = "TaxblIncmPerShr")]
#[cfg_attr(feature = "serde", serde(rename = "TaxblIncmPerShr"))]
pub taxbl_incm_per_shr: ActiveCurrencyAnd13DecimalAmount,
#[yaserde(rename = "TaxblIncmPerShrClctd")]
#[cfg_attr(feature = "serde", serde(rename = "TaxblIncmPerShrClctd"))]
pub taxbl_incm_per_shr_clctd: TaxableIncomePerShareCalculated2Choice,
}
impl Validate for UnitPrice23 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ValorenIdentifier (pub String);
crate::simple_type!(ValorenIdentifier);
impl Validate for ValorenIdentifier {}
#[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:sese.011.001.10")]
pub enum WaivingInstruction1Code {
#[yaserde(rename = "WICA")]
#[cfg_attr(feature = "serde", serde(rename = "WICA"))]
Wica,
#[yaserde(rename = "WIUN")]
#[cfg_attr(feature = "serde", serde(rename = "WIUN"))]
Wiun,
__Unknown__(String),
}
impl Default for WaivingInstruction1Code {
fn default() -> WaivingInstruction1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for WaivingInstruction1Code {}
#[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:sese.011.001.10")]
pub struct WaivingInstruction2Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<WaivingInstruction1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification47>,
}
impl Validate for WaivingInstruction2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct WertpapierIdentifier (pub String);
crate::simple_type!(WertpapierIdentifier);
impl Validate for WertpapierIdentifier {}
#[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 {}
impl crate::MxMessage for Document {
const BUSINESS_AREA: crate::BusinessArea = crate::BusinessArea::sese;
const FUNCTIONALITY: &'static str = "011";
const VARIANT: &'static str = "001";
const VERSION: &'static str = "10";
const MESSAGE_NAME: &'static str = "sese.011.001.10";
const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:sese.011.001.10";
}