#![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.013.001.12")]
pub struct Account27 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max35Text,
#[yaserde(rename = "AcctSvcr")]
#[cfg_attr(feature = "serde", serde(rename = "AcctSvcr"))]
pub acct_svcr: PartyIdentification139,
}
impl Validate for Account27 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct Account37 {
#[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 = "Dsgnt")]
#[cfg_attr(feature = "serde", serde(rename = "Dsgnt"))]
pub dsgnt: Max35Text,
#[yaserde(rename = "AcctNm")]
#[cfg_attr(feature = "serde", serde(rename = "AcctNm"))]
pub acct_nm: Max35Text,
#[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 Account37 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.013.001.12")]
pub enum AccountOwnershipType6Code {
#[yaserde(rename = "BOWN")]
#[cfg_attr(feature = "serde", serde(rename = "BOWN"))]
Bown,
#[yaserde(rename = "CORP")]
#[cfg_attr(feature = "serde", serde(rename = "CORP"))]
Corp,
#[yaserde(rename = "CUST")]
#[cfg_attr(feature = "serde", serde(rename = "CUST"))]
Cust,
#[yaserde(rename = "ENTR")]
#[cfg_attr(feature = "serde", serde(rename = "ENTR"))]
Entr,
#[yaserde(rename = "EURE")]
#[cfg_attr(feature = "serde", serde(rename = "EURE"))]
Eure,
#[yaserde(rename = "PART")]
#[cfg_attr(feature = "serde", serde(rename = "PART"))]
Part,
#[yaserde(rename = "TRUS")]
#[cfg_attr(feature = "serde", serde(rename = "TRUS"))]
Trus,
#[yaserde(rename = "GOVO")]
#[cfg_attr(feature = "serde", serde(rename = "GOVO"))]
Govo,
#[yaserde(rename = "JOIT")]
#[cfg_attr(feature = "serde", serde(rename = "JOIT"))]
Joit,
#[yaserde(rename = "COMO")]
#[cfg_attr(feature = "serde", serde(rename = "COMO"))]
Como,
#[yaserde(rename = "JOIN")]
#[cfg_attr(feature = "serde", serde(rename = "JOIN"))]
Join,
#[yaserde(rename = "LLCO")]
#[cfg_attr(feature = "serde", serde(rename = "LLCO"))]
Llco,
#[yaserde(rename = "LIPA")]
#[cfg_attr(feature = "serde", serde(rename = "LIPA"))]
Lipa,
#[yaserde(rename = "NOMI")]
#[cfg_attr(feature = "serde", serde(rename = "NOMI"))]
Nomi,
#[yaserde(rename = "NFPO")]
#[cfg_attr(feature = "serde", serde(rename = "NFPO"))]
Nfpo,
#[yaserde(rename = "ONIS")]
#[cfg_attr(feature = "serde", serde(rename = "ONIS"))]
Onis,
#[yaserde(rename = "OWNR")]
#[cfg_attr(feature = "serde", serde(rename = "OWNR"))]
Ownr,
#[yaserde(rename = "RGIC")]
#[cfg_attr(feature = "serde", serde(rename = "RGIC"))]
Rgic,
#[yaserde(rename = "SIGL")]
#[cfg_attr(feature = "serde", serde(rename = "SIGL"))]
Sigl,
#[yaserde(rename = "UNCO")]
#[cfg_attr(feature = "serde", serde(rename = "UNCO"))]
Unco,
#[yaserde(rename = "USUF")]
#[cfg_attr(feature = "serde", serde(rename = "USUF"))]
Usuf,
__Unknown__(String),
}
impl Default for AccountOwnershipType6Code {
fn default() -> AccountOwnershipType6Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AccountOwnershipType6Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.013.001.12")]
pub struct AdditionalReference11 {
#[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 AdditionalReference11 {}
#[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.013.001.12")]
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.013.001.12")]
pub struct AllOtherCash1 {
#[yaserde(rename = "Ind")]
#[cfg_attr(feature = "serde", serde(rename = "Ind"))]
pub ind: YesNoIndicator,
#[yaserde(rename = "Ccy")]
#[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
pub ccy: ActiveCurrencyCode,
}
impl Validate for AllOtherCash1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct AlternatePartyIdentification7 {
#[yaserde(rename = "IdTp")]
#[cfg_attr(feature = "serde", serde(rename = "IdTp"))]
pub id_tp: IdentificationType42Choice,
#[yaserde(rename = "Ctry")]
#[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
pub ctry: CountryCode,
#[yaserde(rename = "AltrnId")]
#[cfg_attr(feature = "serde", serde(rename = "AltrnId"))]
pub altrn_id: Max35Text,
}
impl Validate for AlternatePartyIdentification7 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
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)]
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.013.001.12")]
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.013.001.12")]
pub struct BonusWithdrawal2 {
#[yaserde(rename = "TpOfAmt")]
#[cfg_attr(feature = "serde", serde(rename = "TpOfAmt"))]
pub tp_of_amt: TypeOfAmount1Choice,
#[yaserde(rename = "Amt")]
#[cfg_attr(feature = "serde", serde(rename = "Amt"))]
pub amt: ActiveOrHistoricCurrencyAnd13DecimalAmount,
#[yaserde(rename = "Rsn")]
#[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
pub rsn: WithdrawalReason1Choice,
#[yaserde(rename = "UclmdAmt")]
#[cfg_attr(feature = "serde", serde(rename = "UclmdAmt"))]
pub uclmd_amt: ActiveOrHistoricCurrencyAnd13DecimalAmount,
#[yaserde(rename = "Outsdng")]
#[cfg_attr(feature = "serde", serde(rename = "Outsdng"))]
pub outsdng: YesNoIndicator,
#[yaserde(rename = "Ref")]
#[cfg_attr(feature = "serde", serde(rename = "Ref"))]
pub _ref: Max35Text,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: Vec<AdditionalInformation15>,
}
impl Validate for BonusWithdrawal2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.013.001.12")]
pub enum BusinessFlowType1Code {
#[yaserde(rename = "SLDP")]
#[cfg_attr(feature = "serde", serde(rename = "SLDP"))]
Sldp,
#[yaserde(rename = "SLRP")]
#[cfg_attr(feature = "serde", serde(rename = "SLRP"))]
Slrp,
#[yaserde(rename = "DLPR")]
#[cfg_attr(feature = "serde", serde(rename = "DLPR"))]
Dlpr,
__Unknown__(String),
}
impl Default for BusinessFlowType1Code {
fn default() -> BusinessFlowType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for BusinessFlowType1Code {}
#[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.013.001.12")]
pub struct CashAll1 {
#[yaserde(rename = "Ind")]
#[cfg_attr(feature = "serde", serde(rename = "Ind"))]
pub ind: YesNoIndicator,
#[yaserde(rename = "Ccy")]
#[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
pub ccy: ActiveCurrencyCode,
}
impl Validate for CashAll1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
pub struct Conversion5 {
#[yaserde(rename = "TrgtScty")]
#[cfg_attr(feature = "serde", serde(rename = "TrgtScty"))]
pub trgt_scty: FinancialInstrumentIdentification7,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: Vec<AdditionalInformation15>,
}
impl Validate for Conversion5 {}
#[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.013.001.12")]
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.013.001.12")]
pub struct Crystallisation2 {
#[yaserde(rename = "TrchId")]
#[cfg_attr(feature = "serde", serde(rename = "TrchId"))]
pub trch_id: Max35Text,
#[yaserde(rename = "CrstllsdUnitsNb")]
#[cfg_attr(feature = "serde", serde(rename = "CrstllsdUnitsNb"))]
pub crstllsd_units_nb: DecimalNumber,
#[yaserde(rename = "UcrstllsdUnitsNb")]
#[cfg_attr(feature = "serde", serde(rename = "UcrstllsdUnitsNb"))]
pub ucrstllsd_units_nb: DecimalNumber,
#[yaserde(rename = "CrstllsdAmt")]
#[cfg_attr(feature = "serde", serde(rename = "CrstllsdAmt"))]
pub crstllsd_amt: ActiveCurrencyAnd13DecimalAmount,
#[yaserde(rename = "UcrstllsdAmt")]
#[cfg_attr(feature = "serde", serde(rename = "UcrstllsdAmt"))]
pub ucrstllsd_amt: ActiveCurrencyAnd13DecimalAmount,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: Vec<AdditionalInformation15>,
}
impl Validate for Crystallisation2 {}
#[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.013.001.12")]
pub struct DateAndAmount2 {
#[yaserde(rename = "Dt")]
#[cfg_attr(feature = "serde", serde(rename = "Dt"))]
pub dt: Isodate,
#[yaserde(rename = "Amt")]
#[cfg_attr(feature = "serde", serde(rename = "Amt"))]
pub amt: ActiveOrHistoricCurrencyAndAmount,
}
impl Validate for DateAndAmount2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct DateAndDateTime2Choice {
#[yaserde(rename = "Dt")]
#[cfg_attr(feature = "serde", serde(rename = "Dt"))]
pub dt: Option<Isodate>,
#[yaserde(rename = "DtTm")]
#[cfg_attr(feature = "serde", serde(rename = "DtTm"))]
pub dt_tm: Option<IsodateTime>,
}
impl Validate for DateAndDateTime2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.013.001.12")]
pub struct DateQuarter1Choice {
#[yaserde(rename = "Dt")]
#[cfg_attr(feature = "serde", serde(rename = "Dt"))]
pub dt: Option<Isodate>,
#[yaserde(rename = "Prd")]
#[cfg_attr(feature = "serde", serde(rename = "Prd"))]
pub prd: Option<Max35Text>,
}
impl Validate for DateQuarter1Choice {}
#[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.013.001.12")]
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.013.001.12")]
pub struct Document {
#[yaserde(rename = "PrtflTrfConf")]
#[cfg_attr(feature = "serde", serde(rename = "PrtflTrfConf"))]
pub prtfl_trf_conf: PortfolioTransferConfirmationV12,
}
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.013.001.12")]
pub struct DrawdownStatus1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<DrawdownStatus1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification36>,
}
impl Validate for DrawdownStatus1Choice {}
#[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.013.001.12")]
pub enum DrawdownStatus1Code {
#[yaserde(rename = "FULL")]
#[cfg_attr(feature = "serde", serde(rename = "FULL"))]
Full,
#[yaserde(rename = "NONE")]
#[cfg_attr(feature = "serde", serde(rename = "NONE"))]
None,
#[yaserde(rename = "PART")]
#[cfg_attr(feature = "serde", serde(rename = "PART"))]
Part,
__Unknown__(String),
}
impl Default for DrawdownStatus1Code {
fn default() -> DrawdownStatus1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for DrawdownStatus1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
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.013.001.12")]
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)]
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.013.001.12")]
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)]
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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
pub struct FinancialInstrument109 {
#[yaserde(rename = "LineId")]
#[cfg_attr(feature = "serde", serde(rename = "LineId"))]
pub line_id: Max35Text,
#[yaserde(rename = "Instrm")]
#[cfg_attr(feature = "serde", serde(rename = "Instrm"))]
pub instrm: FinancialInstrument101Choice,
#[yaserde(rename = "Qty")]
#[cfg_attr(feature = "serde", serde(rename = "Qty"))]
pub qty: Quantity53,
#[yaserde(rename = "PrtlInstdQty")]
#[cfg_attr(feature = "serde", serde(rename = "PrtlInstdQty"))]
pub prtl_instd_qty: YesNoIndicator,
#[yaserde(rename = "OrgnlPctgInstd")]
#[cfg_attr(feature = "serde", serde(rename = "OrgnlPctgInstd"))]
pub orgnl_pctg_instd: PercentageRate,
#[yaserde(rename = "TrfTp")]
#[cfg_attr(feature = "serde", serde(rename = "TrfTp"))]
pub trf_tp: TransferType2Choice,
#[yaserde(rename = "AddtlAsst")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlAsst"))]
pub addtl_asst: YesNoIndicator,
#[yaserde(rename = "NotAvlbl")]
#[cfg_attr(feature = "serde", serde(rename = "NotAvlbl"))]
pub not_avlbl: YesNoIndicator,
#[yaserde(rename = "Convs")]
#[cfg_attr(feature = "serde", serde(rename = "Convs"))]
pub convs: Conversion5,
#[yaserde(rename = "UnitsDtls")]
#[cfg_attr(feature = "serde", serde(rename = "UnitsDtls"))]
pub units_dtls: Vec<Unit14>,
#[yaserde(rename = "ClntRef")]
#[cfg_attr(feature = "serde", serde(rename = "ClntRef"))]
pub clnt_ref: AdditionalReference10,
#[yaserde(rename = "CtrPtyRef")]
#[cfg_attr(feature = "serde", serde(rename = "CtrPtyRef"))]
pub ctr_pty_ref: AdditionalReference10,
#[yaserde(rename = "BizFlowTp")]
#[cfg_attr(feature = "serde", serde(rename = "BizFlowTp"))]
pub biz_flow_tp: BusinessFlowType1Code,
#[yaserde(rename = "AvrgAcqstnPric")]
#[cfg_attr(feature = "serde", serde(rename = "AvrgAcqstnPric"))]
pub avrg_acqstn_pric: ActiveCurrencyAndAmount,
#[yaserde(rename = "TrfCcy")]
#[cfg_attr(feature = "serde", serde(rename = "TrfCcy"))]
pub trf_ccy: ActiveOrHistoricCurrencyCode,
#[yaserde(rename = "TtlBookVal")]
#[cfg_attr(feature = "serde", serde(rename = "TtlBookVal"))]
pub ttl_book_val: DateAndAmount2,
#[yaserde(rename = "OrgnlCost")]
#[cfg_attr(feature = "serde", serde(rename = "OrgnlCost"))]
pub orgnl_cost: ActiveCurrencyAnd13DecimalAmount,
#[yaserde(rename = "LatstValtn")]
#[cfg_attr(feature = "serde", serde(rename = "LatstValtn"))]
pub latst_valtn: DateAndAmount2,
#[yaserde(rename = "TrfeeAcct")]
#[cfg_attr(feature = "serde", serde(rename = "TrfeeAcct"))]
pub trfee_acct: Account37,
#[yaserde(rename = "Trfr")]
#[cfg_attr(feature = "serde", serde(rename = "Trfr"))]
pub trfr: Account37,
#[yaserde(rename = "IntrmyInf")]
#[cfg_attr(feature = "serde", serde(rename = "IntrmyInf"))]
pub intrmy_inf: Vec<Intermediary43>,
#[yaserde(rename = "ReqdTradDt")]
#[cfg_attr(feature = "serde", serde(rename = "ReqdTradDt"))]
pub reqd_trad_dt: Isodate,
#[yaserde(rename = "ReqdSttlmDt")]
#[cfg_attr(feature = "serde", serde(rename = "ReqdSttlmDt"))]
pub reqd_sttlm_dt: Isodate,
#[yaserde(rename = "FctvTrfDt")]
#[cfg_attr(feature = "serde", serde(rename = "FctvTrfDt"))]
pub fctv_trf_dt: DateAndDateTime2Choice,
#[yaserde(rename = "FctvSttlmDt")]
#[cfg_attr(feature = "serde", serde(rename = "FctvSttlmDt"))]
pub fctv_sttlm_dt: DateAndDateTime2Choice,
#[yaserde(rename = "PmtDtls")]
#[cfg_attr(feature = "serde", serde(rename = "PmtDtls"))]
pub pmt_dtls: PaymentInstrument22,
#[yaserde(rename = "CrstllstnDtls")]
#[cfg_attr(feature = "serde", serde(rename = "CrstllstnDtls"))]
pub crstllstn_dtls: Vec<Crystallisation2>,
#[yaserde(rename = "TaxValtnPt")]
#[cfg_attr(feature = "serde", serde(rename = "TaxValtnPt"))]
pub tax_valtn_pt: Tax36,
#[yaserde(rename = "SttlmPtiesDtls")]
#[cfg_attr(feature = "serde", serde(rename = "SttlmPtiesDtls"))]
pub sttlm_pties_dtls: FundSettlementParameters24,
#[yaserde(rename = "AsstsHeldInOwnNm")]
#[cfg_attr(feature = "serde", serde(rename = "AsstsHeldInOwnNm"))]
pub assts_held_in_own_nm: YesNoIndicator,
#[yaserde(rename = "TrfRsltsInChngOfBnfclOwnr")]
#[cfg_attr(feature = "serde", serde(rename = "TrfRsltsInChngOfBnfclOwnr"))]
pub trf_rslts_in_chng_of_bnfcl_ownr: YesNoIndicator,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: Vec<AdditionalInformation15>,
}
impl Validate for FinancialInstrument109 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
pub struct FundPortfolio7Choice {
#[yaserde(rename = "TaxEffcntPdct")]
#[cfg_attr(feature = "serde", serde(rename = "TaxEffcntPdct"))]
pub tax_effcnt_pdct: Option<TaxEfficientProduct7>,
#[yaserde(rename = "GnlInvstmt")]
#[cfg_attr(feature = "serde", serde(rename = "GnlInvstmt"))]
pub gnl_invstmt: Option<GeneralInvestment2>,
#[yaserde(rename = "Pnsn")]
#[cfg_attr(feature = "serde", serde(rename = "Pnsn"))]
pub pnsn: Option<Pension5>,
}
impl Validate for FundPortfolio7Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct FundSettlementParameters24 {
#[yaserde(rename = "SfkpgPlc")]
#[cfg_attr(feature = "serde", serde(rename = "SfkpgPlc"))]
pub sfkpg_plc: SafekeepingPlaceFormat42Choice,
#[yaserde(rename = "TradTxCond")]
#[cfg_attr(feature = "serde", serde(rename = "TradTxCond"))]
pub trad_tx_cond: Vec<TradeTransactionCondition8Choice>,
#[yaserde(rename = "SttlmTxCond")]
#[cfg_attr(feature = "serde", serde(rename = "SttlmTxCond"))]
pub sttlm_tx_cond: Vec<SettlementTransactionCondition30Choice>,
#[yaserde(rename = "SctiesSttlmSysId")]
#[cfg_attr(feature = "serde", serde(rename = "SctiesSttlmSysId"))]
pub scties_sttlm_sys_id: Max35Text,
#[yaserde(rename = "RcvgSdDtls")]
#[cfg_attr(feature = "serde", serde(rename = "RcvgSdDtls"))]
pub rcvg_sd_dtls: SettlementParties131,
#[yaserde(rename = "DlvrgSdDtls")]
#[cfg_attr(feature = "serde", serde(rename = "DlvrgSdDtls"))]
pub dlvrg_sd_dtls: SettlementParties131,
}
impl Validate for FundSettlementParameters24 {}
#[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.013.001.12")]
pub enum GenderCode {
#[yaserde(rename = "MALE")]
#[cfg_attr(feature = "serde", serde(rename = "MALE"))]
Male,
#[yaserde(rename = "FEMA")]
#[cfg_attr(feature = "serde", serde(rename = "FEMA"))]
Fema,
__Unknown__(String),
}
impl Default for GenderCode {
fn default() -> GenderCode {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for GenderCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct GeneralInvestment2 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: GeneralInvestmentAccountType2Choice,
#[yaserde(rename = "OwnrshTp")]
#[cfg_attr(feature = "serde", serde(rename = "OwnrshTp"))]
pub ownrsh_tp: AccountOwnershipType6Code,
#[yaserde(rename = "CurInvstmtAmt")]
#[cfg_attr(feature = "serde", serde(rename = "CurInvstmtAmt"))]
pub cur_invstmt_amt: ActiveCurrencyAnd13DecimalAmount,
#[yaserde(rename = "EstmtdVal")]
#[cfg_attr(feature = "serde", serde(rename = "EstmtdVal"))]
pub estmtd_val: DateAndAmount2,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: Vec<AdditionalInformation15>,
}
impl Validate for GeneralInvestment2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct GeneralInvestmentAccountType2Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<GeneralInvestmentAccountType2Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification36>,
}
impl Validate for GeneralInvestmentAccountType2Choice {}
#[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.013.001.12")]
pub enum GeneralInvestmentAccountType2Code {
#[yaserde(rename = "ANYY")]
#[cfg_attr(feature = "serde", serde(rename = "ANYY"))]
Anyy,
#[yaserde(rename = "EQUI")]
#[cfg_attr(feature = "serde", serde(rename = "EQUI"))]
Equi,
__Unknown__(String),
}
impl Default for GeneralInvestmentAccountType2Code {
fn default() -> GeneralInvestmentAccountType2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for GeneralInvestmentAccountType2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.013.001.12")]
pub struct GenericIdentification78 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: GenericIdentification30,
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max35Text,
}
impl Validate for GenericIdentification78 {}
#[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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.013.001.12")]
pub enum HolderType1Code {
#[yaserde(rename = "TFEE")]
#[cfg_attr(feature = "serde", serde(rename = "TFEE"))]
Tfee,
#[yaserde(rename = "TFOR")]
#[cfg_attr(feature = "serde", serde(rename = "TFOR"))]
Tfor,
__Unknown__(String),
}
impl Default for HolderType1Code {
fn default() -> HolderType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for HolderType1Code {}
#[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 Isoyear (pub String);
crate::simple_type!(Isoyear);
impl Validate for Isoyear {}
#[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.013.001.12")]
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.013.001.12")]
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.013.001.12")]
pub struct IdentificationType42Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<TypeOfIdentification1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for IdentificationType42Choice {}
#[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)]
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.013.001.12")]
pub struct IndividualPerson8 {
#[yaserde(rename = "Nm")]
#[cfg_attr(feature = "serde", serde(rename = "Nm"))]
pub nm: Max35Text,
#[yaserde(rename = "GvnNm")]
#[cfg_attr(feature = "serde", serde(rename = "GvnNm"))]
pub gvn_nm: Max35Text,
#[yaserde(rename = "NmPrfx")]
#[cfg_attr(feature = "serde", serde(rename = "NmPrfx"))]
pub nm_prfx: NamePrefix1Code,
#[yaserde(rename = "NmSfx")]
#[cfg_attr(feature = "serde", serde(rename = "NmSfx"))]
pub nm_sfx: Max35Text,
#[yaserde(rename = "Gndr")]
#[cfg_attr(feature = "serde", serde(rename = "Gndr"))]
pub gndr: GenderCode,
#[yaserde(rename = "BirthDt")]
#[cfg_attr(feature = "serde", serde(rename = "BirthDt"))]
pub birth_dt: Isodate,
#[yaserde(rename = "SclSctyNb")]
#[cfg_attr(feature = "serde", serde(rename = "SclSctyNb"))]
pub scl_scty_nb: Max35Text,
#[yaserde(rename = "IndvInvstrAdr")]
#[cfg_attr(feature = "serde", serde(rename = "IndvInvstrAdr"))]
pub indv_invstr_adr: PostalAddress1,
}
impl Validate for IndividualPerson8 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct InnovativeFinance1 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: GenericIdentification36,
#[yaserde(rename = "Inf")]
#[cfg_attr(feature = "serde", serde(rename = "Inf"))]
pub inf: Max350Text,
}
impl Validate for InnovativeFinance1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct Intermediary43 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: PartyIdentification139,
#[yaserde(rename = "Acct")]
#[cfg_attr(feature = "serde", serde(rename = "Acct"))]
pub acct: Account27,
#[yaserde(rename = "Role")]
#[cfg_attr(feature = "serde", serde(rename = "Role"))]
pub role: Role4Choice,
#[yaserde(rename = "CtctPrsn")]
#[cfg_attr(feature = "serde", serde(rename = "CtctPrsn"))]
pub ctct_prsn: ContactIdentification2,
}
impl Validate for Intermediary43 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct InvestmentAccount69 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max35Text,
#[yaserde(rename = "Dsgnt")]
#[cfg_attr(feature = "serde", serde(rename = "Dsgnt"))]
pub dsgnt: Max35Text,
#[yaserde(rename = "AcctNm")]
#[cfg_attr(feature = "serde", serde(rename = "AcctNm"))]
pub acct_nm: Max35Text,
#[yaserde(rename = "Svcr")]
#[cfg_attr(feature = "serde", serde(rename = "Svcr"))]
pub svcr: PartyIdentification132,
}
impl Validate for InvestmentAccount69 {}
#[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.013.001.12")]
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.013.001.12")]
pub enum InvestmentFundRole2Code {
#[yaserde(rename = "FMCO")]
#[cfg_attr(feature = "serde", serde(rename = "FMCO"))]
Fmco,
#[yaserde(rename = "REGI")]
#[cfg_attr(feature = "serde", serde(rename = "REGI"))]
Regi,
#[yaserde(rename = "TRAG")]
#[cfg_attr(feature = "serde", serde(rename = "TRAG"))]
Trag,
#[yaserde(rename = "INTR")]
#[cfg_attr(feature = "serde", serde(rename = "INTR"))]
Intr,
#[yaserde(rename = "DIST")]
#[cfg_attr(feature = "serde", serde(rename = "DIST"))]
Dist,
#[yaserde(rename = "CONC")]
#[cfg_attr(feature = "serde", serde(rename = "CONC"))]
Conc,
#[yaserde(rename = "UCL1")]
#[cfg_attr(feature = "serde", serde(rename = "UCL1"))]
Ucl1,
#[yaserde(rename = "UCL2")]
#[cfg_attr(feature = "serde", serde(rename = "UCL2"))]
Ucl2,
#[yaserde(rename = "TRAN")]
#[cfg_attr(feature = "serde", serde(rename = "TRAN"))]
Tran,
__Unknown__(String),
}
impl Default for InvestmentFundRole2Code {
fn default() -> InvestmentFundRole2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for InvestmentFundRole2Code {}
#[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.013.001.12")]
pub struct LumpSumType1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<LumpSumType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification36>,
}
impl Validate for LumpSumType1Choice {}
#[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.013.001.12")]
pub enum LumpSumType1Code {
#[yaserde(rename = "DEAB")]
#[cfg_attr(feature = "serde", serde(rename = "DEAB"))]
Deab,
#[yaserde(rename = "PCLS")]
#[cfg_attr(feature = "serde", serde(rename = "PCLS"))]
Pcls,
#[yaserde(rename = "UFPL")]
#[cfg_attr(feature = "serde", serde(rename = "UFPL"))]
Ufpl,
__Unknown__(String),
}
impl Default for LumpSumType1Code {
fn default() -> LumpSumType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for LumpSumType1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
pub struct MoneyPurchaseAnnualAllowance1 {
#[yaserde(rename = "Trggrd")]
#[cfg_attr(feature = "serde", serde(rename = "Trggrd"))]
pub trggrd: YesNoIndicator,
#[yaserde(rename = "TrggrdDt")]
#[cfg_attr(feature = "serde", serde(rename = "TrggrdDt"))]
pub trggrd_dt: Isodate,
}
impl Validate for MoneyPurchaseAnnualAllowance1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
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.013.001.12")]
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(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.013.001.12")]
pub struct Organisation36 {
#[yaserde(rename = "Nm")]
#[cfg_attr(feature = "serde", serde(rename = "Nm"))]
pub nm: Max140Text,
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: PartyIdentification140,
#[yaserde(rename = "Purp")]
#[cfg_attr(feature = "serde", serde(rename = "Purp"))]
pub purp: Max35Text,
#[yaserde(rename = "TaxtnCtry")]
#[cfg_attr(feature = "serde", serde(rename = "TaxtnCtry"))]
pub taxtn_ctry: CountryCode,
#[yaserde(rename = "RegnCtry")]
#[cfg_attr(feature = "serde", serde(rename = "RegnCtry"))]
pub regn_ctry: CountryCode,
#[yaserde(rename = "RegnDt")]
#[cfg_attr(feature = "serde", serde(rename = "RegnDt"))]
pub regn_dt: Isodate,
#[yaserde(rename = "TaxIdNb")]
#[cfg_attr(feature = "serde", serde(rename = "TaxIdNb"))]
pub tax_id_nb: Max35Text,
#[yaserde(rename = "NtlRegnNb")]
#[cfg_attr(feature = "serde", serde(rename = "NtlRegnNb"))]
pub ntl_regn_nb: Max35Text,
#[yaserde(rename = "CorpInvstrAdr")]
#[cfg_attr(feature = "serde", serde(rename = "CorpInvstrAdr"))]
pub corp_invstr_adr: PostalAddress1,
}
impl Validate for Organisation36 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
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.013.001.12")]
pub struct OtherAmount3 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: GenericIdentification1,
#[yaserde(rename = "Amt")]
#[cfg_attr(feature = "serde", serde(rename = "Amt"))]
pub amt: ActiveCurrencyAndAmount,
}
impl Validate for OtherAmount3 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
pub struct PartyIdentification123Choice {
#[yaserde(rename = "AnyBIC")]
#[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
pub any_b_i_c: Option<AnyBICDec2014Identifier>,
#[yaserde(rename = "PrtryId")]
#[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
pub prtry_id: Option<GenericIdentification36>,
#[yaserde(rename = "NmAndAdr")]
#[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
pub nm_and_adr: Option<NameAndAddress5>,
}
impl Validate for PartyIdentification123Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
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.013.001.12")]
pub struct PartyIdentification126Choice {
#[yaserde(rename = "AnyBIC")]
#[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
pub any_b_i_c: Option<AnyBICDec2014Identifier>,
#[yaserde(rename = "PrtryId")]
#[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
pub prtry_id: Option<GenericIdentification1>,
}
impl Validate for PartyIdentification126Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
pub struct PartyIdentification140 {
#[yaserde(rename = "Pty")]
#[cfg_attr(feature = "serde", serde(rename = "Pty"))]
pub pty: PartyIdentification126Choice,
#[yaserde(rename = "LEI")]
#[cfg_attr(feature = "serde", serde(rename = "LEI"))]
pub lei: Leiidentifier,
}
impl Validate for PartyIdentification140 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct PartyIdentification257Choice {
#[yaserde(rename = "AnyBIC")]
#[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
pub any_b_i_c: Option<AnyBICDec2014Identifier>,
#[yaserde(rename = "NmAndAdr")]
#[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
pub nm_and_adr: Option<NameAndAddress5>,
#[yaserde(rename = "Ctry")]
#[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
pub ctry: Option<CountryCode>,
#[yaserde(rename = "DgtlLdgrId")]
#[cfg_attr(feature = "serde", serde(rename = "DgtlLdgrId"))]
pub dgtl_ldgr_id: Option<Dti2024Identifier>,
}
impl Validate for PartyIdentification257Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct PartyIdentification315 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: PartyIdentification257Choice,
#[yaserde(rename = "LEI")]
#[cfg_attr(feature = "serde", serde(rename = "LEI"))]
pub lei: Leiidentifier,
#[yaserde(rename = "AltrnId")]
#[cfg_attr(feature = "serde", serde(rename = "AltrnId"))]
pub altrn_id: AlternatePartyIdentification7,
#[yaserde(rename = "PrcgDt")]
#[cfg_attr(feature = "serde", serde(rename = "PrcgDt"))]
pub prcg_dt: DateAndDateTime2Choice,
#[yaserde(rename = "PrcgId")]
#[cfg_attr(feature = "serde", serde(rename = "PrcgId"))]
pub prcg_id: Max35Text,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: PartyTextInformation1,
}
impl Validate for PartyIdentification315 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct PartyIdentificationAndAccount194 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: PartyIdentification123Choice,
#[yaserde(rename = "LEI")]
#[cfg_attr(feature = "serde", serde(rename = "LEI"))]
pub lei: Leiidentifier,
#[yaserde(rename = "AltrnId")]
#[cfg_attr(feature = "serde", serde(rename = "AltrnId"))]
pub altrn_id: AlternatePartyIdentification7,
#[yaserde(rename = "SfkpgAcct")]
#[cfg_attr(feature = "serde", serde(rename = "SfkpgAcct"))]
pub sfkpg_acct: SecuritiesAccount19,
#[yaserde(rename = "PrcgDt")]
#[cfg_attr(feature = "serde", serde(rename = "PrcgDt"))]
pub prcg_dt: DateAndDateTime2Choice,
#[yaserde(rename = "PrcgId")]
#[cfg_attr(feature = "serde", serde(rename = "PrcgId"))]
pub prcg_id: Max35Text,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: PartyTextInformation6,
}
impl Validate for PartyIdentificationAndAccount194 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct PartyTextInformation1 {
#[yaserde(rename = "DclrtnDtls")]
#[cfg_attr(feature = "serde", serde(rename = "DclrtnDtls"))]
pub dclrtn_dtls: Max350Text,
#[yaserde(rename = "PtyCtctDtls")]
#[cfg_attr(feature = "serde", serde(rename = "PtyCtctDtls"))]
pub pty_ctct_dtls: Max140Text,
#[yaserde(rename = "RegnDtls")]
#[cfg_attr(feature = "serde", serde(rename = "RegnDtls"))]
pub regn_dtls: Max350Text,
}
impl Validate for PartyTextInformation1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.013.001.12")]
pub struct PartyTextInformation6 {
#[yaserde(rename = "DclrtnDtls")]
#[cfg_attr(feature = "serde", serde(rename = "DclrtnDtls"))]
pub dclrtn_dtls: Max350Text,
#[yaserde(rename = "PtyCtctDtls")]
#[cfg_attr(feature = "serde", serde(rename = "PtyCtctDtls"))]
pub pty_ctct_dtls: Max140Text,
#[yaserde(rename = "RegnDtls")]
#[cfg_attr(feature = "serde", serde(rename = "RegnDtls"))]
pub regn_dtls: Max350Text,
#[yaserde(rename = "RegnAdr")]
#[cfg_attr(feature = "serde", serde(rename = "RegnAdr"))]
pub regn_adr: PostalAddress1,
}
impl Validate for PartyTextInformation6 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct PaymentInstrument22 {
#[yaserde(rename = "Ref")]
#[cfg_attr(feature = "serde", serde(rename = "Ref"))]
pub _ref: Max35Text,
#[yaserde(rename = "CdtTrfDtls")]
#[cfg_attr(feature = "serde", serde(rename = "CdtTrfDtls"))]
pub cdt_trf_dtls: CreditTransfer13,
}
impl Validate for PaymentInstrument22 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct Pension5 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: PensionPolicy1,
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: PensionSchemeType3Choice,
#[yaserde(rename = "TrfScp")]
#[cfg_attr(feature = "serde", serde(rename = "TrfScp"))]
pub trf_scp: PensionTransferScope1Choice,
#[yaserde(rename = "TaxRef")]
#[cfg_attr(feature = "serde", serde(rename = "TaxRef"))]
pub tax_ref: Vec<TaxReference1>,
#[yaserde(rename = "DrwdwnTrchId")]
#[cfg_attr(feature = "serde", serde(rename = "DrwdwnTrchId"))]
pub drwdwn_trch_id: Max35Text,
#[yaserde(rename = "DrwdwnSts")]
#[cfg_attr(feature = "serde", serde(rename = "DrwdwnSts"))]
pub drwdwn_sts: DrawdownStatus1Choice,
#[yaserde(rename = "DrwdwnTp")]
#[cfg_attr(feature = "serde", serde(rename = "DrwdwnTp"))]
pub drwdwn_tp: DrawdownType2Choice,
#[yaserde(rename = "NbOfDrwdwnTrnchs")]
#[cfg_attr(feature = "serde", serde(rename = "NbOfDrwdwnTrnchs"))]
pub nb_of_drwdwn_trnchs: Number,
#[yaserde(rename = "EstmtdVal")]
#[cfg_attr(feature = "serde", serde(rename = "EstmtdVal"))]
pub estmtd_val: DateAndAmount2,
#[yaserde(rename = "BlckTrf")]
#[cfg_attr(feature = "serde", serde(rename = "BlckTrf"))]
pub blck_trf: YesNoIndicator,
#[yaserde(rename = "BlckTrfRef")]
#[cfg_attr(feature = "serde", serde(rename = "BlckTrfRef"))]
pub blck_trf_ref: Max35Text,
#[yaserde(rename = "TaxFreeCshPrtcn")]
#[cfg_attr(feature = "serde", serde(rename = "TaxFreeCshPrtcn"))]
pub tax_free_csh_prtcn: YesNoIndicator,
#[yaserde(rename = "TaxFreeCshAmt")]
#[cfg_attr(feature = "serde", serde(rename = "TaxFreeCshAmt"))]
pub tax_free_csh_amt: DateAndAmount2,
#[yaserde(rename = "ValOfPnsnPlcyOrPlanOrSchme")]
#[cfg_attr(feature = "serde", serde(rename = "ValOfPnsnPlcyOrPlanOrSchme"))]
pub val_of_pnsn_plcy_or_plan_or_schme: DateAndAmount2,
#[yaserde(rename = "RtrmntAgePrtcn")]
#[cfg_attr(feature = "serde", serde(rename = "RtrmntAgePrtcn"))]
pub rtrmnt_age_prtcn: YesNoIndicator,
#[yaserde(rename = "RtrmntAge")]
#[cfg_attr(feature = "serde", serde(rename = "RtrmntAge"))]
pub rtrmnt_age: DecimalNumber,
#[yaserde(rename = "Shrg")]
#[cfg_attr(feature = "serde", serde(rename = "Shrg"))]
pub shrg: YesNoIndicator,
#[yaserde(rename = "LumpSumTp")]
#[cfg_attr(feature = "serde", serde(rename = "LumpSumTp"))]
pub lump_sum_tp: Vec<LumpSumType1Choice>,
#[yaserde(rename = "PnsnOrdr")]
#[cfg_attr(feature = "serde", serde(rename = "PnsnOrdr"))]
pub pnsn_ordr: Vec<PensionOrder1>,
#[yaserde(rename = "RingFncdDrwdwnAssts")]
#[cfg_attr(feature = "serde", serde(rename = "RingFncdDrwdwnAssts"))]
pub ring_fncd_drwdwn_assts: YesNoIndicator,
#[yaserde(rename = "MnyPurchsAnlAllwnc")]
#[cfg_attr(feature = "serde", serde(rename = "MnyPurchsAnlAllwnc"))]
pub mny_purchs_anl_allwnc: MoneyPurchaseAnnualAllowance1,
#[yaserde(rename = "SfgrdBnft")]
#[cfg_attr(feature = "serde", serde(rename = "SfgrdBnft"))]
pub sfgrd_bnft: YesNoIndicator,
#[yaserde(rename = "NonSfgrddGrntedBnfts")]
#[cfg_attr(feature = "serde", serde(rename = "NonSfgrddGrntedBnfts"))]
pub non_sfgrdd_grnted_bnfts: YesNoIndicator,
#[yaserde(rename = "LftmAllwncPrtcn")]
#[cfg_attr(feature = "serde", serde(rename = "LftmAllwncPrtcn"))]
pub lftm_allwnc_prtcn: YesNoIndicator,
#[yaserde(rename = "ClntLftmAllwncPrtcn")]
#[cfg_attr(feature = "serde", serde(rename = "ClntLftmAllwncPrtcn"))]
pub clnt_lftm_allwnc_prtcn: YesNoIndicator,
#[yaserde(rename = "BnftCrstllstnEvtOcrd")]
#[cfg_attr(feature = "serde", serde(rename = "BnftCrstllstnEvtOcrd"))]
pub bnft_crstllstn_evt_ocrd: YesNoIndicator,
#[yaserde(rename = "NonWrpprTrf")]
#[cfg_attr(feature = "serde", serde(rename = "NonWrpprTrf"))]
pub non_wrppr_trf: YesNoIndicator,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: Vec<AdditionalInformation15>,
}
impl Validate for Pension5 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct PensionOrder1 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: PensionOrderType1Choice,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: Vec<AdditionalInformation15>,
}
impl Validate for PensionOrder1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct PensionOrderType1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<PensionOrderType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification36>,
}
impl Validate for PensionOrderType1Choice {}
#[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.013.001.12")]
pub enum PensionOrderType1Code {
#[yaserde(rename = "EARM")]
#[cfg_attr(feature = "serde", serde(rename = "EARM"))]
Earm,
#[yaserde(rename = "SHAR")]
#[cfg_attr(feature = "serde", serde(rename = "SHAR"))]
Shar,
__Unknown__(String),
}
impl Default for PensionOrderType1Code {
fn default() -> PensionOrderType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for PensionOrderType1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct PensionPolicy1 {
#[yaserde(rename = "Idr")]
#[cfg_attr(feature = "serde", serde(rename = "Idr"))]
pub idr: Max35Text,
#[yaserde(rename = "SubIdr")]
#[cfg_attr(feature = "serde", serde(rename = "SubIdr"))]
pub sub_idr: Max35Text,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: AdditionalInformation15,
}
impl Validate for PensionPolicy1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct PensionSchemeType3Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<PensionSchemeType3Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification36>,
}
impl Validate for PensionSchemeType3Choice {}
#[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.013.001.12")]
pub enum PensionSchemeType3Code {
#[yaserde(rename = "AAVC")]
#[cfg_attr(feature = "serde", serde(rename = "AAVC"))]
Aavc,
#[yaserde(rename = "DBEN")]
#[cfg_attr(feature = "serde", serde(rename = "DBEN"))]
Dben,
#[yaserde(rename = "EXPP")]
#[cfg_attr(feature = "serde", serde(rename = "EXPP"))]
Expp,
#[yaserde(rename = "FAVC")]
#[cfg_attr(feature = "serde", serde(rename = "FAVC"))]
Favc,
#[yaserde(rename = "GPPS")]
#[cfg_attr(feature = "serde", serde(rename = "GPPS"))]
Gpps,
#[yaserde(rename = "SIPG")]
#[cfg_attr(feature = "serde", serde(rename = "SIPG"))]
Sipg,
#[yaserde(rename = "STKG")]
#[cfg_attr(feature = "serde", serde(rename = "STKG"))]
Stkg,
#[yaserde(rename = "IPST")]
#[cfg_attr(feature = "serde", serde(rename = "IPST"))]
Ipst,
#[yaserde(rename = "STKI")]
#[cfg_attr(feature = "serde", serde(rename = "STKI"))]
Stki,
#[yaserde(rename = "OTPM")]
#[cfg_attr(feature = "serde", serde(rename = "OTPM"))]
Otpm,
#[yaserde(rename = "OCDC")]
#[cfg_attr(feature = "serde", serde(rename = "OCDC"))]
Ocdc,
#[yaserde(rename = "PPNS")]
#[cfg_attr(feature = "serde", serde(rename = "PPNS"))]
Ppns,
#[yaserde(rename = "EPKA")]
#[cfg_attr(feature = "serde", serde(rename = "EPKA"))]
Epka,
#[yaserde(rename = "ITPO")]
#[cfg_attr(feature = "serde", serde(rename = "ITPO"))]
Itpo,
#[yaserde(rename = "REAN")]
#[cfg_attr(feature = "serde", serde(rename = "REAN"))]
Rean,
#[yaserde(rename = "SC32")]
#[cfg_attr(feature = "serde", serde(rename = "SC32"))]
Sc32,
S32A,
#[yaserde(rename = "SIPP")]
#[cfg_attr(feature = "serde", serde(rename = "SIPP"))]
Sipp,
#[yaserde(rename = "SSAS")]
#[cfg_attr(feature = "serde", serde(rename = "SSAS"))]
Ssas,
#[yaserde(rename = "NWRP")]
#[cfg_attr(feature = "serde", serde(rename = "NWRP"))]
Nwrp,
__Unknown__(String),
}
impl Default for PensionSchemeType3Code {
fn default() -> PensionSchemeType3Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for PensionSchemeType3Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct PensionTransferScope1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<PensionTransferScope1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification36>,
}
impl Validate for PensionTransferScope1Choice {}
#[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.013.001.12")]
pub enum PensionTransferScope1Code {
#[yaserde(rename = "CRYS")]
#[cfg_attr(feature = "serde", serde(rename = "CRYS"))]
Crys,
#[yaserde(rename = "SDDT")]
#[cfg_attr(feature = "serde", serde(rename = "SDDT"))]
Sddt,
#[yaserde(rename = "FULP")]
#[cfg_attr(feature = "serde", serde(rename = "FULP"))]
Fulp,
#[yaserde(rename = "UCRY")]
#[cfg_attr(feature = "serde", serde(rename = "UCRY"))]
Ucry,
__Unknown__(String),
}
impl Default for PensionTransferScope1Code {
fn default() -> PensionTransferScope1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for PensionTransferScope1Code {}
#[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.013.001.12")]
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.013.001.12")]
pub struct PortfolioTransfer15 {
#[yaserde(rename = "MstrRef")]
#[cfg_attr(feature = "serde", serde(rename = "MstrRef"))]
pub mstr_ref: Max35Text,
#[yaserde(rename = "TrfInstrRef")]
#[cfg_attr(feature = "serde", serde(rename = "TrfInstrRef"))]
pub trf_instr_ref: Max35Text,
#[yaserde(rename = "TrfConfId")]
#[cfg_attr(feature = "serde", serde(rename = "TrfConfId"))]
pub trf_conf_id: Max35Text,
#[yaserde(rename = "ActlTrfDt")]
#[cfg_attr(feature = "serde", serde(rename = "ActlTrfDt"))]
pub actl_trf_dt: Isodate,
#[yaserde(rename = "Prtfl")]
#[cfg_attr(feature = "serde", serde(rename = "Prtfl"))]
pub prtfl: FundPortfolio7Choice,
#[yaserde(rename = "AllOthrCsh")]
#[cfg_attr(feature = "serde", serde(rename = "AllOthrCsh"))]
pub all_othr_csh: Vec<AllOtherCash1>,
#[yaserde(rename = "CshAll")]
#[cfg_attr(feature = "serde", serde(rename = "CshAll"))]
pub csh_all: Vec<CashAll1>,
#[yaserde(rename = "RsdlCsh")]
#[cfg_attr(feature = "serde", serde(rename = "RsdlCsh"))]
pub rsdl_csh: Vec<ResidualCash2>,
#[yaserde(rename = "TaxDt")]
#[cfg_attr(feature = "serde", serde(rename = "TaxDt"))]
pub tax_dt: Isodate,
#[yaserde(rename = "PmtDtls")]
#[cfg_attr(feature = "serde", serde(rename = "PmtDtls"))]
pub pmt_dtls: PaymentInstrument22,
#[yaserde(rename = "FinInstrmAsstForTrf")]
#[cfg_attr(feature = "serde", serde(rename = "FinInstrmAsstForTrf"))]
pub fin_instrm_asst_for_trf: Vec<FinancialInstrument109>,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: Vec<AdditionalInformation15>,
}
impl Validate for PortfolioTransfer15 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct PortfolioTransferConfirmationV12 {
#[yaserde(rename = "MsgRef")]
#[cfg_attr(feature = "serde", serde(rename = "MsgRef"))]
pub msg_ref: MessageIdentification1,
#[yaserde(rename = "PoolRef")]
#[cfg_attr(feature = "serde", serde(rename = "PoolRef"))]
pub pool_ref: AdditionalReference11,
#[yaserde(rename = "PrvsRef")]
#[cfg_attr(feature = "serde", serde(rename = "PrvsRef"))]
pub prvs_ref: AdditionalReference10,
#[yaserde(rename = "RltdRef")]
#[cfg_attr(feature = "serde", serde(rename = "RltdRef"))]
pub rltd_ref: AdditionalReference10,
#[yaserde(rename = "PmryIndvInvstr")]
#[cfg_attr(feature = "serde", serde(rename = "PmryIndvInvstr"))]
pub pmry_indv_invstr: IndividualPerson8,
#[yaserde(rename = "RegdHldr")]
#[cfg_attr(feature = "serde", serde(rename = "RegdHldr"))]
pub regd_hldr: IndividualPerson8,
#[yaserde(rename = "ScndryIndvInvstr")]
#[cfg_attr(feature = "serde", serde(rename = "ScndryIndvInvstr"))]
pub scndry_indv_invstr: IndividualPerson8,
#[yaserde(rename = "OthrIndvInvstr")]
#[cfg_attr(feature = "serde", serde(rename = "OthrIndvInvstr"))]
pub othr_indv_invstr: Vec<IndividualPerson8>,
#[yaserde(rename = "PmryCorpInvstr")]
#[cfg_attr(feature = "serde", serde(rename = "PmryCorpInvstr"))]
pub pmry_corp_invstr: Organisation36,
#[yaserde(rename = "ScndryCorpInvstr")]
#[cfg_attr(feature = "serde", serde(rename = "ScndryCorpInvstr"))]
pub scndry_corp_invstr: Organisation36,
#[yaserde(rename = "OthrCorpInvstr")]
#[cfg_attr(feature = "serde", serde(rename = "OthrCorpInvstr"))]
pub othr_corp_invstr: Vec<Organisation36>,
#[yaserde(rename = "TrfrAcct")]
#[cfg_attr(feature = "serde", serde(rename = "TrfrAcct"))]
pub trfr_acct: InvestmentAccount69,
#[yaserde(rename = "NmneeAcct")]
#[cfg_attr(feature = "serde", serde(rename = "NmneeAcct"))]
pub nmnee_acct: InvestmentAccount69,
#[yaserde(rename = "Trfee")]
#[cfg_attr(feature = "serde", serde(rename = "Trfee"))]
pub trfee: PartyIdentification132,
#[yaserde(rename = "PdctTrf")]
#[cfg_attr(feature = "serde", serde(rename = "PdctTrf"))]
pub pdct_trf: Vec<PortfolioTransfer15>,
#[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 PortfolioTransferConfirmationV12 {}
#[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.013.001.12")]
pub enum PortfolioWithdrawalReason1Code {
#[yaserde(rename = "FTRS")]
#[cfg_attr(feature = "serde", serde(rename = "FTRS"))]
Ftrs,
__Unknown__(String),
}
impl Default for PortfolioWithdrawalReason1Code {
fn default() -> PortfolioWithdrawalReason1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for PortfolioWithdrawalReason1Code {}
#[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.013.001.12")]
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.013.001.12")]
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(Default, Clone, PartialEq, Debug)]
pub struct PreviousAll (pub String);
crate::simple_type!(PreviousAll);
impl Validate for PreviousAll {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct PreviousYear1Choice {
#[yaserde(rename = "AllPrvsYrs")]
#[cfg_attr(feature = "serde", serde(rename = "AllPrvsYrs"))]
pub all_prvs_yrs: Option<PreviousAll>,
#[yaserde(rename = "SpcfcPrvsYrs")]
#[cfg_attr(feature = "serde", serde(rename = "SpcfcPrvsYrs"))]
pub spcfc_prvs_yrs: Vec<Isoyear>,
}
impl Validate for PreviousYear1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct PreviousYear4 {
#[yaserde(rename = "PrvsYrs")]
#[cfg_attr(feature = "serde", serde(rename = "PrvsYrs"))]
pub prvs_yrs: PreviousYear1Choice,
#[yaserde(rename = "CshCmpntInd")]
#[cfg_attr(feature = "serde", serde(rename = "CshCmpntInd"))]
pub csh_cmpnt_ind: YesNoIndicator,
}
impl Validate for PreviousYear4 {}
#[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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.013.001.12")]
pub struct Quantity53 {
#[yaserde(rename = "Unit")]
#[cfg_attr(feature = "serde", serde(rename = "Unit"))]
pub unit: Unit1Choice,
#[yaserde(rename = "PctgRate")]
#[cfg_attr(feature = "serde", serde(rename = "PctgRate"))]
pub pctg_rate: PercentageRate,
#[yaserde(rename = "FaceAmt")]
#[cfg_attr(feature = "serde", serde(rename = "FaceAmt"))]
pub face_amt: ImpliedCurrencyAndAmount,
#[yaserde(rename = "AmtsdVal")]
#[cfg_attr(feature = "serde", serde(rename = "AmtsdVal"))]
pub amtsd_val: ImpliedCurrencyAndAmount,
#[yaserde(rename = "CshAmt")]
#[cfg_attr(feature = "serde", serde(rename = "CshAmt"))]
pub csh_amt: ActiveCurrencyAnd13DecimalAmount,
#[yaserde(rename = "OthrAsst")]
#[cfg_attr(feature = "serde", serde(rename = "OthrAsst"))]
pub othr_asst: Max35Text,
}
impl Validate for Quantity53 {}
#[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.013.001.12")]
pub struct ResidualCash2 {
#[yaserde(rename = "Ind")]
#[cfg_attr(feature = "serde", serde(rename = "Ind"))]
pub ind: YesNoIndicator,
#[yaserde(rename = "Ccy")]
#[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
pub ccy: ActiveCurrencyCode,
}
impl Validate for ResidualCash2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct Role4Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<InvestmentFundRole2Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification47>,
}
impl Validate for Role4Choice {}
#[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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.013.001.12")]
pub enum SafekeepingPlace1Code {
#[yaserde(rename = "CUST")]
#[cfg_attr(feature = "serde", serde(rename = "CUST"))]
Cust,
#[yaserde(rename = "ICSD")]
#[cfg_attr(feature = "serde", serde(rename = "ICSD"))]
Icsd,
#[yaserde(rename = "NCSD")]
#[cfg_attr(feature = "serde", serde(rename = "NCSD"))]
Ncsd,
#[yaserde(rename = "SHHE")]
#[cfg_attr(feature = "serde", serde(rename = "SHHE"))]
Shhe,
__Unknown__(String),
}
impl Default for SafekeepingPlace1Code {
fn default() -> SafekeepingPlace1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for SafekeepingPlace1Code {}
#[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.013.001.12")]
pub enum SafekeepingPlace2Code {
#[yaserde(rename = "SHHE")]
#[cfg_attr(feature = "serde", serde(rename = "SHHE"))]
Shhe,
#[yaserde(rename = "ALLP")]
#[cfg_attr(feature = "serde", serde(rename = "ALLP"))]
Allp,
__Unknown__(String),
}
impl Default for SafekeepingPlace2Code {
fn default() -> SafekeepingPlace2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for SafekeepingPlace2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct SafekeepingPlaceFormat42Choice {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Option<SafekeepingPlaceTypeAndText6>,
#[yaserde(rename = "Ctry")]
#[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
pub ctry: Option<CountryCode>,
#[yaserde(rename = "DgtlLdgrId")]
#[cfg_attr(feature = "serde", serde(rename = "DgtlLdgrId"))]
pub dgtl_ldgr_id: Option<Dti2024Identifier>,
#[yaserde(rename = "TpAndId")]
#[cfg_attr(feature = "serde", serde(rename = "TpAndId"))]
pub tp_and_id: Option<SafekeepingPlaceTypeAndIdentification1>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification78>,
}
impl Validate for SafekeepingPlaceFormat42Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct SafekeepingPlaceTypeAndIdentification1 {
#[yaserde(rename = "SfkpgPlcTp")]
#[cfg_attr(feature = "serde", serde(rename = "SfkpgPlcTp"))]
pub sfkpg_plc_tp: SafekeepingPlace1Code,
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: AnyBICDec2014Identifier,
}
impl Validate for SafekeepingPlaceTypeAndIdentification1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct SafekeepingPlaceTypeAndText6 {
#[yaserde(rename = "SfkpgPlcTp")]
#[cfg_attr(feature = "serde", serde(rename = "SfkpgPlcTp"))]
pub sfkpg_plc_tp: SafekeepingPlace2Code,
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max35Text,
}
impl Validate for SafekeepingPlaceTypeAndText6 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct SecuritiesAccount19 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max35Text,
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: GenericIdentification30,
#[yaserde(rename = "Nm")]
#[cfg_attr(feature = "serde", serde(rename = "Nm"))]
pub nm: Max70Text,
}
impl Validate for SecuritiesAccount19 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
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.013.001.12")]
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.013.001.12")]
pub struct SettlementParties131 {
#[yaserde(rename = "Dpstry")]
#[cfg_attr(feature = "serde", serde(rename = "Dpstry"))]
pub dpstry: PartyIdentification315,
#[yaserde(rename = "Pty1")]
#[cfg_attr(feature = "serde", serde(rename = "Pty1"))]
pub pty_1: PartyIdentificationAndAccount194,
#[yaserde(rename = "Pty2")]
#[cfg_attr(feature = "serde", serde(rename = "Pty2"))]
pub pty_2: PartyIdentificationAndAccount194,
#[yaserde(rename = "Pty3")]
#[cfg_attr(feature = "serde", serde(rename = "Pty3"))]
pub pty_3: PartyIdentificationAndAccount194,
#[yaserde(rename = "Pty4")]
#[cfg_attr(feature = "serde", serde(rename = "Pty4"))]
pub pty_4: PartyIdentificationAndAccount194,
#[yaserde(rename = "Pty5")]
#[cfg_attr(feature = "serde", serde(rename = "Pty5"))]
pub pty_5: PartyIdentificationAndAccount194,
}
impl Validate for SettlementParties131 {}
#[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.013.001.12")]
pub enum SettlementTransactionCondition11Code {
#[yaserde(rename = "NOMC")]
#[cfg_attr(feature = "serde", serde(rename = "NOMC"))]
Nomc,
__Unknown__(String),
}
impl Default for SettlementTransactionCondition11Code {
fn default() -> SettlementTransactionCondition11Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for SettlementTransactionCondition11Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct SettlementTransactionCondition30Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<SettlementTransactionCondition11Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for SettlementTransactionCondition30Choice {}
#[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.013.001.12")]
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.013.001.12")]
pub struct SubscriptionInformation2 {
#[yaserde(rename = "DtOfFrstSbcpt")]
#[cfg_attr(feature = "serde", serde(rename = "DtOfFrstSbcpt"))]
pub dt_of_frst_sbcpt: Isodate,
#[yaserde(rename = "EqtyCmpnt")]
#[cfg_attr(feature = "serde", serde(rename = "EqtyCmpnt"))]
pub eqty_cmpnt: ActiveCurrencyAnd13DecimalAmount,
#[yaserde(rename = "CshCmpnt")]
#[cfg_attr(feature = "serde", serde(rename = "CshCmpnt"))]
pub csh_cmpnt: ActiveCurrencyAnd13DecimalAmount,
#[yaserde(rename = "TtlAmtYrToDt")]
#[cfg_attr(feature = "serde", serde(rename = "TtlAmtYrToDt"))]
pub ttl_amt_yr_to_dt: ActiveCurrencyAnd13DecimalAmount,
}
impl Validate for SubscriptionInformation2 {}
#[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.013.001.12")]
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.013.001.12")]
pub struct Tax36 {
#[yaserde(rename = "DtOrPrd")]
#[cfg_attr(feature = "serde", serde(rename = "DtOrPrd"))]
pub dt_or_prd: DateQuarter1Choice,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: Vec<AdditionalInformation15>,
}
impl Validate for Tax36 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
pub struct TaxEfficientProduct7 {
#[yaserde(rename = "TaxEffcntPdctTp")]
#[cfg_attr(feature = "serde", serde(rename = "TaxEffcntPdctTp"))]
pub tax_effcnt_pdct_tp: TaxEfficientProductType2Choice,
#[yaserde(rename = "CurYr")]
#[cfg_attr(feature = "serde", serde(rename = "CurYr"))]
pub cur_yr: YesNoIndicator,
#[yaserde(rename = "CshCmpntInd")]
#[cfg_attr(feature = "serde", serde(rename = "CshCmpntInd"))]
pub csh_cmpnt_ind: YesNoIndicator,
#[yaserde(rename = "PrvsYrs")]
#[cfg_attr(feature = "serde", serde(rename = "PrvsYrs"))]
pub prvs_yrs: PreviousYear4,
#[yaserde(rename = "PrvsYrSbcptAmt")]
#[cfg_attr(feature = "serde", serde(rename = "PrvsYrSbcptAmt"))]
pub prvs_yr_sbcpt_amt: ActiveCurrencyAnd13DecimalAmount,
#[yaserde(rename = "PrvsYrsSbcptAmt")]
#[cfg_attr(feature = "serde", serde(rename = "PrvsYrsSbcptAmt"))]
pub prvs_yrs_sbcpt_amt: ActiveCurrencyAnd13DecimalAmount,
#[yaserde(rename = "DtOfFrstSbcpt")]
#[cfg_attr(feature = "serde", serde(rename = "DtOfFrstSbcpt"))]
pub dt_of_frst_sbcpt: Isodate,
#[yaserde(rename = "CurYrSbcptDtls")]
#[cfg_attr(feature = "serde", serde(rename = "CurYrSbcptDtls"))]
pub cur_yr_sbcpt_dtls: SubscriptionInformation2,
#[yaserde(rename = "BnsOrWdrwl")]
#[cfg_attr(feature = "serde", serde(rename = "BnsOrWdrwl"))]
pub bns_or_wdrwl: Vec<BonusWithdrawal2>,
#[yaserde(rename = "WdrwlForResdtlPurchsPrgrs")]
#[cfg_attr(feature = "serde", serde(rename = "WdrwlForResdtlPurchsPrgrs"))]
pub wdrwl_for_resdtl_purchs_prgrs: YesNoIndicator,
#[yaserde(rename = "TrfrAltrnId")]
#[cfg_attr(feature = "serde", serde(rename = "TrfrAltrnId"))]
pub trfr_altrn_id: Max35Text,
#[yaserde(rename = "TtlSbcptAmt")]
#[cfg_attr(feature = "serde", serde(rename = "TtlSbcptAmt"))]
pub ttl_sbcpt_amt: ActiveCurrencyAndAmount,
#[yaserde(rename = "OthrAmt")]
#[cfg_attr(feature = "serde", serde(rename = "OthrAmt"))]
pub othr_amt: Vec<OtherAmount3>,
#[yaserde(rename = "DtFrstQlfygAddtn")]
#[cfg_attr(feature = "serde", serde(rename = "DtFrstQlfygAddtn"))]
pub dt_frst_qlfyg_addtn: Isodate,
#[yaserde(rename = "InvstrTaxRef")]
#[cfg_attr(feature = "serde", serde(rename = "InvstrTaxRef"))]
pub invstr_tax_ref: TaxReference2,
#[yaserde(rename = "InvstmtsToFllwVal")]
#[cfg_attr(feature = "serde", serde(rename = "InvstmtsToFllwVal"))]
pub invstmts_to_fllw_val: Vec<DateAndAmount2>,
#[yaserde(rename = "InnvtvFinc")]
#[cfg_attr(feature = "serde", serde(rename = "InnvtvFinc"))]
pub innvtv_finc: Vec<InnovativeFinance1>,
#[yaserde(rename = "LwstInvstdAmtCurYr")]
#[cfg_attr(feature = "serde", serde(rename = "LwstInvstdAmtCurYr"))]
pub lwst_invstd_amt_cur_yr: ActiveCurrencyAnd13DecimalAmount,
#[yaserde(rename = "TaxClctnBase")]
#[cfg_attr(feature = "serde", serde(rename = "TaxClctnBase"))]
pub tax_clctn_base: ActiveCurrencyAnd13DecimalAmount,
#[yaserde(rename = "UusdTaxDdctn")]
#[cfg_attr(feature = "serde", serde(rename = "UusdTaxDdctn"))]
pub uusd_tax_ddctn: ActiveCurrencyAnd13DecimalAmount,
#[yaserde(rename = "CurInvstmtAmt")]
#[cfg_attr(feature = "serde", serde(rename = "CurInvstmtAmt"))]
pub cur_invstmt_amt: ActiveCurrencyAnd13DecimalAmount,
#[yaserde(rename = "EstmtdVal")]
#[cfg_attr(feature = "serde", serde(rename = "EstmtdVal"))]
pub estmtd_val: DateAndAmount2,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: Vec<AdditionalInformation15>,
}
impl Validate for TaxEfficientProduct7 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct TaxEfficientProductType2Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<TaxEfficientProductType2Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification36>,
}
impl Validate for TaxEfficientProductType2Choice {}
#[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.013.001.12")]
pub enum TaxEfficientProductType2Code {
#[yaserde(rename = "CASH")]
#[cfg_attr(feature = "serde", serde(rename = "CASH"))]
Cash,
#[yaserde(rename = "CLIS")]
#[cfg_attr(feature = "serde", serde(rename = "CLIS"))]
Clis,
#[yaserde(rename = "FISA")]
#[cfg_attr(feature = "serde", serde(rename = "FISA"))]
Fisa,
#[yaserde(rename = "GISK")]
#[cfg_attr(feature = "serde", serde(rename = "GISK"))]
Gisk,
#[yaserde(rename = "GASK")]
#[cfg_attr(feature = "serde", serde(rename = "GASK"))]
Gask,
#[yaserde(rename = "HISA")]
#[cfg_attr(feature = "serde", serde(rename = "HISA"))]
Hisa,
#[yaserde(rename = "INNF")]
#[cfg_attr(feature = "serde", serde(rename = "INNF"))]
Innf,
#[yaserde(rename = "JCSH")]
#[cfg_attr(feature = "serde", serde(rename = "JCSH"))]
Jcsh,
#[yaserde(rename = "JISA")]
#[cfg_attr(feature = "serde", serde(rename = "JISA"))]
Jisa,
#[yaserde(rename = "LISA")]
#[cfg_attr(feature = "serde", serde(rename = "LISA"))]
Lisa,
#[yaserde(rename = "CCTF")]
#[cfg_attr(feature = "serde", serde(rename = "CCTF"))]
Cctf,
#[yaserde(rename = "SCTF")]
#[cfg_attr(feature = "serde", serde(rename = "SCTF"))]
Sctf,
#[yaserde(rename = "EQUI")]
#[cfg_attr(feature = "serde", serde(rename = "EQUI"))]
Equi,
__Unknown__(String),
}
impl Default for TaxEfficientProductType2Code {
fn default() -> TaxEfficientProductType2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for TaxEfficientProductType2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct TaxReference1 {
#[yaserde(rename = "TaxTp")]
#[cfg_attr(feature = "serde", serde(rename = "TaxTp"))]
pub tax_tp: TaxReferenceType1Choice,
#[yaserde(rename = "Ref")]
#[cfg_attr(feature = "serde", serde(rename = "Ref"))]
pub _ref: Max35Text,
#[yaserde(rename = "HldrTp")]
#[cfg_attr(feature = "serde", serde(rename = "HldrTp"))]
pub hldr_tp: TaxReferenceParty1Choice,
}
impl Validate for TaxReference1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
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.013.001.12")]
pub struct TaxReferenceParty1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<HolderType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification36>,
}
impl Validate for TaxReferenceParty1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.013.001.12")]
pub enum TaxWrapperAmountType1Code {
#[yaserde(rename = "BONU")]
#[cfg_attr(feature = "serde", serde(rename = "BONU"))]
Bonu,
#[yaserde(rename = "WTHD")]
#[cfg_attr(feature = "serde", serde(rename = "WTHD"))]
Wthd,
__Unknown__(String),
}
impl Default for TaxWrapperAmountType1Code {
fn default() -> TaxWrapperAmountType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for TaxWrapperAmountType1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.013.001.12")]
pub enum TradeTransactionCondition5Code {
#[yaserde(rename = "XCPN")]
#[cfg_attr(feature = "serde", serde(rename = "XCPN"))]
Xcpn,
#[yaserde(rename = "CCPN")]
#[cfg_attr(feature = "serde", serde(rename = "CCPN"))]
Ccpn,
__Unknown__(String),
}
impl Default for TradeTransactionCondition5Code {
fn default() -> TradeTransactionCondition5Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for TradeTransactionCondition5Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct TradeTransactionCondition8Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<TradeTransactionCondition5Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for TradeTransactionCondition8Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct TransferType2Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<TransferType4Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification36>,
}
impl Validate for TransferType2Choice {}
#[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.013.001.12")]
pub enum TransferType4Code {
#[yaserde(rename = "CASH")]
#[cfg_attr(feature = "serde", serde(rename = "CASH"))]
Cash,
#[yaserde(rename = "CONV")]
#[cfg_attr(feature = "serde", serde(rename = "CONV"))]
Conv,
#[yaserde(rename = "EXCL")]
#[cfg_attr(feature = "serde", serde(rename = "EXCL"))]
Excl,
#[yaserde(rename = "SECU")]
#[cfg_attr(feature = "serde", serde(rename = "SECU"))]
Secu,
__Unknown__(String),
}
impl Default for TransferType4Code {
fn default() -> TransferType4Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for TransferType4Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.013.001.12")]
pub struct TypeOfAmount1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<TaxWrapperAmountType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification36>,
}
impl Validate for TypeOfAmount1Choice {}
#[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.013.001.12")]
pub enum TypeOfIdentification1Code {
#[yaserde(rename = "ARNU")]
#[cfg_attr(feature = "serde", serde(rename = "ARNU"))]
Arnu,
#[yaserde(rename = "CCPT")]
#[cfg_attr(feature = "serde", serde(rename = "CCPT"))]
Ccpt,
#[yaserde(rename = "CHTY")]
#[cfg_attr(feature = "serde", serde(rename = "CHTY"))]
Chty,
#[yaserde(rename = "CORP")]
#[cfg_attr(feature = "serde", serde(rename = "CORP"))]
Corp,
#[yaserde(rename = "DRLC")]
#[cfg_attr(feature = "serde", serde(rename = "DRLC"))]
Drlc,
#[yaserde(rename = "FIIN")]
#[cfg_attr(feature = "serde", serde(rename = "FIIN"))]
Fiin,
#[yaserde(rename = "TXID")]
#[cfg_attr(feature = "serde", serde(rename = "TXID"))]
Txid,
__Unknown__(String),
}
impl Default for TypeOfIdentification1Code {
fn default() -> TypeOfIdentification1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for TypeOfIdentification1Code {}
#[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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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.013.001.12")]
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:sese.013.001.12")]
pub struct WithdrawalReason1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<PortfolioWithdrawalReason1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification36>,
}
impl Validate for WithdrawalReason1Choice {}
#[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 = "013";
const VARIANT: &'static str = "001";
const VERSION: &'static str = "12";
const MESSAGE_NAME: &'static str = "sese.013.001.12";
const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:sese.013.001.12";
}