#![allow(clippy::all)]
#![allow(non_snake_case, non_camel_case_types, dead_code, unused_imports)]
#![allow(non_local_definitions)]
use std::str::FromStr;
use crate::validate::Validate;
use yaserde_derive::{YaDeserialize, YaSerialize};
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct Account35 {
#[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 Account35 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct AccountIdentification82Choice {
#[yaserde(rename = "IBAN")]
#[cfg_attr(feature = "serde", serde(rename = "IBAN"))]
pub iban: Option<Iban2007Identifier>,
#[yaserde(rename = "BlckChainCshWllt")]
#[cfg_attr(feature = "serde", serde(rename = "BlckChainCshWllt"))]
pub blck_chain_csh_wllt: Option<BlockChainAddressWallet3>,
#[yaserde(rename = "Othr")]
#[cfg_attr(feature = "serde", serde(rename = "Othr"))]
pub othr: Option<GenericAccountIdentification1>,
}
impl Validate for AccountIdentification82Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct AccountIdentificationAndName8 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: AccountIdentification82Choice,
#[yaserde(rename = "Nm")]
#[cfg_attr(feature = "serde", serde(rename = "Nm"))]
pub nm: Max35Text,
}
impl Validate for AccountIdentificationAndName8 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
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:setr.015.001.05")]
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:setr.015.001.05")]
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 ActiveOrHistoricCurrencyAndAmountSimpleType (pub String);
crate::simple_type!(ActiveOrHistoricCurrencyAndAmountSimpleType);
impl Validate for ActiveOrHistoricCurrencyAndAmountSimpleType {
fn validate(&self) -> Result<(), String> {
if self.0 < "0".parse::<String>().unwrap() {
return Err(format!("MinInclusive validation error: invalid value of 0! \nExpected: 0 >= 0.\nActual: 0 == {}", self.0));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
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:setr.015.001.05")]
pub struct AdditionalAmount1Choice {
#[yaserde(rename = "AddtlCshIn")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlCshIn"))]
pub addtl_csh_in: Option<ActiveOrHistoricCurrencyAndAmount>,
#[yaserde(rename = "RsltgCshOut")]
#[cfg_attr(feature = "serde", serde(rename = "RsltgCshOut"))]
pub rsltg_csh_out: Option<ActiveOrHistoricCurrencyAndAmount>,
}
impl Validate for AdditionalAmount1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
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:setr.015.001.05")]
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:setr.015.001.05")]
pub enum AddressType2Code {
#[yaserde(rename = "ADDR")]
#[cfg_attr(feature = "serde", serde(rename = "ADDR"))]
Addr,
#[yaserde(rename = "PBOX")]
#[cfg_attr(feature = "serde", serde(rename = "PBOX"))]
Pbox,
#[yaserde(rename = "HOME")]
#[cfg_attr(feature = "serde", serde(rename = "HOME"))]
Home,
#[yaserde(rename = "BIZZ")]
#[cfg_attr(feature = "serde", serde(rename = "BIZZ"))]
Bizz,
#[yaserde(rename = "MLTO")]
#[cfg_attr(feature = "serde", serde(rename = "MLTO"))]
Mlto,
#[yaserde(rename = "DLVY")]
#[cfg_attr(feature = "serde", serde(rename = "DLVY"))]
Dlvy,
__Unknown__(String),
}
impl Default for AddressType2Code {
fn default() -> AddressType2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AddressType2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
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 BaseOneRate (pub String);
crate::simple_type!(BaseOneRate);
impl Validate for BaseOneRate {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct BelgianIdentifier (pub String);
crate::simple_type!(BelgianIdentifier);
impl Validate for BelgianIdentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub enum BestExecution1Code {
#[yaserde(rename = "BTEX")]
#[cfg_attr(feature = "serde", serde(rename = "BTEX"))]
Btex,
__Unknown__(String),
}
impl Default for BestExecution1Code {
fn default() -> BestExecution1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for BestExecution1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct BlockChainAddressWallet14 {
#[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,
#[yaserde(rename = "DgtlLdgrId")]
#[cfg_attr(feature = "serde", serde(rename = "DgtlLdgrId"))]
pub dgtl_ldgr_id: Dti2024Identifier,
}
impl Validate for BlockChainAddressWallet14 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
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:setr.015.001.05")]
pub struct BranchData4 {
#[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 = "PstlAdr")]
#[cfg_attr(feature = "serde", serde(rename = "PstlAdr"))]
pub pstl_adr: PostalAddress1,
}
impl Validate for BranchData4 {}
#[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:setr.015.001.05")]
pub struct CancellationRight1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<CancellationRight1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification47>,
}
impl Validate for CancellationRight1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub enum CancellationRight1Code {
#[yaserde(rename = "VALI")]
#[cfg_attr(feature = "serde", serde(rename = "VALI"))]
Vali,
#[yaserde(rename = "NOXO")]
#[cfg_attr(feature = "serde", serde(rename = "NOXO"))]
Noxo,
#[yaserde(rename = "NOWA")]
#[cfg_attr(feature = "serde", serde(rename = "NOWA"))]
Nowa,
#[yaserde(rename = "NOIN")]
#[cfg_attr(feature = "serde", serde(rename = "NOIN"))]
Noin,
__Unknown__(String),
}
impl Default for CancellationRight1Code {
fn default() -> CancellationRight1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for CancellationRight1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub enum CardType1Code {
#[yaserde(rename = "CRDT")]
#[cfg_attr(feature = "serde", serde(rename = "CRDT"))]
Crdt,
#[yaserde(rename = "DBIT")]
#[cfg_attr(feature = "serde", serde(rename = "DBIT"))]
Dbit,
__Unknown__(String),
}
impl Default for CardType1Code {
fn default() -> CardType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for CardType1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct CashInOrOut8Choice {
#[yaserde(rename = "CshInPmtInstrm")]
#[cfg_attr(feature = "serde", serde(rename = "CshInPmtInstrm"))]
pub csh_in_pmt_instrm: Option<PaymentInstrument30Choice>,
#[yaserde(rename = "CshOutPmtInstrm")]
#[cfg_attr(feature = "serde", serde(rename = "CshOutPmtInstrm"))]
pub csh_out_pmt_instrm: Option<PaymentInstrument28Choice>,
}
impl Validate for CashInOrOut8Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
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:setr.015.001.05")]
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:setr.015.001.05")]
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:setr.015.001.05")]
pub struct Cheque10 {
#[yaserde(rename = "Nb")]
#[cfg_attr(feature = "serde", serde(rename = "Nb"))]
pub nb: Max35Text,
#[yaserde(rename = "PyeeId")]
#[cfg_attr(feature = "serde", serde(rename = "PyeeId"))]
pub pyee_id: PartyIdentification139,
#[yaserde(rename = "DrweeId")]
#[cfg_attr(feature = "serde", serde(rename = "DrweeId"))]
pub drwee_id: FinancialInstitutionIdentification17,
#[yaserde(rename = "DrwrId")]
#[cfg_attr(feature = "serde", serde(rename = "DrwrId"))]
pub drwr_id: PartyIdentification139,
}
impl Validate for Cheque10 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub enum ConductClassification1Code {
#[yaserde(rename = "NSTA")]
#[cfg_attr(feature = "serde", serde(rename = "NSTA"))]
Nsta,
#[yaserde(rename = "RCLT")]
#[cfg_attr(feature = "serde", serde(rename = "RCLT"))]
Rclt,
#[yaserde(rename = "STAN")]
#[cfg_attr(feature = "serde", serde(rename = "STAN"))]
Stan,
__Unknown__(String),
}
impl Default for ConductClassification1Code {
fn default() -> ConductClassification1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for ConductClassification1Code {}
#[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:setr.015.001.05")]
pub struct CopyInformation5 {
#[yaserde(rename = "CpyInd")]
#[cfg_attr(feature = "serde", serde(rename = "CpyInd"))]
pub cpy_ind: YesNoIndicator,
#[yaserde(rename = "OrgnlRcvr")]
#[cfg_attr(feature = "serde", serde(rename = "OrgnlRcvr"))]
pub orgnl_rcvr: AnyBICDec2014Identifier,
}
impl Validate for CopyInformation5 {}
#[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:setr.015.001.05")]
pub struct CreditTransfer12 {
#[yaserde(rename = "Ref")]
#[cfg_attr(feature = "serde", serde(rename = "Ref"))]
pub _ref: Max35Text,
#[yaserde(rename = "Dbtr")]
#[cfg_attr(feature = "serde", serde(rename = "Dbtr"))]
pub dbtr: PartyIdentification139,
#[yaserde(rename = "DbtrAcct")]
#[cfg_attr(feature = "serde", serde(rename = "DbtrAcct"))]
pub dbtr_acct: AccountIdentificationAndName8,
#[yaserde(rename = "DbtrAgt")]
#[cfg_attr(feature = "serde", serde(rename = "DbtrAgt"))]
pub dbtr_agt: FinancialInstitutionIdentification17,
#[yaserde(rename = "DbtrAgtAcct")]
#[cfg_attr(feature = "serde", serde(rename = "DbtrAgtAcct"))]
pub dbtr_agt_acct: AccountIdentificationAndName8,
#[yaserde(rename = "IntrmyAgt1")]
#[cfg_attr(feature = "serde", serde(rename = "IntrmyAgt1"))]
pub intrmy_agt_1: FinancialInstitutionIdentification17,
#[yaserde(rename = "IntrmyAgt1Acct")]
#[cfg_attr(feature = "serde", serde(rename = "IntrmyAgt1Acct"))]
pub intrmy_agt_1_acct: AccountIdentificationAndName8,
#[yaserde(rename = "IntrmyAgt2")]
#[cfg_attr(feature = "serde", serde(rename = "IntrmyAgt2"))]
pub intrmy_agt_2: FinancialInstitutionIdentification17,
#[yaserde(rename = "IntrmyAgt2Acct")]
#[cfg_attr(feature = "serde", serde(rename = "IntrmyAgt2Acct"))]
pub intrmy_agt_2_acct: AccountIdentificationAndName8,
#[yaserde(rename = "CdtrAgt")]
#[cfg_attr(feature = "serde", serde(rename = "CdtrAgt"))]
pub cdtr_agt: FinancialInstitutionIdentification17,
#[yaserde(rename = "CdtrAgtAcct")]
#[cfg_attr(feature = "serde", serde(rename = "CdtrAgtAcct"))]
pub cdtr_agt_acct: AccountIdentificationAndName8,
#[yaserde(rename = "Cdtr")]
#[cfg_attr(feature = "serde", serde(rename = "Cdtr"))]
pub cdtr: PartyIdentification139,
#[yaserde(rename = "CdtrAcct")]
#[cfg_attr(feature = "serde", serde(rename = "CdtrAcct"))]
pub cdtr_acct: AccountIdentificationAndName8,
}
impl Validate for CreditTransfer12 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct CustomerConductClassification1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<ConductClassification1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification47>,
}
impl Validate for CustomerConductClassification1Choice {}
#[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:setr.015.001.05")]
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:setr.015.001.05")]
pub struct DateFormat42Choice {
#[yaserde(rename = "YrMnth")]
#[cfg_attr(feature = "serde", serde(rename = "YrMnth"))]
pub yr_mnth: Option<IsoyearMonth>,
#[yaserde(rename = "YrMnthDay")]
#[cfg_attr(feature = "serde", serde(rename = "YrMnthDay"))]
pub yr_mnth_day: Option<Isodate>,
}
impl Validate for DateFormat42Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct DecimalNumber (pub String);
crate::simple_type!(DecimalNumber);
impl Validate for DecimalNumber {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct DeliveringPartiesAndAccount24 {
#[yaserde(rename = "DlvrrsCtdnDtls")]
#[cfg_attr(feature = "serde", serde(rename = "DlvrrsCtdnDtls"))]
pub dlvrrs_ctdn_dtls: PartyIdentificationAndAccount235,
#[yaserde(rename = "DlvrrsIntrmy1Dtls")]
#[cfg_attr(feature = "serde", serde(rename = "DlvrrsIntrmy1Dtls"))]
pub dlvrrs_intrmy_1_dtls: PartyIdentificationAndAccount235,
#[yaserde(rename = "DlvrrsIntrmy2Dtls")]
#[cfg_attr(feature = "serde", serde(rename = "DlvrrsIntrmy2Dtls"))]
pub dlvrrs_intrmy_2_dtls: PartyIdentificationAndAccount235,
#[yaserde(rename = "DlvrgAgtDtls")]
#[cfg_attr(feature = "serde", serde(rename = "DlvrgAgtDtls"))]
pub dlvrg_agt_dtls: PartyIdentificationAndAccount235,
}
impl Validate for DeliveringPartiesAndAccount24 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct DeliveryParameters3 {
#[yaserde(rename = "Adr")]
#[cfg_attr(feature = "serde", serde(rename = "Adr"))]
pub adr: NameAndAddress4,
#[yaserde(rename = "IssdCertNb")]
#[cfg_attr(feature = "serde", serde(rename = "IssdCertNb"))]
pub issd_cert_nb: Max35Text,
}
impl Validate for DeliveryParameters3 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub enum DeliveryReceiptType2Code {
#[yaserde(rename = "FREE")]
#[cfg_attr(feature = "serde", serde(rename = "FREE"))]
Free,
#[yaserde(rename = "APMT")]
#[cfg_attr(feature = "serde", serde(rename = "APMT"))]
Apmt,
__Unknown__(String),
}
impl Default for DeliveryReceiptType2Code {
fn default() -> DeliveryReceiptType2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for DeliveryReceiptType2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
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:setr.015.001.05")]
pub struct DirectDebitMandate9 {
#[yaserde(rename = "DbtrAcct")]
#[cfg_attr(feature = "serde", serde(rename = "DbtrAcct"))]
pub dbtr_acct: AccountIdentificationAndName8,
#[yaserde(rename = "Dbtr")]
#[cfg_attr(feature = "serde", serde(rename = "Dbtr"))]
pub dbtr: PartyIdentification139,
#[yaserde(rename = "DbtrTaxIdNb")]
#[cfg_attr(feature = "serde", serde(rename = "DbtrTaxIdNb"))]
pub dbtr_tax_id_nb: Max35Text,
#[yaserde(rename = "DbtrNtlRegnNb")]
#[cfg_attr(feature = "serde", serde(rename = "DbtrNtlRegnNb"))]
pub dbtr_ntl_regn_nb: Max35Text,
#[yaserde(rename = "Cdtr")]
#[cfg_attr(feature = "serde", serde(rename = "Cdtr"))]
pub cdtr: PartyIdentification139,
#[yaserde(rename = "DbtrAgt")]
#[cfg_attr(feature = "serde", serde(rename = "DbtrAgt"))]
pub dbtr_agt: FinancialInstitutionIdentification17,
#[yaserde(rename = "DbtrAgtBrnch")]
#[cfg_attr(feature = "serde", serde(rename = "DbtrAgtBrnch"))]
pub dbtr_agt_brnch: BranchData4,
#[yaserde(rename = "CdtrAgt")]
#[cfg_attr(feature = "serde", serde(rename = "CdtrAgt"))]
pub cdtr_agt: FinancialInstitutionIdentification17,
#[yaserde(rename = "CdtrAgtBrnch")]
#[cfg_attr(feature = "serde", serde(rename = "CdtrAgtBrnch"))]
pub cdtr_agt_brnch: BranchData4,
#[yaserde(rename = "RegnId")]
#[cfg_attr(feature = "serde", serde(rename = "RegnId"))]
pub regn_id: Max35Text,
#[yaserde(rename = "MndtId")]
#[cfg_attr(feature = "serde", serde(rename = "MndtId"))]
pub mndt_id: Max35Text,
}
impl Validate for DirectDebitMandate9 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub enum DistributionPolicy1Code {
#[yaserde(rename = "DIST")]
#[cfg_attr(feature = "serde", serde(rename = "DIST"))]
Dist,
#[yaserde(rename = "ACCU")]
#[cfg_attr(feature = "serde", serde(rename = "ACCU"))]
Accu,
__Unknown__(String),
}
impl Default for DistributionPolicy1Code {
fn default() -> DistributionPolicy1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for DistributionPolicy1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct Document {
#[yaserde(rename = "SwtchOrdrConf")]
#[cfg_attr(feature = "serde", serde(rename = "SwtchOrdrConf"))]
pub swtch_ordr_conf: SwitchOrderConfirmationV05,
}
impl Validate for Document {}
#[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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub enum EucapitalGain2Code {
#[yaserde(rename = "EUSI")]
#[cfg_attr(feature = "serde", serde(rename = "EUSI"))]
Eusi,
#[yaserde(rename = "EUSO")]
#[cfg_attr(feature = "serde", serde(rename = "EUSO"))]
Euso,
#[yaserde(rename = "UKWN")]
#[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
Ukwn,
__Unknown__(String),
}
impl Default for EucapitalGain2Code {
fn default() -> EucapitalGain2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for EucapitalGain2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct EucapitalGain3Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<EucapitalGain2Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification47>,
}
impl Validate for EucapitalGain3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub enum EudividendStatus1Code {
#[yaserde(rename = "DIVI")]
#[cfg_attr(feature = "serde", serde(rename = "DIVI"))]
Divi,
#[yaserde(rename = "DIVO")]
#[cfg_attr(feature = "serde", serde(rename = "DIVO"))]
Divo,
#[yaserde(rename = "UKWN")]
#[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
Ukwn,
__Unknown__(String),
}
impl Default for EudividendStatus1Code {
fn default() -> EudividendStatus1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for EudividendStatus1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct EudividendStatusType2Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<EudividendStatus1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification47>,
}
impl Validate for EudividendStatusType2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct Equalisation1 {
#[yaserde(rename = "Amt")]
#[cfg_attr(feature = "serde", serde(rename = "Amt"))]
pub amt: ActiveOrHistoricCurrencyAndAmount,
#[yaserde(rename = "Rate")]
#[cfg_attr(feature = "serde", serde(rename = "Rate"))]
pub rate: PercentageRate,
}
impl Validate for Equalisation1 {}
#[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:setr.015.001.05")]
pub struct ExemptionReason1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<TaxExemptReason1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification47>,
}
impl Validate for ExemptionReason1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
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:setr.015.001.05")]
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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub enum FinancialAdvice1Code {
#[yaserde(rename = "RECE")]
#[cfg_attr(feature = "serde", serde(rename = "RECE"))]
Rece,
#[yaserde(rename = "NREC")]
#[cfg_attr(feature = "serde", serde(rename = "NREC"))]
Nrec,
#[yaserde(rename = "UKWN")]
#[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
Ukwn,
__Unknown__(String),
}
impl Default for FinancialAdvice1Code {
fn default() -> FinancialAdvice1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for FinancialAdvice1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct FinancialInstitutionIdentification10Choice {
#[yaserde(rename = "NmAndAdr")]
#[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
pub nm_and_adr: Option<NameAndAddress5>,
#[yaserde(rename = "BICFI")]
#[cfg_attr(feature = "serde", serde(rename = "BICFI"))]
pub bicfi: Option<Bicfidec2014Identifier>,
#[yaserde(rename = "ClrSysMmbId")]
#[cfg_attr(feature = "serde", serde(rename = "ClrSysMmbId"))]
pub clr_sys_mmb_id: Option<ClearingSystemMemberIdentification2Choice>,
#[yaserde(rename = "PrtryId")]
#[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
pub prtry_id: Option<Max35Text>,
}
impl Validate for FinancialInstitutionIdentification10Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct FinancialInstitutionIdentification17 {
#[yaserde(rename = "Pty")]
#[cfg_attr(feature = "serde", serde(rename = "Pty"))]
pub pty: FinancialInstitutionIdentification10Choice,
#[yaserde(rename = "LEI")]
#[cfg_attr(feature = "serde", serde(rename = "LEI"))]
pub lei: Leiidentifier,
}
impl Validate for FinancialInstitutionIdentification17 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct FinancialInstrument107 {
#[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 = "SplmtryId")]
#[cfg_attr(feature = "serde", serde(rename = "SplmtryId"))]
pub splmtry_id: Max35Text,
#[yaserde(rename = "ClssTp")]
#[cfg_attr(feature = "serde", serde(rename = "ClssTp"))]
pub clss_tp: Max35Text,
#[yaserde(rename = "SctiesForm")]
#[cfg_attr(feature = "serde", serde(rename = "SctiesForm"))]
pub scties_form: FormOfSecurity1Code,
#[yaserde(rename = "DstrbtnPlcy")]
#[cfg_attr(feature = "serde", serde(rename = "DstrbtnPlcy"))]
pub dstrbtn_plcy: DistributionPolicy1Code,
#[yaserde(rename = "PdctGrp")]
#[cfg_attr(feature = "serde", serde(rename = "PdctGrp"))]
pub pdct_grp: Max140Text,
#[yaserde(rename = "SrsId")]
#[cfg_attr(feature = "serde", serde(rename = "SrsId"))]
pub srs_id: Series1,
}
impl Validate for FinancialInstrument107 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
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:setr.015.001.05")]
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:setr.015.001.05")]
pub struct ForeignExchangeTerms37 {
#[yaserde(rename = "ToAmt")]
#[cfg_attr(feature = "serde", serde(rename = "ToAmt"))]
pub to_amt: ActiveCurrencyAndAmount,
#[yaserde(rename = "FrAmt")]
#[cfg_attr(feature = "serde", serde(rename = "FrAmt"))]
pub fr_amt: ActiveCurrencyAndAmount,
#[yaserde(rename = "UnitCcy")]
#[cfg_attr(feature = "serde", serde(rename = "UnitCcy"))]
pub unit_ccy: ActiveCurrencyCode,
#[yaserde(rename = "QtdCcy")]
#[cfg_attr(feature = "serde", serde(rename = "QtdCcy"))]
pub qtd_ccy: ActiveCurrencyCode,
#[yaserde(rename = "XchgRate")]
#[cfg_attr(feature = "serde", serde(rename = "XchgRate"))]
pub xchg_rate: BaseOneRate,
#[yaserde(rename = "QtnDt")]
#[cfg_attr(feature = "serde", serde(rename = "QtnDt"))]
pub qtn_dt: IsodateTime,
#[yaserde(rename = "QtgInstn")]
#[cfg_attr(feature = "serde", serde(rename = "QtgInstn"))]
pub qtg_instn: PartyIdentification139,
}
impl Validate for ForeignExchangeTerms37 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub enum FormOfSecurity1Code {
#[yaserde(rename = "BEAR")]
#[cfg_attr(feature = "serde", serde(rename = "BEAR"))]
Bear,
#[yaserde(rename = "REGD")]
#[cfg_attr(feature = "serde", serde(rename = "REGD"))]
Regd,
__Unknown__(String),
}
impl Default for FormOfSecurity1Code {
fn default() -> FormOfSecurity1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for FormOfSecurity1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub enum FundCashAccount2Code {
#[yaserde(rename = "CASH")]
#[cfg_attr(feature = "serde", serde(rename = "CASH"))]
Cash,
#[yaserde(rename = "CPFO")]
#[cfg_attr(feature = "serde", serde(rename = "CPFO"))]
Cpfo,
#[yaserde(rename = "CPFS")]
#[cfg_attr(feature = "serde", serde(rename = "CPFS"))]
Cpfs,
#[yaserde(rename = "SRSA")]
#[cfg_attr(feature = "serde", serde(rename = "SRSA"))]
Srsa,
__Unknown__(String),
}
impl Default for FundCashAccount2Code {
fn default() -> FundCashAccount2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for FundCashAccount2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct FundSettlementParameters22 {
#[yaserde(rename = "SttlmDt")]
#[cfg_attr(feature = "serde", serde(rename = "SttlmDt"))]
pub sttlm_dt: Isodate,
#[yaserde(rename = "SttlmPlc")]
#[cfg_attr(feature = "serde", serde(rename = "SttlmPlc"))]
pub sttlm_plc: PartyIdentification339,
#[yaserde(rename = "SfkpgPlc")]
#[cfg_attr(feature = "serde", serde(rename = "SfkpgPlc"))]
pub sfkpg_plc: SafekeepingPlaceFormat42Choice,
#[yaserde(rename = "SctiesSttlmSysId")]
#[cfg_attr(feature = "serde", serde(rename = "SctiesSttlmSysId"))]
pub scties_sttlm_sys_id: Max35Text,
#[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 = "RcvgSdDtls")]
#[cfg_attr(feature = "serde", serde(rename = "RcvgSdDtls"))]
pub rcvg_sd_dtls: ReceivingPartiesAndAccount24,
#[yaserde(rename = "DlvrgSdDtls")]
#[cfg_attr(feature = "serde", serde(rename = "DlvrgSdDtls"))]
pub dlvrg_sd_dtls: DeliveringPartiesAndAccount24,
}
impl Validate for FundSettlementParameters22 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct FundSettlementParameters28 {
#[yaserde(rename = "SttlmDt")]
#[cfg_attr(feature = "serde", serde(rename = "SttlmDt"))]
pub sttlm_dt: Isodate,
#[yaserde(rename = "SttlmPlc")]
#[cfg_attr(feature = "serde", serde(rename = "SttlmPlc"))]
pub sttlm_plc: PartyIdentification339,
#[yaserde(rename = "SfkpgPlc")]
#[cfg_attr(feature = "serde", serde(rename = "SfkpgPlc"))]
pub sfkpg_plc: SafekeepingPlaceFormat42Choice,
#[yaserde(rename = "SctiesSttlmSysId")]
#[cfg_attr(feature = "serde", serde(rename = "SctiesSttlmSysId"))]
pub scties_sttlm_sys_id: Max35Text,
#[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 = "RcvgSdDtls")]
#[cfg_attr(feature = "serde", serde(rename = "RcvgSdDtls"))]
pub rcvg_sd_dtls: ReceivingPartiesAndAccount24,
#[yaserde(rename = "DlvrgSdDtls")]
#[cfg_attr(feature = "serde", serde(rename = "DlvrgSdDtls"))]
pub dlvrg_sd_dtls: DeliveringPartiesAndAccount24,
}
impl Validate for FundSettlementParameters28 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub enum GateHoldBack1Code {
#[yaserde(rename = "GATE")]
#[cfg_attr(feature = "serde", serde(rename = "GATE"))]
Gate,
#[yaserde(rename = "HOLD")]
#[cfg_attr(feature = "serde", serde(rename = "HOLD"))]
Hold,
__Unknown__(String),
}
impl Default for GateHoldBack1Code {
fn default() -> GateHoldBack1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for GateHoldBack1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
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:setr.015.001.05")]
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:setr.015.001.05")]
pub struct GenericIdentification30 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Exact4AlphaNumericText,
#[yaserde(rename = "Issr")]
#[cfg_attr(feature = "serde", serde(rename = "Issr"))]
pub issr: Max35Text,
#[yaserde(rename = "SchmeNm")]
#[cfg_attr(feature = "serde", serde(rename = "SchmeNm"))]
pub schme_nm: Max35Text,
}
impl Validate for GenericIdentification30 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
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:setr.015.001.05")]
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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct HoldBackInformation5 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: GateHoldBack1Code,
#[yaserde(rename = "Amt")]
#[cfg_attr(feature = "serde", serde(rename = "Amt"))]
pub amt: ActiveCurrencyAndAmount,
#[yaserde(rename = "XpctdRlsDt")]
#[cfg_attr(feature = "serde", serde(rename = "XpctdRlsDt"))]
pub xpctd_rls_dt: Isodate,
#[yaserde(rename = "FinInstrmId")]
#[cfg_attr(feature = "serde", serde(rename = "FinInstrmId"))]
pub fin_instrm_id: SecurityIdentification46Choice,
#[yaserde(rename = "FinInstrmNm")]
#[cfg_attr(feature = "serde", serde(rename = "FinInstrmNm"))]
pub fin_instrm_nm: Max350Text,
#[yaserde(rename = "RedCmpltn")]
#[cfg_attr(feature = "serde", serde(rename = "RedCmpltn"))]
pub red_cmpltn: RedemptionCompletion1Code,
#[yaserde(rename = "FnlConf")]
#[cfg_attr(feature = "serde", serde(rename = "FnlConf"))]
pub fnl_conf: YesNoIndicator,
}
impl Validate for HoldBackInformation5 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct HongKongBankIdentifier (pub String);
crate::simple_type!(HongKongBankIdentifier);
impl Validate for HongKongBankIdentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Iban2007Identifier (pub String);
crate::simple_type!(Iban2007Identifier);
impl Validate for Iban2007Identifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Isinoct2015Identifier (pub String);
crate::simple_type!(Isinoct2015Identifier);
impl Validate for Isinoct2015Identifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Isodate (pub String);
crate::simple_type!(Isodate);
impl Validate for Isodate {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct IsodateTime (pub String);
crate::simple_type!(IsodateTime);
impl Validate for IsodateTime {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct IsoyearMonth (pub String);
crate::simple_type!(IsoyearMonth);
impl Validate for IsoyearMonth {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
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:setr.015.001.05")]
pub struct IdentificationSource6Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<FinancialInstrumentIdentificationType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<Max35Text>,
}
impl Validate for IdentificationSource6Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ImpliedCurrencyAndAmount (pub String);
crate::simple_type!(ImpliedCurrencyAndAmount);
impl Validate for ImpliedCurrencyAndAmount {
fn validate(&self) -> Result<(), String> {
if self.0 < "0".parse::<String>().unwrap() {
return Err(format!("MinInclusive validation error: invalid value of 0! \nExpected: 0 >= 0.\nActual: 0 == {}", self.0));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub enum IncomePreference1Code {
#[yaserde(rename = "CASH")]
#[cfg_attr(feature = "serde", serde(rename = "CASH"))]
Cash,
#[yaserde(rename = "DRIP")]
#[cfg_attr(feature = "serde", serde(rename = "DRIP"))]
Drip,
__Unknown__(String),
}
impl Default for IncomePreference1Code {
fn default() -> IncomePreference1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for IncomePreference1Code {}
#[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:setr.015.001.05")]
pub struct InformativeTax2 {
#[yaserde(rename = "TaxblIncmPerDvdd")]
#[cfg_attr(feature = "serde", serde(rename = "TaxblIncmPerDvdd"))]
pub taxbl_incm_per_dvdd: ActiveCurrencyAndAmount,
#[yaserde(rename = "EUCptlGn")]
#[cfg_attr(feature = "serde", serde(rename = "EUCptlGn"))]
pub eu_cptl_gn: EucapitalGain3Choice,
#[yaserde(rename = "EUDvddSts")]
#[cfg_attr(feature = "serde", serde(rename = "EUDvddSts"))]
pub eu_dvdd_sts: EudividendStatusType2Choice,
#[yaserde(rename = "PctgOfDebtClm")]
#[cfg_attr(feature = "serde", serde(rename = "PctgOfDebtClm"))]
pub pctg_of_debt_clm: PercentageRate,
#[yaserde(rename = "IndvTax")]
#[cfg_attr(feature = "serde", serde(rename = "IndvTax"))]
pub indv_tax: Vec<Tax40>,
}
impl Validate for InformativeTax2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct Intermediary49 {
#[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: Account35,
#[yaserde(rename = "OrdrOrgtrElgblty")]
#[cfg_attr(feature = "serde", serde(rename = "OrdrOrgtrElgblty"))]
pub ordr_orgtr_elgblty: OrderOriginatorEligibility1Code,
#[yaserde(rename = "TradgPtyCpcty")]
#[cfg_attr(feature = "serde", serde(rename = "TradgPtyCpcty"))]
pub tradg_pty_cpcty: TradingCapacity8Code,
#[yaserde(rename = "Role")]
#[cfg_attr(feature = "serde", serde(rename = "Role"))]
pub role: InvestmentFundRole2Choice,
}
impl Validate for Intermediary49 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct InvestmentAccount60 {
#[yaserde(rename = "AcctId")]
#[cfg_attr(feature = "serde", serde(rename = "AcctId"))]
pub acct_id: Max35Text,
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: InvestmentAccountType1Choice,
}
impl Validate for InvestmentAccount60 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct InvestmentAccount81 {
#[yaserde(rename = "AcctId")]
#[cfg_attr(feature = "serde", serde(rename = "AcctId"))]
pub acct_id: Max35Text,
#[yaserde(rename = "AcctNm")]
#[cfg_attr(feature = "serde", serde(rename = "AcctNm"))]
pub acct_nm: Max35Text,
#[yaserde(rename = "AcctDsgnt")]
#[cfg_attr(feature = "serde", serde(rename = "AcctDsgnt"))]
pub acct_dsgnt: Max35Text,
#[yaserde(rename = "OwnrId")]
#[cfg_attr(feature = "serde", serde(rename = "OwnrId"))]
pub ownr_id: Vec<PartyIdentification139>,
#[yaserde(rename = "AcctSvcr")]
#[cfg_attr(feature = "serde", serde(rename = "AcctSvcr"))]
pub acct_svcr: PartyIdentification139,
#[yaserde(rename = "OrdrOrgtrElgblty")]
#[cfg_attr(feature = "serde", serde(rename = "OrdrOrgtrElgblty"))]
pub ordr_orgtr_elgblty: OrderOriginatorEligibility1Code,
#[yaserde(rename = "SubAcctDtls")]
#[cfg_attr(feature = "serde", serde(rename = "SubAcctDtls"))]
pub sub_acct_dtls: SubAccount6,
#[yaserde(rename = "BlckChainAdrOrWllt")]
#[cfg_attr(feature = "serde", serde(rename = "BlckChainAdrOrWllt"))]
pub blck_chain_adr_or_wllt: BlockChainAddressWallet3,
}
impl Validate for InvestmentAccount81 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct InvestmentAccountType1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<FundCashAccount2Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification47>,
}
impl Validate for InvestmentAccountType1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct InvestmentFundRole2Choice {
#[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 InvestmentFundRole2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub enum LateReport1Code {
#[yaserde(rename = "LAT1")]
#[cfg_attr(feature = "serde", serde(rename = "LAT1"))]
Lat1,
#[yaserde(rename = "LAT2")]
#[cfg_attr(feature = "serde", serde(rename = "LAT2"))]
Lat2,
__Unknown__(String),
}
impl Default for LateReport1Code {
fn default() -> LateReport1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for LateReport1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Micidentifier (pub String);
crate::simple_type!(Micidentifier);
impl Validate for Micidentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
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 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 Max3Text (pub String);
crate::simple_type!(Max3Text);
impl Validate for Max3Text {
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() > 3 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 3 \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:setr.015.001.05")]
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:setr.015.001.05")]
pub struct NameAndAddress4 {
#[yaserde(rename = "Nm")]
#[cfg_attr(feature = "serde", serde(rename = "Nm"))]
pub nm: Max350Text,
#[yaserde(rename = "Adr")]
#[cfg_attr(feature = "serde", serde(rename = "Adr"))]
pub adr: PostalAddress1,
}
impl Validate for NameAndAddress4 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
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:setr.015.001.05")]
pub enum NegotiatedTrade1Code {
#[yaserde(rename = "NEGO")]
#[cfg_attr(feature = "serde", serde(rename = "NEGO"))]
Nego,
#[yaserde(rename = "NNGO")]
#[cfg_attr(feature = "serde", serde(rename = "NNGO"))]
Nngo,
#[yaserde(rename = "UNKW")]
#[cfg_attr(feature = "serde", serde(rename = "UNKW"))]
Unkw,
__Unknown__(String),
}
impl Default for NegotiatedTrade1Code {
fn default() -> NegotiatedTrade1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for NegotiatedTrade1Code {}
#[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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub enum OrderOriginatorEligibility1Code {
#[yaserde(rename = "ELIG")]
#[cfg_attr(feature = "serde", serde(rename = "ELIG"))]
Elig,
#[yaserde(rename = "RETL")]
#[cfg_attr(feature = "serde", serde(rename = "RETL"))]
Retl,
#[yaserde(rename = "PROF")]
#[cfg_attr(feature = "serde", serde(rename = "PROF"))]
Prof,
__Unknown__(String),
}
impl Default for OrderOriginatorEligibility1Code {
fn default() -> OrderOriginatorEligibility1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for OrderOriginatorEligibility1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct OrderWaiver1 {
#[yaserde(rename = "OrdrWvrRsn")]
#[cfg_attr(feature = "serde", serde(rename = "OrdrWvrRsn"))]
pub ordr_wvr_rsn: Vec<OrderWaiverReason3Choice>,
#[yaserde(rename = "InfVal")]
#[cfg_attr(feature = "serde", serde(rename = "InfVal"))]
pub inf_val: Max350Text,
}
impl Validate for OrderWaiver1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub enum OrderWaiverReason1Code {
#[yaserde(rename = "LATE")]
#[cfg_attr(feature = "serde", serde(rename = "LATE"))]
Late,
#[yaserde(rename = "FEND")]
#[cfg_attr(feature = "serde", serde(rename = "FEND"))]
Fend,
#[yaserde(rename = "BMIN")]
#[cfg_attr(feature = "serde", serde(rename = "BMIN"))]
Bmin,
#[yaserde(rename = "CUTO")]
#[cfg_attr(feature = "serde", serde(rename = "CUTO"))]
Cuto,
#[yaserde(rename = "COMW")]
#[cfg_attr(feature = "serde", serde(rename = "COMW"))]
Comw,
__Unknown__(String),
}
impl Default for OrderWaiverReason1Code {
fn default() -> OrderWaiverReason1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for OrderWaiverReason1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct OrderWaiverReason3Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<OrderWaiverReason1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification47>,
}
impl Validate for OrderWaiverReason3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
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:setr.015.001.05")]
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:setr.015.001.05")]
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:setr.015.001.05")]
pub struct PartyIdentification262Choice {
#[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>,
#[yaserde(rename = "DgtlLdgrId")]
#[cfg_attr(feature = "serde", serde(rename = "DgtlLdgrId"))]
pub dgtl_ldgr_id: Option<Dti2024Identifier>,
}
impl Validate for PartyIdentification262Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct PartyIdentification339 {
#[yaserde(rename = "Pty")]
#[cfg_attr(feature = "serde", serde(rename = "Pty"))]
pub pty: PartyIdentification262Choice,
#[yaserde(rename = "LEI")]
#[cfg_attr(feature = "serde", serde(rename = "LEI"))]
pub lei: Leiidentifier,
}
impl Validate for PartyIdentification339 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct PartyIdentificationAndAccount235 {
#[yaserde(rename = "PtyId")]
#[cfg_attr(feature = "serde", serde(rename = "PtyId"))]
pub pty_id: PartyIdentification139,
#[yaserde(rename = "AcctId")]
#[cfg_attr(feature = "serde", serde(rename = "AcctId"))]
pub acct_id: Max35Text,
#[yaserde(rename = "BlckChainAdrOrWllt")]
#[cfg_attr(feature = "serde", serde(rename = "BlckChainAdrOrWllt"))]
pub blck_chain_adr_or_wllt: BlockChainAddressWallet3,
}
impl Validate for PartyIdentificationAndAccount235 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct PaymentCard34 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: CardType1Code,
#[yaserde(rename = "Nb")]
#[cfg_attr(feature = "serde", serde(rename = "Nb"))]
pub nb: Max35Text,
#[yaserde(rename = "HldrNm")]
#[cfg_attr(feature = "serde", serde(rename = "HldrNm"))]
pub hldr_nm: Max35Text,
#[yaserde(rename = "StartDt")]
#[cfg_attr(feature = "serde", serde(rename = "StartDt"))]
pub start_dt: IsoyearMonth,
#[yaserde(rename = "XpryDt")]
#[cfg_attr(feature = "serde", serde(rename = "XpryDt"))]
pub xpry_dt: IsoyearMonth,
#[yaserde(rename = "CardIssrNm")]
#[cfg_attr(feature = "serde", serde(rename = "CardIssrNm"))]
pub card_issr_nm: Max35Text,
#[yaserde(rename = "CardIssrId")]
#[cfg_attr(feature = "serde", serde(rename = "CardIssrId"))]
pub card_issr_id: PartyIdentification139,
#[yaserde(rename = "SctyCd")]
#[cfg_attr(feature = "serde", serde(rename = "SctyCd"))]
pub scty_cd: Max35Text,
#[yaserde(rename = "SeqNb")]
#[cfg_attr(feature = "serde", serde(rename = "SeqNb"))]
pub seq_nb: Max3Text,
}
impl Validate for PaymentCard34 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct PaymentInstrument28Choice {
#[yaserde(rename = "CdtTrfDtls")]
#[cfg_attr(feature = "serde", serde(rename = "CdtTrfDtls"))]
pub cdt_trf_dtls: Option<CreditTransfer12>,
#[yaserde(rename = "ChqDtls")]
#[cfg_attr(feature = "serde", serde(rename = "ChqDtls"))]
pub chq_dtls: Option<Cheque10>,
#[yaserde(rename = "BkrsDrftDtls")]
#[cfg_attr(feature = "serde", serde(rename = "BkrsDrftDtls"))]
pub bkrs_drft_dtls: Option<Cheque10>,
#[yaserde(rename = "CshAcctDtls")]
#[cfg_attr(feature = "serde", serde(rename = "CshAcctDtls"))]
pub csh_acct_dtls: Option<InvestmentAccount60>,
#[yaserde(rename = "BlckChainCshWllt")]
#[cfg_attr(feature = "serde", serde(rename = "BlckChainCshWllt"))]
pub blck_chain_csh_wllt: Option<BlockChainAddressWallet14>,
}
impl Validate for PaymentInstrument28Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct PaymentInstrument30Choice {
#[yaserde(rename = "PmtCardDtls")]
#[cfg_attr(feature = "serde", serde(rename = "PmtCardDtls"))]
pub pmt_card_dtls: Option<PaymentCard34>,
#[yaserde(rename = "CdtTrfDtls")]
#[cfg_attr(feature = "serde", serde(rename = "CdtTrfDtls"))]
pub cdt_trf_dtls: Option<CreditTransfer12>,
#[yaserde(rename = "DrctDbtDtls")]
#[cfg_attr(feature = "serde", serde(rename = "DrctDbtDtls"))]
pub drct_dbt_dtls: Option<DirectDebitMandate9>,
#[yaserde(rename = "ChqDtls")]
#[cfg_attr(feature = "serde", serde(rename = "ChqDtls"))]
pub chq_dtls: Option<Cheque10>,
#[yaserde(rename = "BkrsDrftDtls")]
#[cfg_attr(feature = "serde", serde(rename = "BkrsDrftDtls"))]
pub bkrs_drft_dtls: Option<Cheque10>,
#[yaserde(rename = "CshAcctDtls")]
#[cfg_attr(feature = "serde", serde(rename = "CshAcctDtls"))]
pub csh_acct_dtls: Option<InvestmentAccount60>,
#[yaserde(rename = "BlckChainCshWllt")]
#[cfg_attr(feature = "serde", serde(rename = "BlckChainCshWllt"))]
pub blck_chain_csh_wllt: Option<BlockChainAddressWallet14>,
}
impl Validate for PaymentInstrument30Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct PaymentTransaction181 {
#[yaserde(rename = "CshInOrOut")]
#[cfg_attr(feature = "serde", serde(rename = "CshInOrOut"))]
pub csh_in_or_out: CashInOrOut8Choice,
}
impl Validate for PaymentTransaction181 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct PercentageRate (pub String);
crate::simple_type!(PercentageRate);
impl Validate for PercentageRate {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct PlaceOfTradeIdentification4Choice {
#[yaserde(rename = "Ctry")]
#[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
pub ctry: Option<CountryCode>,
#[yaserde(rename = "Xchg")]
#[cfg_attr(feature = "serde", serde(rename = "Xchg"))]
pub xchg: Option<Micidentifier>,
#[yaserde(rename = "Pty")]
#[cfg_attr(feature = "serde", serde(rename = "Pty"))]
pub pty: Option<AnyBICDec2014Identifier>,
#[yaserde(rename = "OverTheCntr")]
#[cfg_attr(feature = "serde", serde(rename = "OverTheCntr"))]
pub over_the_cntr: Option<Max35Text>,
}
impl Validate for PlaceOfTradeIdentification4Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct PolishNationalClearingCodeIdentifier (pub String);
crate::simple_type!(PolishNationalClearingCodeIdentifier);
impl Validate for PolishNationalClearingCodeIdentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct PortugueseNCCIdentifier (pub String);
crate::simple_type!(PortugueseNCCIdentifier);
impl Validate for PortugueseNCCIdentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
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:setr.015.001.05")]
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:setr.015.001.05")]
pub struct ProfitAndLoss2Choice {
#[yaserde(rename = "Prft")]
#[cfg_attr(feature = "serde", serde(rename = "Prft"))]
pub prft: Option<ActiveCurrencyAndAmount>,
#[yaserde(rename = "Loss")]
#[cfg_attr(feature = "serde", serde(rename = "Loss"))]
pub loss: Option<ActiveCurrencyAndAmount>,
}
impl Validate for ProfitAndLoss2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
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:setr.015.001.05")]
pub struct Quantity48Choice {
#[yaserde(rename = "Qty")]
#[cfg_attr(feature = "serde", serde(rename = "Qty"))]
pub qty: Option<FinancialInstrumentQuantity33Choice>,
#[yaserde(rename = "PrtryQty")]
#[cfg_attr(feature = "serde", serde(rename = "PrtryQty"))]
pub prtry_qty: Option<ProprietaryQuantity8>,
}
impl Validate for Quantity48Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Ricidentifier (pub String);
crate::simple_type!(Ricidentifier);
impl Validate for Ricidentifier {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 35 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 35 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct ReceivingPartiesAndAccount24 {
#[yaserde(rename = "RcvrsCtdnDtls")]
#[cfg_attr(feature = "serde", serde(rename = "RcvrsCtdnDtls"))]
pub rcvrs_ctdn_dtls: PartyIdentificationAndAccount235,
#[yaserde(rename = "RcvrsIntrmy1Dtls")]
#[cfg_attr(feature = "serde", serde(rename = "RcvrsIntrmy1Dtls"))]
pub rcvrs_intrmy_1_dtls: PartyIdentificationAndAccount235,
#[yaserde(rename = "RcvrsIntrmy2Dtls")]
#[cfg_attr(feature = "serde", serde(rename = "RcvrsIntrmy2Dtls"))]
pub rcvrs_intrmy_2_dtls: PartyIdentificationAndAccount235,
#[yaserde(rename = "RcvgAgtDtls")]
#[cfg_attr(feature = "serde", serde(rename = "RcvgAgtDtls"))]
pub rcvg_agt_dtls: PartyIdentificationAndAccount235,
}
impl Validate for ReceivingPartiesAndAccount24 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub enum RedemptionCompletion1Code {
#[yaserde(rename = "RED0")]
#[cfg_attr(feature = "serde", serde(rename = "RED0"))]
Red0,
#[yaserde(rename = "RED1")]
#[cfg_attr(feature = "serde", serde(rename = "RED1"))]
Red1,
__Unknown__(String),
}
impl Default for RedemptionCompletion1Code {
fn default() -> RedemptionCompletion1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for RedemptionCompletion1Code {}
#[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:setr.015.001.05")]
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:setr.015.001.05")]
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:setr.015.001.05")]
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:setr.015.001.05")]
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:setr.015.001.05")]
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:setr.015.001.05")]
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:setr.015.001.05")]
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:setr.015.001.05")]
pub struct Series1 {
#[yaserde(rename = "SrsDt")]
#[cfg_attr(feature = "serde", serde(rename = "SrsDt"))]
pub srs_dt: DateFormat42Choice,
#[yaserde(rename = "SrsNm")]
#[cfg_attr(feature = "serde", serde(rename = "SrsNm"))]
pub srs_nm: Max35Text,
}
impl Validate for Series1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
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:setr.015.001.05")]
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct SignatureType1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<SignatureType2Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification47>,
}
impl Validate for SignatureType1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub enum SignatureType2Code {
#[yaserde(rename = "DIGI")]
#[cfg_attr(feature = "serde", serde(rename = "DIGI"))]
Digi,
#[yaserde(rename = "ELEC")]
#[cfg_attr(feature = "serde", serde(rename = "ELEC"))]
Elec,
#[yaserde(rename = "NONE")]
#[cfg_attr(feature = "serde", serde(rename = "NONE"))]
None,
#[yaserde(rename = "ORIG")]
#[cfg_attr(feature = "serde", serde(rename = "ORIG"))]
Orig,
__Unknown__(String),
}
impl Default for SignatureType2Code {
fn default() -> SignatureType2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for SignatureType2Code {}
#[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:setr.015.001.05")]
pub struct SubAccount6 {
#[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,
#[yaserde(rename = "AcctDsgnt")]
#[cfg_attr(feature = "serde", serde(rename = "AcctDsgnt"))]
pub acct_dsgnt: Max35Text,
}
impl Validate for SubAccount6 {}
#[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:setr.015.001.05")]
pub struct SwitchExecution8 {
#[yaserde(rename = "AmdmntInd")]
#[cfg_attr(feature = "serde", serde(rename = "AmdmntInd"))]
pub amdmnt_ind: YesNoIndicator,
#[yaserde(rename = "MstrRef")]
#[cfg_attr(feature = "serde", serde(rename = "MstrRef"))]
pub mstr_ref: Max35Text,
#[yaserde(rename = "PlcOfTrad")]
#[cfg_attr(feature = "serde", serde(rename = "PlcOfTrad"))]
pub plc_of_trad: PlaceOfTradeIdentification4Choice,
#[yaserde(rename = "OrdrDtTm")]
#[cfg_attr(feature = "serde", serde(rename = "OrdrDtTm"))]
pub ordr_dt_tm: IsodateTime,
#[yaserde(rename = "RcvdDtTm")]
#[cfg_attr(feature = "serde", serde(rename = "RcvdDtTm"))]
pub rcvd_dt_tm: IsodateTime,
#[yaserde(rename = "DealRef")]
#[cfg_attr(feature = "serde", serde(rename = "DealRef"))]
pub deal_ref: Max35Text,
#[yaserde(rename = "OrdrRef")]
#[cfg_attr(feature = "serde", serde(rename = "OrdrRef"))]
pub ordr_ref: Max35Text,
#[yaserde(rename = "ClntRef")]
#[cfg_attr(feature = "serde", serde(rename = "ClntRef"))]
pub clnt_ref: Max35Text,
#[yaserde(rename = "NonceId")]
#[cfg_attr(feature = "serde", serde(rename = "NonceId"))]
pub nonce_id: Max35Text,
#[yaserde(rename = "InvstmtAcctDtls")]
#[cfg_attr(feature = "serde", serde(rename = "InvstmtAcctDtls"))]
pub invstmt_acct_dtls: InvestmentAccount81,
#[yaserde(rename = "RltdPtyDtls")]
#[cfg_attr(feature = "serde", serde(rename = "RltdPtyDtls"))]
pub rltd_pty_dtls: Vec<Intermediary49>,
#[yaserde(rename = "CxlRght")]
#[cfg_attr(feature = "serde", serde(rename = "CxlRght"))]
pub cxl_rght: CancellationRight1Choice,
#[yaserde(rename = "ReqdFutrTradDt")]
#[cfg_attr(feature = "serde", serde(rename = "ReqdFutrTradDt"))]
pub reqd_futr_trad_dt: Isodate,
#[yaserde(rename = "SttlmAmt")]
#[cfg_attr(feature = "serde", serde(rename = "SttlmAmt"))]
pub sttlm_amt: ActiveCurrencyAndAmount,
#[yaserde(rename = "CshSttlmDt")]
#[cfg_attr(feature = "serde", serde(rename = "CshSttlmDt"))]
pub csh_sttlm_dt: Isodate,
#[yaserde(rename = "SttlmMtd")]
#[cfg_attr(feature = "serde", serde(rename = "SttlmMtd"))]
pub sttlm_mtd: DeliveryReceiptType2Code,
#[yaserde(rename = "AddtlAmt")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlAmt"))]
pub addtl_amt: AdditionalAmount1Choice,
#[yaserde(rename = "BestExctn")]
#[cfg_attr(feature = "serde", serde(rename = "BestExctn"))]
pub best_exctn: BestExecution1Code,
#[yaserde(rename = "RedLegDtls")]
#[cfg_attr(feature = "serde", serde(rename = "RedLegDtls"))]
pub red_leg_dtls: Vec<SwitchRedemptionLegExecution5>,
#[yaserde(rename = "SbcptLegDtls")]
#[cfg_attr(feature = "serde", serde(rename = "SbcptLegDtls"))]
pub sbcpt_leg_dtls: Vec<SwitchSubscriptionLegExecution5>,
#[yaserde(rename = "CshSttlmDtls")]
#[cfg_attr(feature = "serde", serde(rename = "CshSttlmDtls"))]
pub csh_sttlm_dtls: PaymentTransaction181,
#[yaserde(rename = "FXDtls")]
#[cfg_attr(feature = "serde", serde(rename = "FXDtls"))]
pub fx_dtls: Vec<ForeignExchangeTerms37>,
#[yaserde(rename = "FinAdvc")]
#[cfg_attr(feature = "serde", serde(rename = "FinAdvc"))]
pub fin_advc: FinancialAdvice1Code,
#[yaserde(rename = "NgtdTrad")]
#[cfg_attr(feature = "serde", serde(rename = "NgtdTrad"))]
pub ngtd_trad: NegotiatedTrade1Code,
#[yaserde(rename = "LateRpt")]
#[cfg_attr(feature = "serde", serde(rename = "LateRpt"))]
pub late_rpt: LateReport1Code,
#[yaserde(rename = "CstmrCndctClssfctn")]
#[cfg_attr(feature = "serde", serde(rename = "CstmrCndctClssfctn"))]
pub cstmr_cndct_clssfctn: CustomerConductClassification1Choice,
#[yaserde(rename = "TxChanlTp")]
#[cfg_attr(feature = "serde", serde(rename = "TxChanlTp"))]
pub tx_chanl_tp: TransactionChannelType1Choice,
#[yaserde(rename = "SgntrTp")]
#[cfg_attr(feature = "serde", serde(rename = "SgntrTp"))]
pub sgntr_tp: SignatureType1Choice,
#[yaserde(rename = "OrdrWvrDtls")]
#[cfg_attr(feature = "serde", serde(rename = "OrdrWvrDtls"))]
pub ordr_wvr_dtls: OrderWaiver1,
}
impl Validate for SwitchExecution8 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct SwitchOrderConfirmationV05 {
#[yaserde(rename = "MsgId")]
#[cfg_attr(feature = "serde", serde(rename = "MsgId"))]
pub msg_id: 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: Vec<AdditionalReference10>,
#[yaserde(rename = "RltdRef")]
#[cfg_attr(feature = "serde", serde(rename = "RltdRef"))]
pub rltd_ref: AdditionalReference10,
#[yaserde(rename = "SwtchExctnDtls")]
#[cfg_attr(feature = "serde", serde(rename = "SwtchExctnDtls"))]
pub swtch_exctn_dtls: Vec<SwitchExecution8>,
#[yaserde(rename = "CpyDtls")]
#[cfg_attr(feature = "serde", serde(rename = "CpyDtls"))]
pub cpy_dtls: CopyInformation5,
#[yaserde(rename = "Xtnsn")]
#[cfg_attr(feature = "serde", serde(rename = "Xtnsn"))]
pub xtnsn: Vec<Extension1>,
}
impl Validate for SwitchOrderConfirmationV05 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct SwitchRedemptionLegExecution5 {
#[yaserde(rename = "LegId")]
#[cfg_attr(feature = "serde", serde(rename = "LegId"))]
pub leg_id: Max35Text,
#[yaserde(rename = "LegExctnId")]
#[cfg_attr(feature = "serde", serde(rename = "LegExctnId"))]
pub leg_exctn_id: Max35Text,
#[yaserde(rename = "FinInstrmDtls")]
#[cfg_attr(feature = "serde", serde(rename = "FinInstrmDtls"))]
pub fin_instrm_dtls: FinancialInstrument107,
#[yaserde(rename = "Units")]
#[cfg_attr(feature = "serde", serde(rename = "Units"))]
pub units: Unit1Choice,
#[yaserde(rename = "HldgsRedRate")]
#[cfg_attr(feature = "serde", serde(rename = "HldgsRedRate"))]
pub hldgs_red_rate: PercentageRate,
#[yaserde(rename = "NetAmt")]
#[cfg_attr(feature = "serde", serde(rename = "NetAmt"))]
pub net_amt: ActiveCurrencyAndAmount,
#[yaserde(rename = "GrssAmt")]
#[cfg_attr(feature = "serde", serde(rename = "GrssAmt"))]
pub grss_amt: ActiveCurrencyAndAmount,
#[yaserde(rename = "InvstmtAcctDtls")]
#[cfg_attr(feature = "serde", serde(rename = "InvstmtAcctDtls"))]
pub invstmt_acct_dtls: InvestmentAccount81,
#[yaserde(rename = "TradDtTm")]
#[cfg_attr(feature = "serde", serde(rename = "TradDtTm"))]
pub trad_dt_tm: DateAndDateTime2Choice,
#[yaserde(rename = "PricDtls")]
#[cfg_attr(feature = "serde", serde(rename = "PricDtls"))]
pub pric_dtls: UnitPrice22,
#[yaserde(rename = "InftvPricDtls")]
#[cfg_attr(feature = "serde", serde(rename = "InftvPricDtls"))]
pub inftv_pric_dtls: Vec<UnitPrice22>,
#[yaserde(rename = "CumDvddInd")]
#[cfg_attr(feature = "serde", serde(rename = "CumDvddInd"))]
pub cum_dvdd_ind: YesNoIndicator,
#[yaserde(rename = "IntrmPrftAmt")]
#[cfg_attr(feature = "serde", serde(rename = "IntrmPrftAmt"))]
pub intrm_prft_amt: ProfitAndLoss2Choice,
#[yaserde(rename = "IncmPref")]
#[cfg_attr(feature = "serde", serde(rename = "IncmPref"))]
pub incm_pref: IncomePreference1Code,
#[yaserde(rename = "Grp1Or2Units")]
#[cfg_attr(feature = "serde", serde(rename = "Grp1Or2Units"))]
pub grp_1_or_2_units: UktaxGroupUnit1Code,
#[yaserde(rename = "ReqdSttlmCcy")]
#[cfg_attr(feature = "serde", serde(rename = "ReqdSttlmCcy"))]
pub reqd_sttlm_ccy: ActiveCurrencyCode,
#[yaserde(rename = "ReqdNAVCcy")]
#[cfg_attr(feature = "serde", serde(rename = "ReqdNAVCcy"))]
pub reqd_nav_ccy: ActiveOrHistoricCurrencyCode,
#[yaserde(rename = "TxOvrhd")]
#[cfg_attr(feature = "serde", serde(rename = "TxOvrhd"))]
pub tx_ovrhd: TotalFeesAndTaxes44,
#[yaserde(rename = "InftvTaxDtls")]
#[cfg_attr(feature = "serde", serde(rename = "InftvTaxDtls"))]
pub inftv_tax_dtls: InformativeTax2,
#[yaserde(rename = "SttlmAndCtdyDtls")]
#[cfg_attr(feature = "serde", serde(rename = "SttlmAndCtdyDtls"))]
pub sttlm_and_ctdy_dtls: FundSettlementParameters22,
#[yaserde(rename = "PhysDlvryInd")]
#[cfg_attr(feature = "serde", serde(rename = "PhysDlvryInd"))]
pub phys_dlvry_ind: YesNoIndicator,
#[yaserde(rename = "PhysDlvryDtls")]
#[cfg_attr(feature = "serde", serde(rename = "PhysDlvryDtls"))]
pub phys_dlvry_dtls: DeliveryParameters3,
#[yaserde(rename = "DgtlAsstSttlm")]
#[cfg_attr(feature = "serde", serde(rename = "DgtlAsstSttlm"))]
pub dgtl_asst_sttlm: DigitalPaymentSettlement3,
#[yaserde(rename = "NonStdSttlmInf")]
#[cfg_attr(feature = "serde", serde(rename = "NonStdSttlmInf"))]
pub non_std_sttlm_inf: Max350Text,
#[yaserde(rename = "Equlstn")]
#[cfg_attr(feature = "serde", serde(rename = "Equlstn"))]
pub equlstn: Equalisation1,
#[yaserde(rename = "GtgOrHldBckDtls")]
#[cfg_attr(feature = "serde", serde(rename = "GtgOrHldBckDtls"))]
pub gtg_or_hld_bck_dtls: HoldBackInformation5,
}
impl Validate for SwitchRedemptionLegExecution5 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct SwitchSubscriptionLegExecution5 {
#[yaserde(rename = "LegId")]
#[cfg_attr(feature = "serde", serde(rename = "LegId"))]
pub leg_id: Max35Text,
#[yaserde(rename = "LegExctnId")]
#[cfg_attr(feature = "serde", serde(rename = "LegExctnId"))]
pub leg_exctn_id: Max35Text,
#[yaserde(rename = "FinInstrmDtls")]
#[cfg_attr(feature = "serde", serde(rename = "FinInstrmDtls"))]
pub fin_instrm_dtls: FinancialInstrument107,
#[yaserde(rename = "Units")]
#[cfg_attr(feature = "serde", serde(rename = "Units"))]
pub units: Unit1Choice,
#[yaserde(rename = "NetAmt")]
#[cfg_attr(feature = "serde", serde(rename = "NetAmt"))]
pub net_amt: ActiveCurrencyAndAmount,
#[yaserde(rename = "GrssAmt")]
#[cfg_attr(feature = "serde", serde(rename = "GrssAmt"))]
pub grss_amt: ActiveCurrencyAndAmount,
#[yaserde(rename = "InvstmtAcctDtls")]
#[cfg_attr(feature = "serde", serde(rename = "InvstmtAcctDtls"))]
pub invstmt_acct_dtls: InvestmentAccount81,
#[yaserde(rename = "TradDtTm")]
#[cfg_attr(feature = "serde", serde(rename = "TradDtTm"))]
pub trad_dt_tm: DateAndDateTime2Choice,
#[yaserde(rename = "PricDtls")]
#[cfg_attr(feature = "serde", serde(rename = "PricDtls"))]
pub pric_dtls: UnitPrice22,
#[yaserde(rename = "InftvPricDtls")]
#[cfg_attr(feature = "serde", serde(rename = "InftvPricDtls"))]
pub inftv_pric_dtls: Vec<UnitPrice22>,
#[yaserde(rename = "CumDvddInd")]
#[cfg_attr(feature = "serde", serde(rename = "CumDvddInd"))]
pub cum_dvdd_ind: YesNoIndicator,
#[yaserde(rename = "IntrmPrftAmt")]
#[cfg_attr(feature = "serde", serde(rename = "IntrmPrftAmt"))]
pub intrm_prft_amt: ProfitAndLoss2Choice,
#[yaserde(rename = "IncmPref")]
#[cfg_attr(feature = "serde", serde(rename = "IncmPref"))]
pub incm_pref: IncomePreference1Code,
#[yaserde(rename = "ReqdSttlmCcy")]
#[cfg_attr(feature = "serde", serde(rename = "ReqdSttlmCcy"))]
pub reqd_sttlm_ccy: ActiveCurrencyCode,
#[yaserde(rename = "ReqdNAVCcy")]
#[cfg_attr(feature = "serde", serde(rename = "ReqdNAVCcy"))]
pub reqd_nav_ccy: ActiveOrHistoricCurrencyCode,
#[yaserde(rename = "TxOvrhd")]
#[cfg_attr(feature = "serde", serde(rename = "TxOvrhd"))]
pub tx_ovrhd: TotalFeesAndTaxes44,
#[yaserde(rename = "InftvTaxDtls")]
#[cfg_attr(feature = "serde", serde(rename = "InftvTaxDtls"))]
pub inftv_tax_dtls: InformativeTax2,
#[yaserde(rename = "SttlmAndCtdyDtls")]
#[cfg_attr(feature = "serde", serde(rename = "SttlmAndCtdyDtls"))]
pub sttlm_and_ctdy_dtls: FundSettlementParameters28,
#[yaserde(rename = "PhysDlvryInd")]
#[cfg_attr(feature = "serde", serde(rename = "PhysDlvryInd"))]
pub phys_dlvry_ind: YesNoIndicator,
#[yaserde(rename = "PhysDlvryDtls")]
#[cfg_attr(feature = "serde", serde(rename = "PhysDlvryDtls"))]
pub phys_dlvry_dtls: DeliveryParameters3,
#[yaserde(rename = "DgtlAsstSttlm")]
#[cfg_attr(feature = "serde", serde(rename = "DgtlAsstSttlm"))]
pub dgtl_asst_sttlm: DigitalPaymentSettlement3,
#[yaserde(rename = "NonStdSttlmInf")]
#[cfg_attr(feature = "serde", serde(rename = "NonStdSttlmInf"))]
pub non_std_sttlm_inf: Max350Text,
#[yaserde(rename = "Equlstn")]
#[cfg_attr(feature = "serde", serde(rename = "Equlstn"))]
pub equlstn: Equalisation1,
}
impl Validate for SwitchSubscriptionLegExecution5 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
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:setr.015.001.05")]
pub struct Tax40 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: TaxType3Choice,
#[yaserde(rename = "InftvAmt")]
#[cfg_attr(feature = "serde", serde(rename = "InftvAmt"))]
pub inftv_amt: ActiveCurrencyAndAmount,
#[yaserde(rename = "InftvRate")]
#[cfg_attr(feature = "serde", serde(rename = "InftvRate"))]
pub inftv_rate: PercentageRate,
#[yaserde(rename = "Ctry")]
#[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
pub ctry: CountryCode,
#[yaserde(rename = "XmptnInd")]
#[cfg_attr(feature = "serde", serde(rename = "XmptnInd"))]
pub xmptn_ind: YesNoIndicator,
#[yaserde(rename = "XmptnRsn")]
#[cfg_attr(feature = "serde", serde(rename = "XmptnRsn"))]
pub xmptn_rsn: ExemptionReason1Choice,
#[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 Tax40 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
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:setr.015.001.05")]
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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub enum TaxExemptReason1Code {
#[yaserde(rename = "NONE")]
#[cfg_attr(feature = "serde", serde(rename = "NONE"))]
None,
#[yaserde(rename = "MASA")]
#[cfg_attr(feature = "serde", serde(rename = "MASA"))]
Masa,
#[yaserde(rename = "MISA")]
#[cfg_attr(feature = "serde", serde(rename = "MISA"))]
Misa,
#[yaserde(rename = "SISA")]
#[cfg_attr(feature = "serde", serde(rename = "SISA"))]
Sisa,
#[yaserde(rename = "IISA")]
#[cfg_attr(feature = "serde", serde(rename = "IISA"))]
Iisa,
#[yaserde(rename = "CUYP")]
#[cfg_attr(feature = "serde", serde(rename = "CUYP"))]
Cuyp,
#[yaserde(rename = "PRYP")]
#[cfg_attr(feature = "serde", serde(rename = "PRYP"))]
Pryp,
#[yaserde(rename = "ASTR")]
#[cfg_attr(feature = "serde", serde(rename = "ASTR"))]
Astr,
#[yaserde(rename = "EMPY")]
#[cfg_attr(feature = "serde", serde(rename = "EMPY"))]
Empy,
#[yaserde(rename = "EMCY")]
#[cfg_attr(feature = "serde", serde(rename = "EMCY"))]
Emcy,
#[yaserde(rename = "EPRY")]
#[cfg_attr(feature = "serde", serde(rename = "EPRY"))]
Epry,
#[yaserde(rename = "ECYE")]
#[cfg_attr(feature = "serde", serde(rename = "ECYE"))]
Ecye,
#[yaserde(rename = "NFPI")]
#[cfg_attr(feature = "serde", serde(rename = "NFPI"))]
Nfpi,
#[yaserde(rename = "NFQP")]
#[cfg_attr(feature = "serde", serde(rename = "NFQP"))]
Nfqp,
#[yaserde(rename = "DECP")]
#[cfg_attr(feature = "serde", serde(rename = "DECP"))]
Decp,
#[yaserde(rename = "IRAC")]
#[cfg_attr(feature = "serde", serde(rename = "IRAC"))]
Irac,
#[yaserde(rename = "IRAR")]
#[cfg_attr(feature = "serde", serde(rename = "IRAR"))]
Irar,
#[yaserde(rename = "KEOG")]
#[cfg_attr(feature = "serde", serde(rename = "KEOG"))]
Keog,
#[yaserde(rename = "PFSP")]
#[cfg_attr(feature = "serde", serde(rename = "PFSP"))]
Pfsp,
#[yaserde(rename = "401K")]
#[cfg_attr(feature = "serde", serde(rename = "401K"))]
_401K,
#[yaserde(rename = "SIRA")]
#[cfg_attr(feature = "serde", serde(rename = "SIRA"))]
Sira,
#[yaserde(rename = "403B")]
#[cfg_attr(feature = "serde", serde(rename = "403B"))]
_403B,
#[yaserde(rename = "457X")]
#[cfg_attr(feature = "serde", serde(rename = "457X"))]
_457X,
#[yaserde(rename = "RIRA")]
#[cfg_attr(feature = "serde", serde(rename = "RIRA"))]
Rira,
#[yaserde(rename = "RIAN")]
#[cfg_attr(feature = "serde", serde(rename = "RIAN"))]
Rian,
#[yaserde(rename = "RCRF")]
#[cfg_attr(feature = "serde", serde(rename = "RCRF"))]
Rcrf,
#[yaserde(rename = "RCIP")]
#[cfg_attr(feature = "serde", serde(rename = "RCIP"))]
Rcip,
#[yaserde(rename = "EIFP")]
#[cfg_attr(feature = "serde", serde(rename = "EIFP"))]
Eifp,
#[yaserde(rename = "EIOP")]
#[cfg_attr(feature = "serde", serde(rename = "EIOP"))]
Eiop,
__Unknown__(String),
}
impl Default for TaxExemptReason1Code {
fn default() -> TaxExemptReason1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for TaxExemptReason1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
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:setr.015.001.05")]
pub struct TaxType3Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<TaxType17Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification47>,
}
impl Validate for TaxType3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
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:setr.015.001.05")]
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:setr.015.001.05")]
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:setr.015.001.05")]
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:setr.015.001.05")]
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:setr.015.001.05")]
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:setr.015.001.05")]
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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub enum TradingCapacity8Code {
#[yaserde(rename = "AGEN")]
#[cfg_attr(feature = "serde", serde(rename = "AGEN"))]
Agen,
#[yaserde(rename = "PRIN")]
#[cfg_attr(feature = "serde", serde(rename = "PRIN"))]
Prin,
__Unknown__(String),
}
impl Default for TradingCapacity8Code {
fn default() -> TradingCapacity8Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for TradingCapacity8Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub enum TransactionChannel2Code {
#[yaserde(rename = "FIAD")]
#[cfg_attr(feature = "serde", serde(rename = "FIAD"))]
Fiad,
#[yaserde(rename = "HOBA")]
#[cfg_attr(feature = "serde", serde(rename = "HOBA"))]
Hoba,
#[yaserde(rename = "BRAN")]
#[cfg_attr(feature = "serde", serde(rename = "BRAN"))]
Bran,
__Unknown__(String),
}
impl Default for TransactionChannel2Code {
fn default() -> TransactionChannel2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for TransactionChannel2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
pub struct TransactionChannelType1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<TransactionChannel2Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification47>,
}
impl Validate for TransactionChannelType1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:setr.015.001.05")]
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:setr.015.001.05")]
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:setr.015.001.05")]
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:setr.015.001.05")]
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:setr.015.001.05")]
pub struct UnitPrice22 {
#[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 = "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,
#[yaserde(rename = "PricDiffRsn")]
#[cfg_attr(feature = "serde", serde(rename = "PricDiffRsn"))]
pub pric_diff_rsn: Max350Text,
}
impl Validate for UnitPrice22 {}
#[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:setr.015.001.05")]
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:setr.015.001.05")]
pub struct WaivingInstruction2Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<WaivingInstruction1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification47>,
}
impl Validate for WaivingInstruction2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct WertpapierIdentifier (pub String);
crate::simple_type!(WertpapierIdentifier);
impl Validate for WertpapierIdentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct YesNoIndicator (pub bool);
crate::simple_type!(YesNoIndicator);
impl Validate for YesNoIndicator {}
impl crate::MxMessage for Document {
const BUSINESS_AREA: crate::BusinessArea = crate::BusinessArea::setr;
const FUNCTIONALITY: &'static str = "015";
const VARIANT: &'static str = "001";
const VERSION: &'static str = "05";
const MESSAGE_NAME: &'static str = "setr.015.001.05";
const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:setr.015.001.05";
}