#![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:camt.052.001.09")]
pub struct AccountIdentification4Choice {
#[yaserde(rename = "IBAN")]
#[cfg_attr(feature = "serde", serde(rename = "IBAN"))]
pub iban: Option<Iban2007Identifier>,
#[yaserde(rename = "Othr")]
#[cfg_attr(feature = "serde", serde(rename = "Othr"))]
pub othr: Option<GenericAccountIdentification1>,
}
impl Validate for AccountIdentification4Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct AccountInterest4 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: InterestType1Choice,
#[yaserde(rename = "Rate")]
#[cfg_attr(feature = "serde", serde(rename = "Rate"))]
pub rate: Vec<Rate4>,
#[yaserde(rename = "FrToDt")]
#[cfg_attr(feature = "serde", serde(rename = "FrToDt"))]
pub fr_to_dt: DateTimePeriod1,
#[yaserde(rename = "Rsn")]
#[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
pub rsn: Max35Text,
#[yaserde(rename = "Tax")]
#[cfg_attr(feature = "serde", serde(rename = "Tax"))]
pub tax: TaxCharges2,
}
impl Validate for AccountInterest4 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct AccountReport30 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max35Text,
#[yaserde(rename = "RptPgntn")]
#[cfg_attr(feature = "serde", serde(rename = "RptPgntn"))]
pub rpt_pgntn: Pagination1,
#[yaserde(rename = "ElctrncSeqNb")]
#[cfg_attr(feature = "serde", serde(rename = "ElctrncSeqNb"))]
pub elctrnc_seq_nb: Number,
#[yaserde(rename = "RptgSeq")]
#[cfg_attr(feature = "serde", serde(rename = "RptgSeq"))]
pub rptg_seq: SequenceRange1Choice,
#[yaserde(rename = "LglSeqNb")]
#[cfg_attr(feature = "serde", serde(rename = "LglSeqNb"))]
pub lgl_seq_nb: Number,
#[yaserde(rename = "CreDtTm")]
#[cfg_attr(feature = "serde", serde(rename = "CreDtTm"))]
pub cre_dt_tm: IsodateTime,
#[yaserde(rename = "FrToDt")]
#[cfg_attr(feature = "serde", serde(rename = "FrToDt"))]
pub fr_to_dt: DateTimePeriod1,
#[yaserde(rename = "CpyDplctInd")]
#[cfg_attr(feature = "serde", serde(rename = "CpyDplctInd"))]
pub cpy_dplct_ind: CopyDuplicate1Code,
#[yaserde(rename = "RptgSrc")]
#[cfg_attr(feature = "serde", serde(rename = "RptgSrc"))]
pub rptg_src: ReportingSource1Choice,
#[yaserde(rename = "Acct")]
#[cfg_attr(feature = "serde", serde(rename = "Acct"))]
pub acct: CashAccount41,
#[yaserde(rename = "RltdAcct")]
#[cfg_attr(feature = "serde", serde(rename = "RltdAcct"))]
pub rltd_acct: CashAccount40,
#[yaserde(rename = "Intrst")]
#[cfg_attr(feature = "serde", serde(rename = "Intrst"))]
pub intrst: Vec<AccountInterest4>,
#[yaserde(rename = "Bal")]
#[cfg_attr(feature = "serde", serde(rename = "Bal"))]
pub bal: Vec<CashBalance8>,
#[yaserde(rename = "TxsSummry")]
#[cfg_attr(feature = "serde", serde(rename = "TxsSummry"))]
pub txs_summry: TotalTransactions6,
#[yaserde(rename = "Ntry")]
#[cfg_attr(feature = "serde", serde(rename = "Ntry"))]
pub ntry: Vec<ReportEntry11>,
#[yaserde(rename = "AddtlRptInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlRptInf"))]
pub addtl_rpt_inf: Max500Text,
}
impl Validate for AccountReport30 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
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 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:camt.052.001.09")]
pub struct ActiveCurrencyAndAmount {
#[yaserde(text)]
pub value: String,
#[yaserde(attribute, rename = "Ccy")]
#[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
pub ccy: ActiveCurrencyCode,
}
impl Validate for ActiveCurrencyAndAmount {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ActiveCurrencyCode (pub String);
crate::simple_type!(ActiveCurrencyCode);
impl Validate for ActiveCurrencyCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ActiveOrHistoricCurrencyAnd13DecimalAmountSimpleType (pub String);
crate::simple_type!(ActiveOrHistoricCurrencyAnd13DecimalAmountSimpleType);
impl Validate for ActiveOrHistoricCurrencyAnd13DecimalAmountSimpleType {
fn validate(&self) -> Result<(), String> {
if self.0 < "0".parse::<String>().unwrap() {
return Err(format!("MinInclusive validation error: invalid value of 0! \nExpected: 0 >= 0.\nActual: 0 == {}", self.0));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct ActiveOrHistoricCurrencyAnd13DecimalAmount {
#[yaserde(text)]
pub value: String,
#[yaserde(attribute, rename = "Ccy")]
#[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
pub ccy: ActiveOrHistoricCurrencyCode,
}
impl Validate for ActiveOrHistoricCurrencyAnd13DecimalAmount {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ActiveOrHistoricCurrencyAndAmountSimpleType (pub String);
crate::simple_type!(ActiveOrHistoricCurrencyAndAmountSimpleType);
impl Validate for ActiveOrHistoricCurrencyAndAmountSimpleType {
fn validate(&self) -> Result<(), String> {
if self.0 < "0".parse::<String>().unwrap() {
return Err(format!("MinInclusive validation error: invalid value of 0! \nExpected: 0 >= 0.\nActual: 0 == {}", self.0));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct ActiveOrHistoricCurrencyAndAmountRange2 {
#[yaserde(rename = "Amt")]
#[cfg_attr(feature = "serde", serde(rename = "Amt"))]
pub amt: ImpliedCurrencyAmountRange1Choice,
#[yaserde(rename = "CdtDbtInd")]
#[cfg_attr(feature = "serde", serde(rename = "CdtDbtInd"))]
pub cdt_dbt_ind: CreditDebitCode,
#[yaserde(rename = "Ccy")]
#[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
pub ccy: ActiveOrHistoricCurrencyCode,
}
impl Validate for ActiveOrHistoricCurrencyAndAmountRange2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ActiveOrHistoricCurrencyCode (pub String);
crate::simple_type!(ActiveOrHistoricCurrencyCode);
impl Validate for ActiveOrHistoricCurrencyCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
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:camt.052.001.09")]
pub struct AddressType3Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<AddressType2Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification30>,
}
impl Validate for AddressType3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct AmountAndCurrencyExchange3 {
#[yaserde(rename = "InstdAmt")]
#[cfg_attr(feature = "serde", serde(rename = "InstdAmt"))]
pub instd_amt: AmountAndCurrencyExchangeDetails3,
#[yaserde(rename = "TxAmt")]
#[cfg_attr(feature = "serde", serde(rename = "TxAmt"))]
pub tx_amt: AmountAndCurrencyExchangeDetails3,
#[yaserde(rename = "CntrValAmt")]
#[cfg_attr(feature = "serde", serde(rename = "CntrValAmt"))]
pub cntr_val_amt: AmountAndCurrencyExchangeDetails3,
#[yaserde(rename = "AnncdPstngAmt")]
#[cfg_attr(feature = "serde", serde(rename = "AnncdPstngAmt"))]
pub anncd_pstng_amt: AmountAndCurrencyExchangeDetails3,
#[yaserde(rename = "PrtryAmt")]
#[cfg_attr(feature = "serde", serde(rename = "PrtryAmt"))]
pub prtry_amt: Vec<AmountAndCurrencyExchangeDetails4>,
}
impl Validate for AmountAndCurrencyExchange3 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct AmountAndCurrencyExchangeDetails3 {
#[yaserde(rename = "Amt")]
#[cfg_attr(feature = "serde", serde(rename = "Amt"))]
pub amt: ActiveOrHistoricCurrencyAndAmount,
#[yaserde(rename = "CcyXchg")]
#[cfg_attr(feature = "serde", serde(rename = "CcyXchg"))]
pub ccy_xchg: CurrencyExchange5,
}
impl Validate for AmountAndCurrencyExchangeDetails3 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct AmountAndCurrencyExchangeDetails4 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: Max35Text,
#[yaserde(rename = "Amt")]
#[cfg_attr(feature = "serde", serde(rename = "Amt"))]
pub amt: ActiveOrHistoricCurrencyAndAmount,
#[yaserde(rename = "CcyXchg")]
#[cfg_attr(feature = "serde", serde(rename = "CcyXchg"))]
pub ccy_xchg: CurrencyExchange5,
}
impl Validate for AmountAndCurrencyExchangeDetails4 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct AmountAndDirection35 {
#[yaserde(rename = "Amt")]
#[cfg_attr(feature = "serde", serde(rename = "Amt"))]
pub amt: NonNegativeDecimalNumber,
#[yaserde(rename = "CdtDbtInd")]
#[cfg_attr(feature = "serde", serde(rename = "CdtDbtInd"))]
pub cdt_dbt_ind: CreditDebitCode,
}
impl Validate for AmountAndDirection35 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct AmountRangeBoundary1 {
#[yaserde(rename = "BdryAmt")]
#[cfg_attr(feature = "serde", serde(rename = "BdryAmt"))]
pub bdry_amt: ImpliedCurrencyAndAmount,
#[yaserde(rename = "Incl")]
#[cfg_attr(feature = "serde", serde(rename = "Incl"))]
pub incl: YesNoIndicator,
}
impl Validate for AmountRangeBoundary1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct AnyBICDec2014Identifier (pub String);
crate::simple_type!(AnyBICDec2014Identifier);
impl Validate for AnyBICDec2014Identifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub enum AttendanceContext1Code {
#[yaserde(rename = "ATTD")]
#[cfg_attr(feature = "serde", serde(rename = "ATTD"))]
Attd,
#[yaserde(rename = "SATT")]
#[cfg_attr(feature = "serde", serde(rename = "SATT"))]
Satt,
#[yaserde(rename = "UATT")]
#[cfg_attr(feature = "serde", serde(rename = "UATT"))]
Uatt,
__Unknown__(String),
}
impl Default for AttendanceContext1Code {
fn default() -> AttendanceContext1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AttendanceContext1Code {}
#[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:camt.052.001.09")]
pub enum AuthenticationEntity1Code {
#[yaserde(rename = "ICCD")]
#[cfg_attr(feature = "serde", serde(rename = "ICCD"))]
Iccd,
#[yaserde(rename = "AGNT")]
#[cfg_attr(feature = "serde", serde(rename = "AGNT"))]
Agnt,
#[yaserde(rename = "MERC")]
#[cfg_attr(feature = "serde", serde(rename = "MERC"))]
Merc,
__Unknown__(String),
}
impl Default for AuthenticationEntity1Code {
fn default() -> AuthenticationEntity1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AuthenticationEntity1Code {}
#[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:camt.052.001.09")]
pub enum AuthenticationMethod1Code {
#[yaserde(rename = "UKNW")]
#[cfg_attr(feature = "serde", serde(rename = "UKNW"))]
Uknw,
#[yaserde(rename = "BYPS")]
#[cfg_attr(feature = "serde", serde(rename = "BYPS"))]
Byps,
#[yaserde(rename = "NPIN")]
#[cfg_attr(feature = "serde", serde(rename = "NPIN"))]
Npin,
#[yaserde(rename = "FPIN")]
#[cfg_attr(feature = "serde", serde(rename = "FPIN"))]
Fpin,
#[yaserde(rename = "CPSG")]
#[cfg_attr(feature = "serde", serde(rename = "CPSG"))]
Cpsg,
#[yaserde(rename = "PPSG")]
#[cfg_attr(feature = "serde", serde(rename = "PPSG"))]
Ppsg,
#[yaserde(rename = "MANU")]
#[cfg_attr(feature = "serde", serde(rename = "MANU"))]
Manu,
#[yaserde(rename = "MERC")]
#[cfg_attr(feature = "serde", serde(rename = "MERC"))]
Merc,
#[yaserde(rename = "SCRT")]
#[cfg_attr(feature = "serde", serde(rename = "SCRT"))]
Scrt,
#[yaserde(rename = "SNCT")]
#[cfg_attr(feature = "serde", serde(rename = "SNCT"))]
Snct,
#[yaserde(rename = "SCNL")]
#[cfg_attr(feature = "serde", serde(rename = "SCNL"))]
Scnl,
__Unknown__(String),
}
impl Default for AuthenticationMethod1Code {
fn default() -> AuthenticationMethod1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AuthenticationMethod1Code {}
#[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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct BalanceSubType1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<ExternalBalanceSubType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<Max35Text>,
}
impl Validate for BalanceSubType1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct BalanceType10Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<ExternalBalanceType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<Max35Text>,
}
impl Validate for BalanceType10Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct BalanceType13 {
#[yaserde(rename = "CdOrPrtry")]
#[cfg_attr(feature = "serde", serde(rename = "CdOrPrtry"))]
pub cd_or_prtry: BalanceType10Choice,
#[yaserde(rename = "SubTp")]
#[cfg_attr(feature = "serde", serde(rename = "SubTp"))]
pub sub_tp: BalanceSubType1Choice,
}
impl Validate for BalanceType13 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct BankToCustomerAccountReportV09 {
#[yaserde(rename = "GrpHdr")]
#[cfg_attr(feature = "serde", serde(rename = "GrpHdr"))]
pub grp_hdr: GroupHeader81,
#[yaserde(rename = "Rpt")]
#[cfg_attr(feature = "serde", serde(rename = "Rpt"))]
pub rpt: Vec<AccountReport30>,
#[yaserde(rename = "SplmtryData")]
#[cfg_attr(feature = "serde", serde(rename = "SplmtryData"))]
pub splmtry_data: Vec<SupplementaryData1>,
}
impl Validate for BankToCustomerAccountReportV09 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct BankTransactionCodeStructure4 {
#[yaserde(rename = "Domn")]
#[cfg_attr(feature = "serde", serde(rename = "Domn"))]
pub domn: BankTransactionCodeStructure5,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: ProprietaryBankTransactionCodeStructure1,
}
impl Validate for BankTransactionCodeStructure4 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct BankTransactionCodeStructure5 {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: ExternalBankTransactionDomain1Code,
#[yaserde(rename = "Fmly")]
#[cfg_attr(feature = "serde", serde(rename = "Fmly"))]
pub fmly: BankTransactionCodeStructure6,
}
impl Validate for BankTransactionCodeStructure5 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct BankTransactionCodeStructure6 {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: ExternalBankTransactionFamily1Code,
#[yaserde(rename = "SubFmlyCd")]
#[cfg_attr(feature = "serde", serde(rename = "SubFmlyCd"))]
pub sub_fmly_cd: ExternalBankTransactionSubFamily1Code,
}
impl Validate for BankTransactionCodeStructure6 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct BaseOneRate (pub String);
crate::simple_type!(BaseOneRate);
impl Validate for BaseOneRate {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct BatchInformation2 {
#[yaserde(rename = "MsgId")]
#[cfg_attr(feature = "serde", serde(rename = "MsgId"))]
pub msg_id: Max35Text,
#[yaserde(rename = "PmtInfId")]
#[cfg_attr(feature = "serde", serde(rename = "PmtInfId"))]
pub pmt_inf_id: Max35Text,
#[yaserde(rename = "NbOfTxs")]
#[cfg_attr(feature = "serde", serde(rename = "NbOfTxs"))]
pub nb_of_txs: Max15NumericText,
#[yaserde(rename = "TtlAmt")]
#[cfg_attr(feature = "serde", serde(rename = "TtlAmt"))]
pub ttl_amt: ActiveOrHistoricCurrencyAndAmount,
#[yaserde(rename = "CdtDbtInd")]
#[cfg_attr(feature = "serde", serde(rename = "CdtDbtInd"))]
pub cdt_dbt_ind: CreditDebitCode,
}
impl Validate for BatchInformation2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct BranchAndFinancialInstitutionIdentification6 {
#[yaserde(rename = "FinInstnId")]
#[cfg_attr(feature = "serde", serde(rename = "FinInstnId"))]
pub fin_instn_id: FinancialInstitutionIdentification18,
#[yaserde(rename = "BrnchId")]
#[cfg_attr(feature = "serde", serde(rename = "BrnchId"))]
pub brnch_id: BranchData3,
}
impl Validate for BranchAndFinancialInstitutionIdentification6 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct BranchData3 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max35Text,
#[yaserde(rename = "LEI")]
#[cfg_attr(feature = "serde", serde(rename = "LEI"))]
pub lei: Leiidentifier,
#[yaserde(rename = "Nm")]
#[cfg_attr(feature = "serde", serde(rename = "Nm"))]
pub nm: Max140Text,
#[yaserde(rename = "PstlAdr")]
#[cfg_attr(feature = "serde", serde(rename = "PstlAdr"))]
pub pstl_adr: PostalAddress24,
}
impl Validate for BranchData3 {}
#[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:camt.052.001.09")]
pub enum Cscmanagement1Code {
#[yaserde(rename = "PRST")]
#[cfg_attr(feature = "serde", serde(rename = "PRST"))]
Prst,
#[yaserde(rename = "BYPS")]
#[cfg_attr(feature = "serde", serde(rename = "BYPS"))]
Byps,
#[yaserde(rename = "UNRD")]
#[cfg_attr(feature = "serde", serde(rename = "UNRD"))]
Unrd,
#[yaserde(rename = "NCSC")]
#[cfg_attr(feature = "serde", serde(rename = "NCSC"))]
Ncsc,
__Unknown__(String),
}
impl Default for Cscmanagement1Code {
fn default() -> Cscmanagement1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for Cscmanagement1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct CardAggregated2 {
#[yaserde(rename = "AddtlSvc")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlSvc"))]
pub addtl_svc: CardPaymentServiceType2Code,
#[yaserde(rename = "TxCtgy")]
#[cfg_attr(feature = "serde", serde(rename = "TxCtgy"))]
pub tx_ctgy: ExternalCardTransactionCategory1Code,
#[yaserde(rename = "SaleRcncltnId")]
#[cfg_attr(feature = "serde", serde(rename = "SaleRcncltnId"))]
pub sale_rcncltn_id: Max35Text,
#[yaserde(rename = "SeqNbRg")]
#[cfg_attr(feature = "serde", serde(rename = "SeqNbRg"))]
pub seq_nb_rg: CardSequenceNumberRange1,
#[yaserde(rename = "TxDtRg")]
#[cfg_attr(feature = "serde", serde(rename = "TxDtRg"))]
pub tx_dt_rg: DateOrDateTimePeriod1Choice,
}
impl Validate for CardAggregated2 {}
#[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:camt.052.001.09")]
pub enum CardDataReading1Code {
#[yaserde(rename = "TAGC")]
#[cfg_attr(feature = "serde", serde(rename = "TAGC"))]
Tagc,
#[yaserde(rename = "PHYS")]
#[cfg_attr(feature = "serde", serde(rename = "PHYS"))]
Phys,
#[yaserde(rename = "BRCD")]
#[cfg_attr(feature = "serde", serde(rename = "BRCD"))]
Brcd,
#[yaserde(rename = "MGST")]
#[cfg_attr(feature = "serde", serde(rename = "MGST"))]
Mgst,
#[yaserde(rename = "CICC")]
#[cfg_attr(feature = "serde", serde(rename = "CICC"))]
Cicc,
#[yaserde(rename = "DFLE")]
#[cfg_attr(feature = "serde", serde(rename = "DFLE"))]
Dfle,
#[yaserde(rename = "CTLS")]
#[cfg_attr(feature = "serde", serde(rename = "CTLS"))]
Ctls,
#[yaserde(rename = "ECTL")]
#[cfg_attr(feature = "serde", serde(rename = "ECTL"))]
Ectl,
__Unknown__(String),
}
impl Default for CardDataReading1Code {
fn default() -> CardDataReading1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for CardDataReading1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct CardEntry5 {
#[yaserde(rename = "Card")]
#[cfg_attr(feature = "serde", serde(rename = "Card"))]
pub card: PaymentCard4,
#[yaserde(rename = "POI")]
#[cfg_attr(feature = "serde", serde(rename = "POI"))]
pub poi: PointOfInteraction1,
#[yaserde(rename = "AggtdNtry")]
#[cfg_attr(feature = "serde", serde(rename = "AggtdNtry"))]
pub aggtd_ntry: CardAggregated2,
#[yaserde(rename = "PrePdAcct")]
#[cfg_attr(feature = "serde", serde(rename = "PrePdAcct"))]
pub pre_pd_acct: CashAccount40,
}
impl Validate for CardEntry5 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct CardIndividualTransaction2 {
#[yaserde(rename = "ICCRltdData")]
#[cfg_attr(feature = "serde", serde(rename = "ICCRltdData"))]
pub icc_rltd_data: Max1025Text,
#[yaserde(rename = "PmtCntxt")]
#[cfg_attr(feature = "serde", serde(rename = "PmtCntxt"))]
pub pmt_cntxt: PaymentContext3,
#[yaserde(rename = "AddtlSvc")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlSvc"))]
pub addtl_svc: CardPaymentServiceType2Code,
#[yaserde(rename = "TxCtgy")]
#[cfg_attr(feature = "serde", serde(rename = "TxCtgy"))]
pub tx_ctgy: ExternalCardTransactionCategory1Code,
#[yaserde(rename = "SaleRcncltnId")]
#[cfg_attr(feature = "serde", serde(rename = "SaleRcncltnId"))]
pub sale_rcncltn_id: Max35Text,
#[yaserde(rename = "SaleRefNb")]
#[cfg_attr(feature = "serde", serde(rename = "SaleRefNb"))]
pub sale_ref_nb: Max35Text,
#[yaserde(rename = "RePresntmntRsn")]
#[cfg_attr(feature = "serde", serde(rename = "RePresntmntRsn"))]
pub re_presntmnt_rsn: ExternalRePresentmentReason1Code,
#[yaserde(rename = "SeqNb")]
#[cfg_attr(feature = "serde", serde(rename = "SeqNb"))]
pub seq_nb: Max35Text,
#[yaserde(rename = "TxId")]
#[cfg_attr(feature = "serde", serde(rename = "TxId"))]
pub tx_id: TransactionIdentifier1,
#[yaserde(rename = "Pdct")]
#[cfg_attr(feature = "serde", serde(rename = "Pdct"))]
pub pdct: Product2,
#[yaserde(rename = "VldtnDt")]
#[cfg_attr(feature = "serde", serde(rename = "VldtnDt"))]
pub vldtn_dt: Isodate,
#[yaserde(rename = "VldtnSeqNb")]
#[cfg_attr(feature = "serde", serde(rename = "VldtnSeqNb"))]
pub vldtn_seq_nb: Max35Text,
}
impl Validate for CardIndividualTransaction2 {}
#[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:camt.052.001.09")]
pub enum CardPaymentServiceType2Code {
#[yaserde(rename = "AGGR")]
#[cfg_attr(feature = "serde", serde(rename = "AGGR"))]
Aggr,
#[yaserde(rename = "DCCV")]
#[cfg_attr(feature = "serde", serde(rename = "DCCV"))]
Dccv,
#[yaserde(rename = "GRTT")]
#[cfg_attr(feature = "serde", serde(rename = "GRTT"))]
Grtt,
#[yaserde(rename = "INSP")]
#[cfg_attr(feature = "serde", serde(rename = "INSP"))]
Insp,
#[yaserde(rename = "LOYT")]
#[cfg_attr(feature = "serde", serde(rename = "LOYT"))]
Loyt,
#[yaserde(rename = "NRES")]
#[cfg_attr(feature = "serde", serde(rename = "NRES"))]
Nres,
#[yaserde(rename = "PUCO")]
#[cfg_attr(feature = "serde", serde(rename = "PUCO"))]
Puco,
#[yaserde(rename = "RECP")]
#[cfg_attr(feature = "serde", serde(rename = "RECP"))]
Recp,
#[yaserde(rename = "SOAF")]
#[cfg_attr(feature = "serde", serde(rename = "SOAF"))]
Soaf,
#[yaserde(rename = "UNAF")]
#[cfg_attr(feature = "serde", serde(rename = "UNAF"))]
Unaf,
#[yaserde(rename = "VCAU")]
#[cfg_attr(feature = "serde", serde(rename = "VCAU"))]
Vcau,
__Unknown__(String),
}
impl Default for CardPaymentServiceType2Code {
fn default() -> CardPaymentServiceType2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for CardPaymentServiceType2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct CardSecurityInformation1 {
#[yaserde(rename = "CSCMgmt")]
#[cfg_attr(feature = "serde", serde(rename = "CSCMgmt"))]
pub csc_mgmt: Cscmanagement1Code,
#[yaserde(rename = "CSCVal")]
#[cfg_attr(feature = "serde", serde(rename = "CSCVal"))]
pub csc_val: Min3Max4NumericText,
}
impl Validate for CardSecurityInformation1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct CardSequenceNumberRange1 {
#[yaserde(rename = "FrstTx")]
#[cfg_attr(feature = "serde", serde(rename = "FrstTx"))]
pub frst_tx: Max35Text,
#[yaserde(rename = "LastTx")]
#[cfg_attr(feature = "serde", serde(rename = "LastTx"))]
pub last_tx: Max35Text,
}
impl Validate for CardSequenceNumberRange1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct CardTransaction18 {
#[yaserde(rename = "Card")]
#[cfg_attr(feature = "serde", serde(rename = "Card"))]
pub card: PaymentCard4,
#[yaserde(rename = "POI")]
#[cfg_attr(feature = "serde", serde(rename = "POI"))]
pub poi: PointOfInteraction1,
#[yaserde(rename = "Tx")]
#[cfg_attr(feature = "serde", serde(rename = "Tx"))]
pub tx: CardTransaction3Choice,
#[yaserde(rename = "PrePdAcct")]
#[cfg_attr(feature = "serde", serde(rename = "PrePdAcct"))]
pub pre_pd_acct: CashAccount40,
}
impl Validate for CardTransaction18 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct CardTransaction3Choice {
#[yaserde(rename = "Aggtd")]
#[cfg_attr(feature = "serde", serde(rename = "Aggtd"))]
pub aggtd: Option<CardAggregated2>,
#[yaserde(rename = "Indv")]
#[cfg_attr(feature = "serde", serde(rename = "Indv"))]
pub indv: Option<CardIndividualTransaction2>,
}
impl Validate for CardTransaction3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct CardholderAuthentication2 {
#[yaserde(rename = "AuthntcnMtd")]
#[cfg_attr(feature = "serde", serde(rename = "AuthntcnMtd"))]
pub authntcn_mtd: AuthenticationMethod1Code,
#[yaserde(rename = "AuthntcnNtty")]
#[cfg_attr(feature = "serde", serde(rename = "AuthntcnNtty"))]
pub authntcn_ntty: AuthenticationEntity1Code,
}
impl Validate for CardholderAuthentication2 {}
#[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:camt.052.001.09")]
pub enum CardholderVerificationCapability1Code {
#[yaserde(rename = "MNSG")]
#[cfg_attr(feature = "serde", serde(rename = "MNSG"))]
Mnsg,
#[yaserde(rename = "NPIN")]
#[cfg_attr(feature = "serde", serde(rename = "NPIN"))]
Npin,
#[yaserde(rename = "FCPN")]
#[cfg_attr(feature = "serde", serde(rename = "FCPN"))]
Fcpn,
#[yaserde(rename = "FEPN")]
#[cfg_attr(feature = "serde", serde(rename = "FEPN"))]
Fepn,
#[yaserde(rename = "FDSG")]
#[cfg_attr(feature = "serde", serde(rename = "FDSG"))]
Fdsg,
#[yaserde(rename = "FBIO")]
#[cfg_attr(feature = "serde", serde(rename = "FBIO"))]
Fbio,
#[yaserde(rename = "MNVR")]
#[cfg_attr(feature = "serde", serde(rename = "MNVR"))]
Mnvr,
#[yaserde(rename = "FBIG")]
#[cfg_attr(feature = "serde", serde(rename = "FBIG"))]
Fbig,
#[yaserde(rename = "APKI")]
#[cfg_attr(feature = "serde", serde(rename = "APKI"))]
Apki,
#[yaserde(rename = "PKIS")]
#[cfg_attr(feature = "serde", serde(rename = "PKIS"))]
Pkis,
#[yaserde(rename = "CHDT")]
#[cfg_attr(feature = "serde", serde(rename = "CHDT"))]
Chdt,
#[yaserde(rename = "SCEC")]
#[cfg_attr(feature = "serde", serde(rename = "SCEC"))]
Scec,
__Unknown__(String),
}
impl Default for CardholderVerificationCapability1Code {
fn default() -> CardholderVerificationCapability1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for CardholderVerificationCapability1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct CashAccount40 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: AccountIdentification4Choice,
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: CashAccountType2Choice,
#[yaserde(rename = "Ccy")]
#[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
pub ccy: ActiveOrHistoricCurrencyCode,
#[yaserde(rename = "Nm")]
#[cfg_attr(feature = "serde", serde(rename = "Nm"))]
pub nm: Max70Text,
#[yaserde(rename = "Prxy")]
#[cfg_attr(feature = "serde", serde(rename = "Prxy"))]
pub prxy: ProxyAccountIdentification1,
}
impl Validate for CashAccount40 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct CashAccount41 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: AccountIdentification4Choice,
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: CashAccountType2Choice,
#[yaserde(rename = "Ccy")]
#[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
pub ccy: ActiveOrHistoricCurrencyCode,
#[yaserde(rename = "Nm")]
#[cfg_attr(feature = "serde", serde(rename = "Nm"))]
pub nm: Max70Text,
#[yaserde(rename = "Prxy")]
#[cfg_attr(feature = "serde", serde(rename = "Prxy"))]
pub prxy: ProxyAccountIdentification1,
#[yaserde(rename = "Ownr")]
#[cfg_attr(feature = "serde", serde(rename = "Ownr"))]
pub ownr: PartyIdentification135,
#[yaserde(rename = "Svcr")]
#[cfg_attr(feature = "serde", serde(rename = "Svcr"))]
pub svcr: BranchAndFinancialInstitutionIdentification6,
}
impl Validate for CashAccount41 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct CashAccountType2Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<ExternalCashAccountType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<Max35Text>,
}
impl Validate for CashAccountType2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct CashAvailability1 {
#[yaserde(rename = "Dt")]
#[cfg_attr(feature = "serde", serde(rename = "Dt"))]
pub dt: CashAvailabilityDate1Choice,
#[yaserde(rename = "Amt")]
#[cfg_attr(feature = "serde", serde(rename = "Amt"))]
pub amt: ActiveOrHistoricCurrencyAndAmount,
#[yaserde(rename = "CdtDbtInd")]
#[cfg_attr(feature = "serde", serde(rename = "CdtDbtInd"))]
pub cdt_dbt_ind: CreditDebitCode,
}
impl Validate for CashAvailability1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct CashAvailabilityDate1Choice {
#[yaserde(rename = "NbOfDays")]
#[cfg_attr(feature = "serde", serde(rename = "NbOfDays"))]
pub nb_of_days: Option<Max15PlusSignedNumericText>,
#[yaserde(rename = "ActlDt")]
#[cfg_attr(feature = "serde", serde(rename = "ActlDt"))]
pub actl_dt: Option<Isodate>,
}
impl Validate for CashAvailabilityDate1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct CashBalance8 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: BalanceType13,
#[yaserde(rename = "CdtLine")]
#[cfg_attr(feature = "serde", serde(rename = "CdtLine"))]
pub cdt_line: Vec<CreditLine3>,
#[yaserde(rename = "Amt")]
#[cfg_attr(feature = "serde", serde(rename = "Amt"))]
pub amt: ActiveOrHistoricCurrencyAndAmount,
#[yaserde(rename = "CdtDbtInd")]
#[cfg_attr(feature = "serde", serde(rename = "CdtDbtInd"))]
pub cdt_dbt_ind: CreditDebitCode,
#[yaserde(rename = "Dt")]
#[cfg_attr(feature = "serde", serde(rename = "Dt"))]
pub dt: DateAndDateTime2Choice,
#[yaserde(rename = "Avlbty")]
#[cfg_attr(feature = "serde", serde(rename = "Avlbty"))]
pub avlbty: Vec<CashAvailability1>,
}
impl Validate for CashBalance8 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct CashDeposit1 {
#[yaserde(rename = "NoteDnmtn")]
#[cfg_attr(feature = "serde", serde(rename = "NoteDnmtn"))]
pub note_dnmtn: ActiveCurrencyAndAmount,
#[yaserde(rename = "NbOfNotes")]
#[cfg_attr(feature = "serde", serde(rename = "NbOfNotes"))]
pub nb_of_notes: Max15NumericText,
#[yaserde(rename = "Amt")]
#[cfg_attr(feature = "serde", serde(rename = "Amt"))]
pub amt: ActiveCurrencyAndAmount,
}
impl Validate for CashDeposit1 {}
#[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:camt.052.001.09")]
pub enum ChargeBearerType1Code {
#[yaserde(rename = "DEBT")]
#[cfg_attr(feature = "serde", serde(rename = "DEBT"))]
Debt,
#[yaserde(rename = "CRED")]
#[cfg_attr(feature = "serde", serde(rename = "CRED"))]
Cred,
#[yaserde(rename = "SHAR")]
#[cfg_attr(feature = "serde", serde(rename = "SHAR"))]
Shar,
#[yaserde(rename = "SLEV")]
#[cfg_attr(feature = "serde", serde(rename = "SLEV"))]
Slev,
__Unknown__(String),
}
impl Default for ChargeBearerType1Code {
fn default() -> ChargeBearerType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for ChargeBearerType1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ChargeIncludedIndicator (pub bool);
crate::simple_type!(ChargeIncludedIndicator);
impl Validate for ChargeIncludedIndicator {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct ChargeType3Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<ExternalChargeType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<GenericIdentification3>,
}
impl Validate for ChargeType3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct Charges6 {
#[yaserde(rename = "TtlChrgsAndTaxAmt")]
#[cfg_attr(feature = "serde", serde(rename = "TtlChrgsAndTaxAmt"))]
pub ttl_chrgs_and_tax_amt: ActiveOrHistoricCurrencyAndAmount,
#[yaserde(rename = "Rcrd")]
#[cfg_attr(feature = "serde", serde(rename = "Rcrd"))]
pub rcrd: Vec<ChargesRecord3>,
}
impl Validate for Charges6 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct ChargesRecord3 {
#[yaserde(rename = "Amt")]
#[cfg_attr(feature = "serde", serde(rename = "Amt"))]
pub amt: ActiveOrHistoricCurrencyAndAmount,
#[yaserde(rename = "CdtDbtInd")]
#[cfg_attr(feature = "serde", serde(rename = "CdtDbtInd"))]
pub cdt_dbt_ind: CreditDebitCode,
#[yaserde(rename = "ChrgInclInd")]
#[cfg_attr(feature = "serde", serde(rename = "ChrgInclInd"))]
pub chrg_incl_ind: ChargeIncludedIndicator,
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: ChargeType3Choice,
#[yaserde(rename = "Rate")]
#[cfg_attr(feature = "serde", serde(rename = "Rate"))]
pub rate: PercentageRate,
#[yaserde(rename = "Br")]
#[cfg_attr(feature = "serde", serde(rename = "Br"))]
pub br: ChargeBearerType1Code,
#[yaserde(rename = "Agt")]
#[cfg_attr(feature = "serde", serde(rename = "Agt"))]
pub agt: BranchAndFinancialInstitutionIdentification6,
#[yaserde(rename = "Tax")]
#[cfg_attr(feature = "serde", serde(rename = "Tax"))]
pub tax: TaxCharges2,
}
impl Validate for ChargesRecord3 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct ClearingSystemIdentification2Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<ExternalClearingSystemIdentification1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<Max35Text>,
}
impl Validate for ClearingSystemIdentification2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct ClearingSystemMemberIdentification2 {
#[yaserde(rename = "ClrSysId")]
#[cfg_attr(feature = "serde", serde(rename = "ClrSysId"))]
pub clr_sys_id: ClearingSystemIdentification2Choice,
#[yaserde(rename = "MmbId")]
#[cfg_attr(feature = "serde", serde(rename = "MmbId"))]
pub mmb_id: Max35Text,
}
impl Validate for ClearingSystemMemberIdentification2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct Contact4 {
#[yaserde(rename = "NmPrfx")]
#[cfg_attr(feature = "serde", serde(rename = "NmPrfx"))]
pub nm_prfx: NamePrefix2Code,
#[yaserde(rename = "Nm")]
#[cfg_attr(feature = "serde", serde(rename = "Nm"))]
pub nm: Max140Text,
#[yaserde(rename = "PhneNb")]
#[cfg_attr(feature = "serde", serde(rename = "PhneNb"))]
pub phne_nb: PhoneNumber,
#[yaserde(rename = "MobNb")]
#[cfg_attr(feature = "serde", serde(rename = "MobNb"))]
pub mob_nb: PhoneNumber,
#[yaserde(rename = "FaxNb")]
#[cfg_attr(feature = "serde", serde(rename = "FaxNb"))]
pub fax_nb: PhoneNumber,
#[yaserde(rename = "EmailAdr")]
#[cfg_attr(feature = "serde", serde(rename = "EmailAdr"))]
pub email_adr: Max2048Text,
#[yaserde(rename = "EmailPurp")]
#[cfg_attr(feature = "serde", serde(rename = "EmailPurp"))]
pub email_purp: Max35Text,
#[yaserde(rename = "JobTitl")]
#[cfg_attr(feature = "serde", serde(rename = "JobTitl"))]
pub job_titl: Max35Text,
#[yaserde(rename = "Rspnsblty")]
#[cfg_attr(feature = "serde", serde(rename = "Rspnsblty"))]
pub rspnsblty: Max35Text,
#[yaserde(rename = "Dept")]
#[cfg_attr(feature = "serde", serde(rename = "Dept"))]
pub dept: Max70Text,
#[yaserde(rename = "Othr")]
#[cfg_attr(feature = "serde", serde(rename = "Othr"))]
pub othr: Vec<OtherContact1>,
#[yaserde(rename = "PrefrdMtd")]
#[cfg_attr(feature = "serde", serde(rename = "PrefrdMtd"))]
pub prefrd_mtd: PreferredContactMethod1Code,
}
impl Validate for Contact4 {}
#[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:camt.052.001.09")]
pub enum CopyDuplicate1Code {
#[yaserde(rename = "CODU")]
#[cfg_attr(feature = "serde", serde(rename = "CODU"))]
Codu,
#[yaserde(rename = "COPY")]
#[cfg_attr(feature = "serde", serde(rename = "COPY"))]
Copy,
#[yaserde(rename = "DUPL")]
#[cfg_attr(feature = "serde", serde(rename = "DUPL"))]
Dupl,
__Unknown__(String),
}
impl Default for CopyDuplicate1Code {
fn default() -> CopyDuplicate1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for CopyDuplicate1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct CorporateAction9 {
#[yaserde(rename = "EvtTp")]
#[cfg_attr(feature = "serde", serde(rename = "EvtTp"))]
pub evt_tp: Max35Text,
#[yaserde(rename = "EvtId")]
#[cfg_attr(feature = "serde", serde(rename = "EvtId"))]
pub evt_id: Max35Text,
}
impl Validate for CorporateAction9 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct CountryCode (pub String);
crate::simple_type!(CountryCode);
impl Validate for CountryCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub enum CreditDebitCode {
#[yaserde(rename = "CRDT")]
#[cfg_attr(feature = "serde", serde(rename = "CRDT"))]
Crdt,
#[yaserde(rename = "DBIT")]
#[cfg_attr(feature = "serde", serde(rename = "DBIT"))]
Dbit,
__Unknown__(String),
}
impl Default for CreditDebitCode {
fn default() -> CreditDebitCode {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for CreditDebitCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct CreditLine3 {
#[yaserde(rename = "Incl")]
#[cfg_attr(feature = "serde", serde(rename = "Incl"))]
pub incl: TrueFalseIndicator,
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: CreditLineType1Choice,
#[yaserde(rename = "Amt")]
#[cfg_attr(feature = "serde", serde(rename = "Amt"))]
pub amt: ActiveOrHistoricCurrencyAndAmount,
#[yaserde(rename = "Dt")]
#[cfg_attr(feature = "serde", serde(rename = "Dt"))]
pub dt: DateAndDateTime2Choice,
}
impl Validate for CreditLine3 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct CreditLineType1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<ExternalCreditLineType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<Max35Text>,
}
impl Validate for CreditLineType1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct CreditorReferenceInformation2 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: CreditorReferenceType2,
#[yaserde(rename = "Ref")]
#[cfg_attr(feature = "serde", serde(rename = "Ref"))]
pub _ref: Max35Text,
}
impl Validate for CreditorReferenceInformation2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct CreditorReferenceType1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<DocumentType3Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<Max35Text>,
}
impl Validate for CreditorReferenceType1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct CreditorReferenceType2 {
#[yaserde(rename = "CdOrPrtry")]
#[cfg_attr(feature = "serde", serde(rename = "CdOrPrtry"))]
pub cd_or_prtry: CreditorReferenceType1Choice,
#[yaserde(rename = "Issr")]
#[cfg_attr(feature = "serde", serde(rename = "Issr"))]
pub issr: Max35Text,
}
impl Validate for CreditorReferenceType2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct CurrencyExchange5 {
#[yaserde(rename = "SrcCcy")]
#[cfg_attr(feature = "serde", serde(rename = "SrcCcy"))]
pub src_ccy: ActiveOrHistoricCurrencyCode,
#[yaserde(rename = "TrgtCcy")]
#[cfg_attr(feature = "serde", serde(rename = "TrgtCcy"))]
pub trgt_ccy: ActiveOrHistoricCurrencyCode,
#[yaserde(rename = "UnitCcy")]
#[cfg_attr(feature = "serde", serde(rename = "UnitCcy"))]
pub unit_ccy: ActiveOrHistoricCurrencyCode,
#[yaserde(rename = "XchgRate")]
#[cfg_attr(feature = "serde", serde(rename = "XchgRate"))]
pub xchg_rate: BaseOneRate,
#[yaserde(rename = "CtrctId")]
#[cfg_attr(feature = "serde", serde(rename = "CtrctId"))]
pub ctrct_id: Max35Text,
#[yaserde(rename = "QtnDt")]
#[cfg_attr(feature = "serde", serde(rename = "QtnDt"))]
pub qtn_dt: IsodateTime,
}
impl Validate for CurrencyExchange5 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
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:camt.052.001.09")]
pub struct DateAndPlaceOfBirth1 {
#[yaserde(rename = "BirthDt")]
#[cfg_attr(feature = "serde", serde(rename = "BirthDt"))]
pub birth_dt: Isodate,
#[yaserde(rename = "PrvcOfBirth")]
#[cfg_attr(feature = "serde", serde(rename = "PrvcOfBirth"))]
pub prvc_of_birth: Max35Text,
#[yaserde(rename = "CityOfBirth")]
#[cfg_attr(feature = "serde", serde(rename = "CityOfBirth"))]
pub city_of_birth: Max35Text,
#[yaserde(rename = "CtryOfBirth")]
#[cfg_attr(feature = "serde", serde(rename = "CtryOfBirth"))]
pub ctry_of_birth: CountryCode,
}
impl Validate for DateAndPlaceOfBirth1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct DateOrDateTimePeriod1Choice {
#[yaserde(rename = "Dt")]
#[cfg_attr(feature = "serde", serde(rename = "Dt"))]
pub dt: Option<DatePeriod2>,
#[yaserde(rename = "DtTm")]
#[cfg_attr(feature = "serde", serde(rename = "DtTm"))]
pub dt_tm: Option<DateTimePeriod1>,
}
impl Validate for DateOrDateTimePeriod1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct DatePeriod2 {
#[yaserde(rename = "FrDt")]
#[cfg_attr(feature = "serde", serde(rename = "FrDt"))]
pub fr_dt: Isodate,
#[yaserde(rename = "ToDt")]
#[cfg_attr(feature = "serde", serde(rename = "ToDt"))]
pub to_dt: Isodate,
}
impl Validate for DatePeriod2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct DateTimePeriod1 {
#[yaserde(rename = "FrDtTm")]
#[cfg_attr(feature = "serde", serde(rename = "FrDtTm"))]
pub fr_dt_tm: IsodateTime,
#[yaserde(rename = "ToDtTm")]
#[cfg_attr(feature = "serde", serde(rename = "ToDtTm"))]
pub to_dt_tm: IsodateTime,
}
impl Validate for DateTimePeriod1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
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:camt.052.001.09")]
pub struct DiscountAmountAndType1 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: DiscountAmountType1Choice,
#[yaserde(rename = "Amt")]
#[cfg_attr(feature = "serde", serde(rename = "Amt"))]
pub amt: ActiveOrHistoricCurrencyAndAmount,
}
impl Validate for DiscountAmountAndType1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct DiscountAmountType1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<ExternalDiscountAmountType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<Max35Text>,
}
impl Validate for DiscountAmountType1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct DisplayCapabilities1 {
#[yaserde(rename = "DispTp")]
#[cfg_attr(feature = "serde", serde(rename = "DispTp"))]
pub disp_tp: UserInterface2Code,
#[yaserde(rename = "NbOfLines")]
#[cfg_attr(feature = "serde", serde(rename = "NbOfLines"))]
pub nb_of_lines: Max3NumericText,
#[yaserde(rename = "LineWidth")]
#[cfg_attr(feature = "serde", serde(rename = "LineWidth"))]
pub line_width: Max3NumericText,
}
impl Validate for DisplayCapabilities1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct Document {
#[yaserde(rename = "BkToCstmrAcctRpt")]
#[cfg_attr(feature = "serde", serde(rename = "BkToCstmrAcctRpt"))]
pub bk_to_cstmr_acct_rpt: BankToCustomerAccountReportV09,
}
impl Validate for Document {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct DocumentAdjustment1 {
#[yaserde(rename = "Amt")]
#[cfg_attr(feature = "serde", serde(rename = "Amt"))]
pub amt: ActiveOrHistoricCurrencyAndAmount,
#[yaserde(rename = "CdtDbtInd")]
#[cfg_attr(feature = "serde", serde(rename = "CdtDbtInd"))]
pub cdt_dbt_ind: CreditDebitCode,
#[yaserde(rename = "Rsn")]
#[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
pub rsn: Max4Text,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: Max140Text,
}
impl Validate for DocumentAdjustment1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct DocumentLineIdentification1 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: DocumentLineType1,
#[yaserde(rename = "Nb")]
#[cfg_attr(feature = "serde", serde(rename = "Nb"))]
pub nb: Max35Text,
#[yaserde(rename = "RltdDt")]
#[cfg_attr(feature = "serde", serde(rename = "RltdDt"))]
pub rltd_dt: Isodate,
}
impl Validate for DocumentLineIdentification1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct DocumentLineInformation1 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Vec<DocumentLineIdentification1>,
#[yaserde(rename = "Desc")]
#[cfg_attr(feature = "serde", serde(rename = "Desc"))]
pub desc: Max2048Text,
#[yaserde(rename = "Amt")]
#[cfg_attr(feature = "serde", serde(rename = "Amt"))]
pub amt: RemittanceAmount3,
}
impl Validate for DocumentLineInformation1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct DocumentLineType1 {
#[yaserde(rename = "CdOrPrtry")]
#[cfg_attr(feature = "serde", serde(rename = "CdOrPrtry"))]
pub cd_or_prtry: DocumentLineType1Choice,
#[yaserde(rename = "Issr")]
#[cfg_attr(feature = "serde", serde(rename = "Issr"))]
pub issr: Max35Text,
}
impl Validate for DocumentLineType1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct DocumentLineType1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<ExternalDocumentLineType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<Max35Text>,
}
impl Validate for DocumentLineType1Choice {}
#[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:camt.052.001.09")]
pub enum DocumentType3Code {
#[yaserde(rename = "RADM")]
#[cfg_attr(feature = "serde", serde(rename = "RADM"))]
Radm,
#[yaserde(rename = "RPIN")]
#[cfg_attr(feature = "serde", serde(rename = "RPIN"))]
Rpin,
#[yaserde(rename = "FXDR")]
#[cfg_attr(feature = "serde", serde(rename = "FXDR"))]
Fxdr,
#[yaserde(rename = "DISP")]
#[cfg_attr(feature = "serde", serde(rename = "DISP"))]
Disp,
#[yaserde(rename = "PUOR")]
#[cfg_attr(feature = "serde", serde(rename = "PUOR"))]
Puor,
#[yaserde(rename = "SCOR")]
#[cfg_attr(feature = "serde", serde(rename = "SCOR"))]
Scor,
__Unknown__(String),
}
impl Default for DocumentType3Code {
fn default() -> DocumentType3Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for DocumentType3Code {}
#[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:camt.052.001.09")]
pub enum DocumentType6Code {
#[yaserde(rename = "MSIN")]
#[cfg_attr(feature = "serde", serde(rename = "MSIN"))]
Msin,
#[yaserde(rename = "CNFA")]
#[cfg_attr(feature = "serde", serde(rename = "CNFA"))]
Cnfa,
#[yaserde(rename = "DNFA")]
#[cfg_attr(feature = "serde", serde(rename = "DNFA"))]
Dnfa,
#[yaserde(rename = "CINV")]
#[cfg_attr(feature = "serde", serde(rename = "CINV"))]
Cinv,
#[yaserde(rename = "CREN")]
#[cfg_attr(feature = "serde", serde(rename = "CREN"))]
Cren,
#[yaserde(rename = "DEBN")]
#[cfg_attr(feature = "serde", serde(rename = "DEBN"))]
Debn,
#[yaserde(rename = "HIRI")]
#[cfg_attr(feature = "serde", serde(rename = "HIRI"))]
Hiri,
#[yaserde(rename = "SBIN")]
#[cfg_attr(feature = "serde", serde(rename = "SBIN"))]
Sbin,
#[yaserde(rename = "CMCN")]
#[cfg_attr(feature = "serde", serde(rename = "CMCN"))]
Cmcn,
#[yaserde(rename = "SOAC")]
#[cfg_attr(feature = "serde", serde(rename = "SOAC"))]
Soac,
#[yaserde(rename = "DISP")]
#[cfg_attr(feature = "serde", serde(rename = "DISP"))]
Disp,
#[yaserde(rename = "BOLD")]
#[cfg_attr(feature = "serde", serde(rename = "BOLD"))]
Bold,
#[yaserde(rename = "VCHR")]
#[cfg_attr(feature = "serde", serde(rename = "VCHR"))]
Vchr,
#[yaserde(rename = "AROI")]
#[cfg_attr(feature = "serde", serde(rename = "AROI"))]
Aroi,
#[yaserde(rename = "TSUT")]
#[cfg_attr(feature = "serde", serde(rename = "TSUT"))]
Tsut,
#[yaserde(rename = "PUOR")]
#[cfg_attr(feature = "serde", serde(rename = "PUOR"))]
Puor,
__Unknown__(String),
}
impl Default for DocumentType6Code {
fn default() -> DocumentType6Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for DocumentType6Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct EntryDetails10 {
#[yaserde(rename = "Btch")]
#[cfg_attr(feature = "serde", serde(rename = "Btch"))]
pub btch: BatchInformation2,
#[yaserde(rename = "TxDtls")]
#[cfg_attr(feature = "serde", serde(rename = "TxDtls"))]
pub tx_dtls: Vec<EntryTransaction11>,
}
impl Validate for EntryDetails10 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct EntryStatus1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<ExternalEntryStatus1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<Max35Text>,
}
impl Validate for EntryStatus1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct EntryTransaction11 {
#[yaserde(rename = "Refs")]
#[cfg_attr(feature = "serde", serde(rename = "Refs"))]
pub refs: TransactionReferences6,
#[yaserde(rename = "Amt")]
#[cfg_attr(feature = "serde", serde(rename = "Amt"))]
pub amt: ActiveOrHistoricCurrencyAndAmount,
#[yaserde(rename = "CdtDbtInd")]
#[cfg_attr(feature = "serde", serde(rename = "CdtDbtInd"))]
pub cdt_dbt_ind: CreditDebitCode,
#[yaserde(rename = "AmtDtls")]
#[cfg_attr(feature = "serde", serde(rename = "AmtDtls"))]
pub amt_dtls: AmountAndCurrencyExchange3,
#[yaserde(rename = "Avlbty")]
#[cfg_attr(feature = "serde", serde(rename = "Avlbty"))]
pub avlbty: Vec<CashAvailability1>,
#[yaserde(rename = "BkTxCd")]
#[cfg_attr(feature = "serde", serde(rename = "BkTxCd"))]
pub bk_tx_cd: BankTransactionCodeStructure4,
#[yaserde(rename = "Chrgs")]
#[cfg_attr(feature = "serde", serde(rename = "Chrgs"))]
pub chrgs: Charges6,
#[yaserde(rename = "Intrst")]
#[cfg_attr(feature = "serde", serde(rename = "Intrst"))]
pub intrst: TransactionInterest4,
#[yaserde(rename = "RltdPties")]
#[cfg_attr(feature = "serde", serde(rename = "RltdPties"))]
pub rltd_pties: TransactionParties9,
#[yaserde(rename = "RltdAgts")]
#[cfg_attr(feature = "serde", serde(rename = "RltdAgts"))]
pub rltd_agts: TransactionAgents5,
#[yaserde(rename = "LclInstrm")]
#[cfg_attr(feature = "serde", serde(rename = "LclInstrm"))]
pub lcl_instrm: LocalInstrument2Choice,
#[yaserde(rename = "Purp")]
#[cfg_attr(feature = "serde", serde(rename = "Purp"))]
pub purp: Purpose2Choice,
#[yaserde(rename = "RltdRmtInf")]
#[cfg_attr(feature = "serde", serde(rename = "RltdRmtInf"))]
pub rltd_rmt_inf: Vec<RemittanceLocation7>,
#[yaserde(rename = "RmtInf")]
#[cfg_attr(feature = "serde", serde(rename = "RmtInf"))]
pub rmt_inf: RemittanceInformation21,
#[yaserde(rename = "RltdDts")]
#[cfg_attr(feature = "serde", serde(rename = "RltdDts"))]
pub rltd_dts: TransactionDates3,
#[yaserde(rename = "RltdPric")]
#[cfg_attr(feature = "serde", serde(rename = "RltdPric"))]
pub rltd_pric: TransactionPrice4Choice,
#[yaserde(rename = "RltdQties")]
#[cfg_attr(feature = "serde", serde(rename = "RltdQties"))]
pub rltd_qties: Vec<TransactionQuantities3Choice>,
#[yaserde(rename = "FinInstrmId")]
#[cfg_attr(feature = "serde", serde(rename = "FinInstrmId"))]
pub fin_instrm_id: SecurityIdentification19,
#[yaserde(rename = "Tax")]
#[cfg_attr(feature = "serde", serde(rename = "Tax"))]
pub tax: TaxInformation10,
#[yaserde(rename = "RtrInf")]
#[cfg_attr(feature = "serde", serde(rename = "RtrInf"))]
pub rtr_inf: PaymentReturnReason5,
#[yaserde(rename = "CorpActn")]
#[cfg_attr(feature = "serde", serde(rename = "CorpActn"))]
pub corp_actn: CorporateAction9,
#[yaserde(rename = "SfkpgAcct")]
#[cfg_attr(feature = "serde", serde(rename = "SfkpgAcct"))]
pub sfkpg_acct: SecuritiesAccount19,
#[yaserde(rename = "CshDpst")]
#[cfg_attr(feature = "serde", serde(rename = "CshDpst"))]
pub csh_dpst: Vec<CashDeposit1>,
#[yaserde(rename = "CardTx")]
#[cfg_attr(feature = "serde", serde(rename = "CardTx"))]
pub card_tx: CardTransaction18,
#[yaserde(rename = "AddtlTxInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlTxInf"))]
pub addtl_tx_inf: Max500Text,
#[yaserde(rename = "SplmtryData")]
#[cfg_attr(feature = "serde", serde(rename = "SplmtryData"))]
pub splmtry_data: Vec<SupplementaryData1>,
}
impl Validate for EntryTransaction11 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Exact1NumericText (pub String);
crate::simple_type!(Exact1NumericText);
impl Validate for Exact1NumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Exact3NumericText (pub String);
crate::simple_type!(Exact3NumericText);
impl Validate for Exact3NumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Exact4AlphaNumericText (pub String);
crate::simple_type!(Exact4AlphaNumericText);
impl Validate for Exact4AlphaNumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct 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 ExternalBalanceSubType1Code (pub String);
crate::simple_type!(ExternalBalanceSubType1Code);
impl Validate for ExternalBalanceSubType1Code {
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 ExternalBalanceType1Code (pub String);
crate::simple_type!(ExternalBalanceType1Code);
impl Validate for ExternalBalanceType1Code {
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 ExternalBankTransactionDomain1Code (pub String);
crate::simple_type!(ExternalBankTransactionDomain1Code);
impl Validate for ExternalBankTransactionDomain1Code {
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 ExternalBankTransactionFamily1Code (pub String);
crate::simple_type!(ExternalBankTransactionFamily1Code);
impl Validate for ExternalBankTransactionFamily1Code {
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 ExternalBankTransactionSubFamily1Code (pub String);
crate::simple_type!(ExternalBankTransactionSubFamily1Code);
impl Validate for ExternalBankTransactionSubFamily1Code {
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 ExternalCardTransactionCategory1Code (pub String);
crate::simple_type!(ExternalCardTransactionCategory1Code);
impl Validate for ExternalCardTransactionCategory1Code {
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 ExternalCashAccountType1Code (pub String);
crate::simple_type!(ExternalCashAccountType1Code);
impl Validate for ExternalCashAccountType1Code {
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 ExternalChargeType1Code (pub String);
crate::simple_type!(ExternalChargeType1Code);
impl Validate for ExternalChargeType1Code {
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 ExternalClearingSystemIdentification1Code (pub String);
crate::simple_type!(ExternalClearingSystemIdentification1Code);
impl Validate for ExternalClearingSystemIdentification1Code {
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() > 5 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 5 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ExternalCreditLineType1Code (pub String);
crate::simple_type!(ExternalCreditLineType1Code);
impl Validate for ExternalCreditLineType1Code {
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 ExternalDiscountAmountType1Code (pub String);
crate::simple_type!(ExternalDiscountAmountType1Code);
impl Validate for ExternalDiscountAmountType1Code {
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 ExternalDocumentLineType1Code (pub String);
crate::simple_type!(ExternalDocumentLineType1Code);
impl Validate for ExternalDocumentLineType1Code {
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 ExternalEntryStatus1Code (pub String);
crate::simple_type!(ExternalEntryStatus1Code);
impl Validate for ExternalEntryStatus1Code {
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 ExternalFinancialInstitutionIdentification1Code (pub String);
crate::simple_type!(ExternalFinancialInstitutionIdentification1Code);
impl Validate for ExternalFinancialInstitutionIdentification1Code {
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 ExternalFinancialInstrumentIdentificationType1Code (pub String);
crate::simple_type!(ExternalFinancialInstrumentIdentificationType1Code);
impl Validate for ExternalFinancialInstrumentIdentificationType1Code {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 4 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 4 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ExternalGarnishmentType1Code (pub String);
crate::simple_type!(ExternalGarnishmentType1Code);
impl Validate for ExternalGarnishmentType1Code {
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 ExternalLocalInstrument1Code (pub String);
crate::simple_type!(ExternalLocalInstrument1Code);
impl Validate for ExternalLocalInstrument1Code {
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 ExternalOrganisationIdentification1Code (pub String);
crate::simple_type!(ExternalOrganisationIdentification1Code);
impl Validate for ExternalOrganisationIdentification1Code {
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 ExternalPersonIdentification1Code (pub String);
crate::simple_type!(ExternalPersonIdentification1Code);
impl Validate for ExternalPersonIdentification1Code {
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 ExternalProxyAccountType1Code (pub String);
crate::simple_type!(ExternalProxyAccountType1Code);
impl Validate for ExternalProxyAccountType1Code {
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 ExternalPurpose1Code (pub String);
crate::simple_type!(ExternalPurpose1Code);
impl Validate for ExternalPurpose1Code {
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 ExternalRePresentmentReason1Code (pub String);
crate::simple_type!(ExternalRePresentmentReason1Code);
impl Validate for ExternalRePresentmentReason1Code {
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 ExternalReportingSource1Code (pub String);
crate::simple_type!(ExternalReportingSource1Code);
impl Validate for ExternalReportingSource1Code {
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 ExternalReturnReason1Code (pub String);
crate::simple_type!(ExternalReturnReason1Code);
impl Validate for ExternalReturnReason1Code {
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 ExternalTaxAmountType1Code (pub String);
crate::simple_type!(ExternalTaxAmountType1Code);
impl Validate for ExternalTaxAmountType1Code {
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 ExternalTechnicalInputChannel1Code (pub String);
crate::simple_type!(ExternalTechnicalInputChannel1Code);
impl Validate for ExternalTechnicalInputChannel1Code {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 4 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 4 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct FinancialIdentificationSchemeName1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<ExternalFinancialInstitutionIdentification1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<Max35Text>,
}
impl Validate for FinancialIdentificationSchemeName1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct FinancialInstitutionIdentification18 {
#[yaserde(rename = "BICFI")]
#[cfg_attr(feature = "serde", serde(rename = "BICFI"))]
pub bicfi: Bicfidec2014Identifier,
#[yaserde(rename = "ClrSysMmbId")]
#[cfg_attr(feature = "serde", serde(rename = "ClrSysMmbId"))]
pub clr_sys_mmb_id: ClearingSystemMemberIdentification2,
#[yaserde(rename = "LEI")]
#[cfg_attr(feature = "serde", serde(rename = "LEI"))]
pub lei: Leiidentifier,
#[yaserde(rename = "Nm")]
#[cfg_attr(feature = "serde", serde(rename = "Nm"))]
pub nm: Max140Text,
#[yaserde(rename = "PstlAdr")]
#[cfg_attr(feature = "serde", serde(rename = "PstlAdr"))]
pub pstl_adr: PostalAddress24,
#[yaserde(rename = "Othr")]
#[cfg_attr(feature = "serde", serde(rename = "Othr"))]
pub othr: GenericFinancialIdentification1,
}
impl Validate for FinancialInstitutionIdentification18 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct FinancialInstrumentQuantity1Choice {
#[yaserde(rename = "Unit")]
#[cfg_attr(feature = "serde", serde(rename = "Unit"))]
pub unit: Option<DecimalNumber>,
#[yaserde(rename = "FaceAmt")]
#[cfg_attr(feature = "serde", serde(rename = "FaceAmt"))]
pub face_amt: Option<ImpliedCurrencyAndAmount>,
#[yaserde(rename = "AmtsdVal")]
#[cfg_attr(feature = "serde", serde(rename = "AmtsdVal"))]
pub amtsd_val: Option<ImpliedCurrencyAndAmount>,
}
impl Validate for FinancialInstrumentQuantity1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct FromToAmountRange1 {
#[yaserde(rename = "FrAmt")]
#[cfg_attr(feature = "serde", serde(rename = "FrAmt"))]
pub fr_amt: AmountRangeBoundary1,
#[yaserde(rename = "ToAmt")]
#[cfg_attr(feature = "serde", serde(rename = "ToAmt"))]
pub to_amt: AmountRangeBoundary1,
}
impl Validate for FromToAmountRange1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct Garnishment3 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: GarnishmentType1,
#[yaserde(rename = "Grnshee")]
#[cfg_attr(feature = "serde", serde(rename = "Grnshee"))]
pub grnshee: PartyIdentification135,
#[yaserde(rename = "GrnshmtAdmstr")]
#[cfg_attr(feature = "serde", serde(rename = "GrnshmtAdmstr"))]
pub grnshmt_admstr: PartyIdentification135,
#[yaserde(rename = "RefNb")]
#[cfg_attr(feature = "serde", serde(rename = "RefNb"))]
pub ref_nb: Max140Text,
#[yaserde(rename = "Dt")]
#[cfg_attr(feature = "serde", serde(rename = "Dt"))]
pub dt: Isodate,
#[yaserde(rename = "RmtdAmt")]
#[cfg_attr(feature = "serde", serde(rename = "RmtdAmt"))]
pub rmtd_amt: ActiveOrHistoricCurrencyAndAmount,
#[yaserde(rename = "FmlyMdclInsrncInd")]
#[cfg_attr(feature = "serde", serde(rename = "FmlyMdclInsrncInd"))]
pub fmly_mdcl_insrnc_ind: TrueFalseIndicator,
#[yaserde(rename = "MplyeeTermntnInd")]
#[cfg_attr(feature = "serde", serde(rename = "MplyeeTermntnInd"))]
pub mplyee_termntn_ind: TrueFalseIndicator,
}
impl Validate for Garnishment3 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct GarnishmentType1 {
#[yaserde(rename = "CdOrPrtry")]
#[cfg_attr(feature = "serde", serde(rename = "CdOrPrtry"))]
pub cd_or_prtry: GarnishmentType1Choice,
#[yaserde(rename = "Issr")]
#[cfg_attr(feature = "serde", serde(rename = "Issr"))]
pub issr: Max35Text,
}
impl Validate for GarnishmentType1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct GarnishmentType1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<ExternalGarnishmentType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<Max35Text>,
}
impl Validate for GarnishmentType1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
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:camt.052.001.09")]
pub struct GenericFinancialIdentification1 {
#[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: FinancialIdentificationSchemeName1Choice,
#[yaserde(rename = "Issr")]
#[cfg_attr(feature = "serde", serde(rename = "Issr"))]
pub issr: Max35Text,
}
impl Validate for GenericFinancialIdentification1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
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:camt.052.001.09")]
pub struct GenericIdentification3 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max35Text,
#[yaserde(rename = "Issr")]
#[cfg_attr(feature = "serde", serde(rename = "Issr"))]
pub issr: Max35Text,
}
impl Validate for GenericIdentification3 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
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:camt.052.001.09")]
pub struct GenericIdentification32 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max35Text,
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: PartyType3Code,
#[yaserde(rename = "Issr")]
#[cfg_attr(feature = "serde", serde(rename = "Issr"))]
pub issr: PartyType4Code,
#[yaserde(rename = "ShrtNm")]
#[cfg_attr(feature = "serde", serde(rename = "ShrtNm"))]
pub shrt_nm: Max35Text,
}
impl Validate for GenericIdentification32 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct GenericOrganisationIdentification1 {
#[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: OrganisationIdentificationSchemeName1Choice,
#[yaserde(rename = "Issr")]
#[cfg_attr(feature = "serde", serde(rename = "Issr"))]
pub issr: Max35Text,
}
impl Validate for GenericOrganisationIdentification1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct GenericPersonIdentification1 {
#[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: PersonIdentificationSchemeName1Choice,
#[yaserde(rename = "Issr")]
#[cfg_attr(feature = "serde", serde(rename = "Issr"))]
pub issr: Max35Text,
}
impl Validate for GenericPersonIdentification1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct GroupHeader81 {
#[yaserde(rename = "MsgId")]
#[cfg_attr(feature = "serde", serde(rename = "MsgId"))]
pub msg_id: Max35Text,
#[yaserde(rename = "CreDtTm")]
#[cfg_attr(feature = "serde", serde(rename = "CreDtTm"))]
pub cre_dt_tm: IsodateTime,
#[yaserde(rename = "MsgRcpt")]
#[cfg_attr(feature = "serde", serde(rename = "MsgRcpt"))]
pub msg_rcpt: PartyIdentification135,
#[yaserde(rename = "MsgPgntn")]
#[cfg_attr(feature = "serde", serde(rename = "MsgPgntn"))]
pub msg_pgntn: Pagination1,
#[yaserde(rename = "OrgnlBizQry")]
#[cfg_attr(feature = "serde", serde(rename = "OrgnlBizQry"))]
pub orgnl_biz_qry: OriginalBusinessQuery1,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: Max500Text,
}
impl Validate for GroupHeader81 {}
#[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 Iso2AlanguageCode (pub String);
crate::simple_type!(Iso2AlanguageCode);
impl Validate for Iso2AlanguageCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Isodate (pub String);
crate::simple_type!(Isodate);
impl Validate for Isodate {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct IsodateTime (pub String);
crate::simple_type!(IsodateTime);
impl Validate for IsodateTime {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Isoyear (pub String);
crate::simple_type!(Isoyear);
impl Validate for Isoyear {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct IsoyearMonth (pub String);
crate::simple_type!(IsoyearMonth);
impl Validate for IsoyearMonth {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct IdentificationSource3Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<ExternalFinancialInstrumentIdentificationType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<Max35Text>,
}
impl Validate for IdentificationSource3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct ImpliedCurrencyAmountRange1Choice {
#[yaserde(rename = "FrAmt")]
#[cfg_attr(feature = "serde", serde(rename = "FrAmt"))]
pub fr_amt: Option<AmountRangeBoundary1>,
#[yaserde(rename = "ToAmt")]
#[cfg_attr(feature = "serde", serde(rename = "ToAmt"))]
pub to_amt: Option<AmountRangeBoundary1>,
#[yaserde(rename = "FrToAmt")]
#[cfg_attr(feature = "serde", serde(rename = "FrToAmt"))]
pub fr_to_amt: Option<FromToAmountRange1>,
#[yaserde(rename = "EQAmt")]
#[cfg_attr(feature = "serde", serde(rename = "EQAmt"))]
pub eqamt: Option<ImpliedCurrencyAndAmount>,
#[yaserde(rename = "NEQAmt")]
#[cfg_attr(feature = "serde", serde(rename = "NEQAmt"))]
pub neqamt: Option<ImpliedCurrencyAndAmount>,
}
impl Validate for ImpliedCurrencyAmountRange1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct ImpliedCurrencyAndAmount (pub String);
crate::simple_type!(ImpliedCurrencyAndAmount);
impl Validate for ImpliedCurrencyAndAmount {
fn validate(&self) -> Result<(), String> {
if self.0 < "0".parse::<String>().unwrap() {
return Err(format!("MinInclusive validation error: invalid value of 0! \nExpected: 0 >= 0.\nActual: 0 == {}", self.0));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct InterestRecord2 {
#[yaserde(rename = "Amt")]
#[cfg_attr(feature = "serde", serde(rename = "Amt"))]
pub amt: ActiveOrHistoricCurrencyAndAmount,
#[yaserde(rename = "CdtDbtInd")]
#[cfg_attr(feature = "serde", serde(rename = "CdtDbtInd"))]
pub cdt_dbt_ind: CreditDebitCode,
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: InterestType1Choice,
#[yaserde(rename = "Rate")]
#[cfg_attr(feature = "serde", serde(rename = "Rate"))]
pub rate: Rate4,
#[yaserde(rename = "FrToDt")]
#[cfg_attr(feature = "serde", serde(rename = "FrToDt"))]
pub fr_to_dt: DateTimePeriod1,
#[yaserde(rename = "Rsn")]
#[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
pub rsn: Max35Text,
#[yaserde(rename = "Tax")]
#[cfg_attr(feature = "serde", serde(rename = "Tax"))]
pub tax: TaxCharges2,
}
impl Validate for InterestRecord2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct InterestType1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<InterestType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<Max35Text>,
}
impl Validate for InterestType1Choice {}
#[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:camt.052.001.09")]
pub enum InterestType1Code {
#[yaserde(rename = "INDY")]
#[cfg_attr(feature = "serde", serde(rename = "INDY"))]
Indy,
#[yaserde(rename = "OVRN")]
#[cfg_attr(feature = "serde", serde(rename = "OVRN"))]
Ovrn,
__Unknown__(String),
}
impl Default for InterestType1Code {
fn default() -> InterestType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for InterestType1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Leiidentifier (pub String);
crate::simple_type!(Leiidentifier);
impl Validate for Leiidentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct LocalInstrument2Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<ExternalLocalInstrument1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<Max35Text>,
}
impl Validate for LocalInstrument2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max1025Text (pub String);
crate::simple_type!(Max1025Text);
impl Validate for Max1025Text {
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() > 1025 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 1025 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max105Text (pub String);
crate::simple_type!(Max105Text);
impl Validate for Max105Text {
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() > 105 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 105 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max128Text (pub String);
crate::simple_type!(Max128Text);
impl Validate for Max128Text {
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() > 128 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 128 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max140Text (pub String);
crate::simple_type!(Max140Text);
impl Validate for Max140Text {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 140 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 140 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max15NumericText (pub String);
crate::simple_type!(Max15NumericText);
impl Validate for Max15NumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max15PlusSignedNumericText (pub String);
crate::simple_type!(Max15PlusSignedNumericText);
impl Validate for Max15PlusSignedNumericText {}
#[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 Max2048Text (pub String);
crate::simple_type!(Max2048Text);
impl Validate for Max2048Text {
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() > 2048 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 2048 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max34Text (pub String);
crate::simple_type!(Max34Text);
impl Validate for Max34Text {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 34 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 34 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max350Text (pub String);
crate::simple_type!(Max350Text);
impl Validate for Max350Text {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 350 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 350 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max35Text (pub String);
crate::simple_type!(Max35Text);
impl Validate for Max35Text {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 35 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 35 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max3NumericText (pub String);
crate::simple_type!(Max3NumericText);
impl Validate for Max3NumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max4Text (pub String);
crate::simple_type!(Max4Text);
impl Validate for Max4Text {
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 Max500Text (pub String);
crate::simple_type!(Max500Text);
impl Validate for Max500Text {
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() > 500 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 500 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max5NumericText (pub String);
crate::simple_type!(Max5NumericText);
impl Validate for Max5NumericText {}
#[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:camt.052.001.09")]
pub struct MessageIdentification2 {
#[yaserde(rename = "MsgNmId")]
#[cfg_attr(feature = "serde", serde(rename = "MsgNmId"))]
pub msg_nm_id: Max35Text,
#[yaserde(rename = "MsgId")]
#[cfg_attr(feature = "serde", serde(rename = "MsgId"))]
pub msg_id: Max35Text,
}
impl Validate for MessageIdentification2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Min2Max3NumericText (pub String);
crate::simple_type!(Min2Max3NumericText);
impl Validate for Min2Max3NumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Min3Max4NumericText (pub String);
crate::simple_type!(Min3Max4NumericText);
impl Validate for Min3Max4NumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Min8Max28NumericText (pub String);
crate::simple_type!(Min8Max28NumericText);
impl Validate for Min8Max28NumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct NameAndAddress16 {
#[yaserde(rename = "Nm")]
#[cfg_attr(feature = "serde", serde(rename = "Nm"))]
pub nm: Max140Text,
#[yaserde(rename = "Adr")]
#[cfg_attr(feature = "serde", serde(rename = "Adr"))]
pub adr: PostalAddress24,
}
impl Validate for NameAndAddress16 {}
#[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:camt.052.001.09")]
pub enum NamePrefix2Code {
#[yaserde(rename = "DOCT")]
#[cfg_attr(feature = "serde", serde(rename = "DOCT"))]
Doct,
#[yaserde(rename = "MADM")]
#[cfg_attr(feature = "serde", serde(rename = "MADM"))]
Madm,
#[yaserde(rename = "MISS")]
#[cfg_attr(feature = "serde", serde(rename = "MISS"))]
Miss,
#[yaserde(rename = "MIST")]
#[cfg_attr(feature = "serde", serde(rename = "MIST"))]
Mist,
#[yaserde(rename = "MIKS")]
#[cfg_attr(feature = "serde", serde(rename = "MIKS"))]
Miks,
__Unknown__(String),
}
impl Default for NamePrefix2Code {
fn default() -> NamePrefix2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for NamePrefix2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct NonNegativeDecimalNumber (pub String);
crate::simple_type!(NonNegativeDecimalNumber);
impl Validate for NonNegativeDecimalNumber {
fn validate(&self) -> Result<(), String> {
if self.0 < "0".parse::<String>().unwrap() {
return Err(format!("MinInclusive validation error: invalid value of 0! \nExpected: 0 >= 0.\nActual: 0 == {}", self.0));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Number (pub String);
crate::simple_type!(Number);
impl Validate for Number {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct NumberAndSumOfTransactions1 {
#[yaserde(rename = "NbOfNtries")]
#[cfg_attr(feature = "serde", serde(rename = "NbOfNtries"))]
pub nb_of_ntries: Max15NumericText,
#[yaserde(rename = "Sum")]
#[cfg_attr(feature = "serde", serde(rename = "Sum"))]
pub sum: DecimalNumber,
}
impl Validate for NumberAndSumOfTransactions1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct NumberAndSumOfTransactions4 {
#[yaserde(rename = "NbOfNtries")]
#[cfg_attr(feature = "serde", serde(rename = "NbOfNtries"))]
pub nb_of_ntries: Max15NumericText,
#[yaserde(rename = "Sum")]
#[cfg_attr(feature = "serde", serde(rename = "Sum"))]
pub sum: DecimalNumber,
#[yaserde(rename = "TtlNetNtry")]
#[cfg_attr(feature = "serde", serde(rename = "TtlNetNtry"))]
pub ttl_net_ntry: AmountAndDirection35,
}
impl Validate for NumberAndSumOfTransactions4 {}
#[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:camt.052.001.09")]
pub enum OnLineCapability1Code {
#[yaserde(rename = "OFLN")]
#[cfg_attr(feature = "serde", serde(rename = "OFLN"))]
Ofln,
#[yaserde(rename = "ONLN")]
#[cfg_attr(feature = "serde", serde(rename = "ONLN"))]
Onln,
#[yaserde(rename = "SMON")]
#[cfg_attr(feature = "serde", serde(rename = "SMON"))]
Smon,
__Unknown__(String),
}
impl Default for OnLineCapability1Code {
fn default() -> OnLineCapability1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for OnLineCapability1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct OrganisationIdentification29 {
#[yaserde(rename = "AnyBIC")]
#[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
pub any_bic: AnyBICDec2014Identifier,
#[yaserde(rename = "LEI")]
#[cfg_attr(feature = "serde", serde(rename = "LEI"))]
pub lei: Leiidentifier,
#[yaserde(rename = "Othr")]
#[cfg_attr(feature = "serde", serde(rename = "Othr"))]
pub othr: Vec<GenericOrganisationIdentification1>,
}
impl Validate for OrganisationIdentification29 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct OrganisationIdentificationSchemeName1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<ExternalOrganisationIdentification1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<Max35Text>,
}
impl Validate for OrganisationIdentificationSchemeName1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct OriginalAndCurrentQuantities1 {
#[yaserde(rename = "FaceAmt")]
#[cfg_attr(feature = "serde", serde(rename = "FaceAmt"))]
pub face_amt: ImpliedCurrencyAndAmount,
#[yaserde(rename = "AmtsdVal")]
#[cfg_attr(feature = "serde", serde(rename = "AmtsdVal"))]
pub amtsd_val: ImpliedCurrencyAndAmount,
}
impl Validate for OriginalAndCurrentQuantities1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct OriginalBusinessQuery1 {
#[yaserde(rename = "MsgId")]
#[cfg_attr(feature = "serde", serde(rename = "MsgId"))]
pub msg_id: Max35Text,
#[yaserde(rename = "MsgNmId")]
#[cfg_attr(feature = "serde", serde(rename = "MsgNmId"))]
pub msg_nm_id: Max35Text,
#[yaserde(rename = "CreDtTm")]
#[cfg_attr(feature = "serde", serde(rename = "CreDtTm"))]
pub cre_dt_tm: IsodateTime,
}
impl Validate for OriginalBusinessQuery1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct OtherContact1 {
#[yaserde(rename = "ChanlTp")]
#[cfg_attr(feature = "serde", serde(rename = "ChanlTp"))]
pub chanl_tp: Max4Text,
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max128Text,
}
impl Validate for OtherContact1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct OtherIdentification1 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max35Text,
#[yaserde(rename = "Sfx")]
#[cfg_attr(feature = "serde", serde(rename = "Sfx"))]
pub sfx: Max16Text,
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: IdentificationSource3Choice,
}
impl Validate for OtherIdentification1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub enum PoicomponentType1Code {
#[yaserde(rename = "SOFT")]
#[cfg_attr(feature = "serde", serde(rename = "SOFT"))]
Soft,
#[yaserde(rename = "EMVK")]
#[cfg_attr(feature = "serde", serde(rename = "EMVK"))]
Emvk,
#[yaserde(rename = "EMVO")]
#[cfg_attr(feature = "serde", serde(rename = "EMVO"))]
Emvo,
#[yaserde(rename = "MRIT")]
#[cfg_attr(feature = "serde", serde(rename = "MRIT"))]
Mrit,
#[yaserde(rename = "CHIT")]
#[cfg_attr(feature = "serde", serde(rename = "CHIT"))]
Chit,
#[yaserde(rename = "SECM")]
#[cfg_attr(feature = "serde", serde(rename = "SECM"))]
Secm,
#[yaserde(rename = "PEDV")]
#[cfg_attr(feature = "serde", serde(rename = "PEDV"))]
Pedv,
__Unknown__(String),
}
impl Default for PoicomponentType1Code {
fn default() -> PoicomponentType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for PoicomponentType1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct Pagination1 {
#[yaserde(rename = "PgNb")]
#[cfg_attr(feature = "serde", serde(rename = "PgNb"))]
pub pg_nb: Max5NumericText,
#[yaserde(rename = "LastPgInd")]
#[cfg_attr(feature = "serde", serde(rename = "LastPgInd"))]
pub last_pg_ind: YesNoIndicator,
}
impl Validate for Pagination1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct Party38Choice {
#[yaserde(rename = "OrgId")]
#[cfg_attr(feature = "serde", serde(rename = "OrgId"))]
pub org_id: Option<OrganisationIdentification29>,
#[yaserde(rename = "PrvtId")]
#[cfg_attr(feature = "serde", serde(rename = "PrvtId"))]
pub prvt_id: Option<PersonIdentification13>,
}
impl Validate for Party38Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct Party40Choice {
#[yaserde(rename = "Pty")]
#[cfg_attr(feature = "serde", serde(rename = "Pty"))]
pub pty: Option<PartyIdentification135>,
#[yaserde(rename = "Agt")]
#[cfg_attr(feature = "serde", serde(rename = "Agt"))]
pub agt: Option<BranchAndFinancialInstitutionIdentification6>,
}
impl Validate for Party40Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct PartyIdentification135 {
#[yaserde(rename = "Nm")]
#[cfg_attr(feature = "serde", serde(rename = "Nm"))]
pub nm: Max140Text,
#[yaserde(rename = "PstlAdr")]
#[cfg_attr(feature = "serde", serde(rename = "PstlAdr"))]
pub pstl_adr: PostalAddress24,
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Party38Choice,
#[yaserde(rename = "CtryOfRes")]
#[cfg_attr(feature = "serde", serde(rename = "CtryOfRes"))]
pub ctry_of_res: CountryCode,
#[yaserde(rename = "CtctDtls")]
#[cfg_attr(feature = "serde", serde(rename = "CtctDtls"))]
pub ctct_dtls: Contact4,
}
impl Validate for PartyIdentification135 {}
#[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:camt.052.001.09")]
pub enum PartyType3Code {
#[yaserde(rename = "OPOI")]
#[cfg_attr(feature = "serde", serde(rename = "OPOI"))]
Opoi,
#[yaserde(rename = "MERC")]
#[cfg_attr(feature = "serde", serde(rename = "MERC"))]
Merc,
#[yaserde(rename = "ACCP")]
#[cfg_attr(feature = "serde", serde(rename = "ACCP"))]
Accp,
#[yaserde(rename = "ITAG")]
#[cfg_attr(feature = "serde", serde(rename = "ITAG"))]
Itag,
#[yaserde(rename = "ACQR")]
#[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
Acqr,
#[yaserde(rename = "CISS")]
#[cfg_attr(feature = "serde", serde(rename = "CISS"))]
Ciss,
#[yaserde(rename = "DLIS")]
#[cfg_attr(feature = "serde", serde(rename = "DLIS"))]
Dlis,
__Unknown__(String),
}
impl Default for PartyType3Code {
fn default() -> PartyType3Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for PartyType3Code {}
#[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:camt.052.001.09")]
pub enum PartyType4Code {
#[yaserde(rename = "MERC")]
#[cfg_attr(feature = "serde", serde(rename = "MERC"))]
Merc,
#[yaserde(rename = "ACCP")]
#[cfg_attr(feature = "serde", serde(rename = "ACCP"))]
Accp,
#[yaserde(rename = "ITAG")]
#[cfg_attr(feature = "serde", serde(rename = "ITAG"))]
Itag,
#[yaserde(rename = "ACQR")]
#[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
Acqr,
#[yaserde(rename = "CISS")]
#[cfg_attr(feature = "serde", serde(rename = "CISS"))]
Ciss,
#[yaserde(rename = "TAXH")]
#[cfg_attr(feature = "serde", serde(rename = "TAXH"))]
Taxh,
__Unknown__(String),
}
impl Default for PartyType4Code {
fn default() -> PartyType4Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for PartyType4Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct PaymentCard4 {
#[yaserde(rename = "PlainCardData")]
#[cfg_attr(feature = "serde", serde(rename = "PlainCardData"))]
pub plain_card_data: PlainCardData1,
#[yaserde(rename = "CardCtryCd")]
#[cfg_attr(feature = "serde", serde(rename = "CardCtryCd"))]
pub card_ctry_cd: Exact3NumericText,
#[yaserde(rename = "CardBrnd")]
#[cfg_attr(feature = "serde", serde(rename = "CardBrnd"))]
pub card_brnd: GenericIdentification1,
#[yaserde(rename = "AddtlCardData")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlCardData"))]
pub addtl_card_data: Max70Text,
}
impl Validate for PaymentCard4 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct PaymentContext3 {
#[yaserde(rename = "CardPres")]
#[cfg_attr(feature = "serde", serde(rename = "CardPres"))]
pub card_pres: TrueFalseIndicator,
#[yaserde(rename = "CrdhldrPres")]
#[cfg_attr(feature = "serde", serde(rename = "CrdhldrPres"))]
pub crdhldr_pres: TrueFalseIndicator,
#[yaserde(rename = "OnLineCntxt")]
#[cfg_attr(feature = "serde", serde(rename = "OnLineCntxt"))]
pub on_line_cntxt: TrueFalseIndicator,
#[yaserde(rename = "AttndncCntxt")]
#[cfg_attr(feature = "serde", serde(rename = "AttndncCntxt"))]
pub attndnc_cntxt: AttendanceContext1Code,
#[yaserde(rename = "TxEnvt")]
#[cfg_attr(feature = "serde", serde(rename = "TxEnvt"))]
pub tx_envt: TransactionEnvironment1Code,
#[yaserde(rename = "TxChanl")]
#[cfg_attr(feature = "serde", serde(rename = "TxChanl"))]
pub tx_chanl: TransactionChannel1Code,
#[yaserde(rename = "AttndntMsgCpbl")]
#[cfg_attr(feature = "serde", serde(rename = "AttndntMsgCpbl"))]
pub attndnt_msg_cpbl: TrueFalseIndicator,
#[yaserde(rename = "AttndntLang")]
#[cfg_attr(feature = "serde", serde(rename = "AttndntLang"))]
pub attndnt_lang: Iso2AlanguageCode,
#[yaserde(rename = "CardDataNtryMd")]
#[cfg_attr(feature = "serde", serde(rename = "CardDataNtryMd"))]
pub card_data_ntry_md: CardDataReading1Code,
#[yaserde(rename = "FllbckInd")]
#[cfg_attr(feature = "serde", serde(rename = "FllbckInd"))]
pub fllbck_ind: TrueFalseIndicator,
#[yaserde(rename = "AuthntcnMtd")]
#[cfg_attr(feature = "serde", serde(rename = "AuthntcnMtd"))]
pub authntcn_mtd: CardholderAuthentication2,
}
impl Validate for PaymentContext3 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct PaymentReturnReason5 {
#[yaserde(rename = "OrgnlBkTxCd")]
#[cfg_attr(feature = "serde", serde(rename = "OrgnlBkTxCd"))]
pub orgnl_bk_tx_cd: BankTransactionCodeStructure4,
#[yaserde(rename = "Orgtr")]
#[cfg_attr(feature = "serde", serde(rename = "Orgtr"))]
pub orgtr: PartyIdentification135,
#[yaserde(rename = "Rsn")]
#[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
pub rsn: ReturnReason5Choice,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: Vec<Max105Text>,
}
impl Validate for PaymentReturnReason5 {}
#[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:camt.052.001.09")]
pub struct PersonIdentification13 {
#[yaserde(rename = "DtAndPlcOfBirth")]
#[cfg_attr(feature = "serde", serde(rename = "DtAndPlcOfBirth"))]
pub dt_and_plc_of_birth: DateAndPlaceOfBirth1,
#[yaserde(rename = "Othr")]
#[cfg_attr(feature = "serde", serde(rename = "Othr"))]
pub othr: Vec<GenericPersonIdentification1>,
}
impl Validate for PersonIdentification13 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct PersonIdentificationSchemeName1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<ExternalPersonIdentification1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<Max35Text>,
}
impl Validate for PersonIdentificationSchemeName1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct PhoneNumber (pub String);
crate::simple_type!(PhoneNumber);
impl Validate for PhoneNumber {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct PlainCardData1 {
#[yaserde(rename = "PAN")]
#[cfg_attr(feature = "serde", serde(rename = "PAN"))]
pub pan: Min8Max28NumericText,
#[yaserde(rename = "CardSeqNb")]
#[cfg_attr(feature = "serde", serde(rename = "CardSeqNb"))]
pub card_seq_nb: Min2Max3NumericText,
#[yaserde(rename = "FctvDt")]
#[cfg_attr(feature = "serde", serde(rename = "FctvDt"))]
pub fctv_dt: IsoyearMonth,
#[yaserde(rename = "XpryDt")]
#[cfg_attr(feature = "serde", serde(rename = "XpryDt"))]
pub xpry_dt: IsoyearMonth,
#[yaserde(rename = "SvcCd")]
#[cfg_attr(feature = "serde", serde(rename = "SvcCd"))]
pub svc_cd: Exact3NumericText,
#[yaserde(rename = "TrckData")]
#[cfg_attr(feature = "serde", serde(rename = "TrckData"))]
pub trck_data: Vec<TrackData1>,
#[yaserde(rename = "CardSctyCd")]
#[cfg_attr(feature = "serde", serde(rename = "CardSctyCd"))]
pub card_scty_cd: CardSecurityInformation1,
}
impl Validate for PlainCardData1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct PointOfInteraction1 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: GenericIdentification32,
#[yaserde(rename = "SysNm")]
#[cfg_attr(feature = "serde", serde(rename = "SysNm"))]
pub sys_nm: Max70Text,
#[yaserde(rename = "GrpId")]
#[cfg_attr(feature = "serde", serde(rename = "GrpId"))]
pub grp_id: Max35Text,
#[yaserde(rename = "Cpblties")]
#[cfg_attr(feature = "serde", serde(rename = "Cpblties"))]
pub cpblties: PointOfInteractionCapabilities1,
#[yaserde(rename = "Cmpnt")]
#[cfg_attr(feature = "serde", serde(rename = "Cmpnt"))]
pub cmpnt: Vec<PointOfInteractionComponent1>,
}
impl Validate for PointOfInteraction1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct PointOfInteractionCapabilities1 {
#[yaserde(rename = "CardRdngCpblties")]
#[cfg_attr(feature = "serde", serde(rename = "CardRdngCpblties"))]
pub card_rdng_cpblties: Vec<CardDataReading1Code>,
#[yaserde(rename = "CrdhldrVrfctnCpblties")]
#[cfg_attr(feature = "serde", serde(rename = "CrdhldrVrfctnCpblties"))]
pub crdhldr_vrfctn_cpblties: Vec<CardholderVerificationCapability1Code>,
#[yaserde(rename = "OnLineCpblties")]
#[cfg_attr(feature = "serde", serde(rename = "OnLineCpblties"))]
pub on_line_cpblties: OnLineCapability1Code,
#[yaserde(rename = "DispCpblties")]
#[cfg_attr(feature = "serde", serde(rename = "DispCpblties"))]
pub disp_cpblties: Vec<DisplayCapabilities1>,
#[yaserde(rename = "PrtLineWidth")]
#[cfg_attr(feature = "serde", serde(rename = "PrtLineWidth"))]
pub prt_line_width: Max3NumericText,
}
impl Validate for PointOfInteractionCapabilities1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct PointOfInteractionComponent1 {
#[yaserde(rename = "POICmpntTp")]
#[cfg_attr(feature = "serde", serde(rename = "POICmpntTp"))]
pub poi_cmpnt_tp: PoicomponentType1Code,
#[yaserde(rename = "ManfctrId")]
#[cfg_attr(feature = "serde", serde(rename = "ManfctrId"))]
pub manfctr_id: Max35Text,
#[yaserde(rename = "Mdl")]
#[cfg_attr(feature = "serde", serde(rename = "Mdl"))]
pub mdl: Max35Text,
#[yaserde(rename = "VrsnNb")]
#[cfg_attr(feature = "serde", serde(rename = "VrsnNb"))]
pub vrsn_nb: Max16Text,
#[yaserde(rename = "SrlNb")]
#[cfg_attr(feature = "serde", serde(rename = "SrlNb"))]
pub srl_nb: Max35Text,
#[yaserde(rename = "ApprvlNb")]
#[cfg_attr(feature = "serde", serde(rename = "ApprvlNb"))]
pub apprvl_nb: Vec<Max70Text>,
}
impl Validate for PointOfInteractionComponent1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct PostalAddress24 {
#[yaserde(rename = "AdrTp")]
#[cfg_attr(feature = "serde", serde(rename = "AdrTp"))]
pub adr_tp: AddressType3Choice,
#[yaserde(rename = "Dept")]
#[cfg_attr(feature = "serde", serde(rename = "Dept"))]
pub dept: Max70Text,
#[yaserde(rename = "SubDept")]
#[cfg_attr(feature = "serde", serde(rename = "SubDept"))]
pub sub_dept: Max70Text,
#[yaserde(rename = "StrtNm")]
#[cfg_attr(feature = "serde", serde(rename = "StrtNm"))]
pub strt_nm: Max70Text,
#[yaserde(rename = "BldgNb")]
#[cfg_attr(feature = "serde", serde(rename = "BldgNb"))]
pub bldg_nb: Max16Text,
#[yaserde(rename = "BldgNm")]
#[cfg_attr(feature = "serde", serde(rename = "BldgNm"))]
pub bldg_nm: Max35Text,
#[yaserde(rename = "Flr")]
#[cfg_attr(feature = "serde", serde(rename = "Flr"))]
pub flr: Max70Text,
#[yaserde(rename = "PstBx")]
#[cfg_attr(feature = "serde", serde(rename = "PstBx"))]
pub pst_bx: Max16Text,
#[yaserde(rename = "Room")]
#[cfg_attr(feature = "serde", serde(rename = "Room"))]
pub room: Max70Text,
#[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 = "TwnLctnNm")]
#[cfg_attr(feature = "serde", serde(rename = "TwnLctnNm"))]
pub twn_lctn_nm: Max35Text,
#[yaserde(rename = "DstrctNm")]
#[cfg_attr(feature = "serde", serde(rename = "DstrctNm"))]
pub dstrct_nm: Max35Text,
#[yaserde(rename = "CtrySubDvsn")]
#[cfg_attr(feature = "serde", serde(rename = "CtrySubDvsn"))]
pub ctry_sub_dvsn: Max35Text,
#[yaserde(rename = "Ctry")]
#[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
pub ctry: CountryCode,
#[yaserde(rename = "AdrLine")]
#[cfg_attr(feature = "serde", serde(rename = "AdrLine"))]
pub adr_line: Vec<Max70Text>,
}
impl Validate for PostalAddress24 {}
#[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:camt.052.001.09")]
pub enum PreferredContactMethod1Code {
#[yaserde(rename = "LETT")]
#[cfg_attr(feature = "serde", serde(rename = "LETT"))]
Lett,
#[yaserde(rename = "MAIL")]
#[cfg_attr(feature = "serde", serde(rename = "MAIL"))]
Mail,
#[yaserde(rename = "PHON")]
#[cfg_attr(feature = "serde", serde(rename = "PHON"))]
Phon,
#[yaserde(rename = "FAXX")]
#[cfg_attr(feature = "serde", serde(rename = "FAXX"))]
Faxx,
#[yaserde(rename = "CELL")]
#[cfg_attr(feature = "serde", serde(rename = "CELL"))]
Cell,
__Unknown__(String),
}
impl Default for PreferredContactMethod1Code {
fn default() -> PreferredContactMethod1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for PreferredContactMethod1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct Price7 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: YieldedOrValueType1Choice,
#[yaserde(rename = "Val")]
#[cfg_attr(feature = "serde", serde(rename = "Val"))]
pub val: PriceRateOrAmount3Choice,
}
impl Validate for Price7 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct PriceRateOrAmount3Choice {
#[yaserde(rename = "Rate")]
#[cfg_attr(feature = "serde", serde(rename = "Rate"))]
pub rate: Option<PercentageRate>,
#[yaserde(rename = "Amt")]
#[cfg_attr(feature = "serde", serde(rename = "Amt"))]
pub amt: Option<ActiveOrHistoricCurrencyAnd13DecimalAmount>,
}
impl Validate for PriceRateOrAmount3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub enum PriceValueType1Code {
#[yaserde(rename = "DISC")]
#[cfg_attr(feature = "serde", serde(rename = "DISC"))]
Disc,
#[yaserde(rename = "PREM")]
#[cfg_attr(feature = "serde", serde(rename = "PREM"))]
Prem,
#[yaserde(rename = "PARV")]
#[cfg_attr(feature = "serde", serde(rename = "PARV"))]
Parv,
__Unknown__(String),
}
impl Default for PriceValueType1Code {
fn default() -> PriceValueType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for PriceValueType1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct Product2 {
#[yaserde(rename = "PdctCd")]
#[cfg_attr(feature = "serde", serde(rename = "PdctCd"))]
pub pdct_cd: Max70Text,
#[yaserde(rename = "UnitOfMeasr")]
#[cfg_attr(feature = "serde", serde(rename = "UnitOfMeasr"))]
pub unit_of_measr: UnitOfMeasure1Code,
#[yaserde(rename = "PdctQty")]
#[cfg_attr(feature = "serde", serde(rename = "PdctQty"))]
pub pdct_qty: DecimalNumber,
#[yaserde(rename = "UnitPric")]
#[cfg_attr(feature = "serde", serde(rename = "UnitPric"))]
pub unit_pric: ImpliedCurrencyAndAmount,
#[yaserde(rename = "PdctAmt")]
#[cfg_attr(feature = "serde", serde(rename = "PdctAmt"))]
pub pdct_amt: ImpliedCurrencyAndAmount,
#[yaserde(rename = "TaxTp")]
#[cfg_attr(feature = "serde", serde(rename = "TaxTp"))]
pub tax_tp: Max35Text,
#[yaserde(rename = "AddtlPdctInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlPdctInf"))]
pub addtl_pdct_inf: Max35Text,
}
impl Validate for Product2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct ProprietaryAgent4 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: Max35Text,
#[yaserde(rename = "Agt")]
#[cfg_attr(feature = "serde", serde(rename = "Agt"))]
pub agt: BranchAndFinancialInstitutionIdentification6,
}
impl Validate for ProprietaryAgent4 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct ProprietaryBankTransactionCodeStructure1 {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Max35Text,
#[yaserde(rename = "Issr")]
#[cfg_attr(feature = "serde", serde(rename = "Issr"))]
pub issr: Max35Text,
}
impl Validate for ProprietaryBankTransactionCodeStructure1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct ProprietaryDate3 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: Max35Text,
#[yaserde(rename = "Dt")]
#[cfg_attr(feature = "serde", serde(rename = "Dt"))]
pub dt: DateAndDateTime2Choice,
}
impl Validate for ProprietaryDate3 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct ProprietaryParty5 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: Max35Text,
#[yaserde(rename = "Pty")]
#[cfg_attr(feature = "serde", serde(rename = "Pty"))]
pub pty: Party40Choice,
}
impl Validate for ProprietaryParty5 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct ProprietaryPrice2 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: Max35Text,
#[yaserde(rename = "Pric")]
#[cfg_attr(feature = "serde", serde(rename = "Pric"))]
pub pric: ActiveOrHistoricCurrencyAndAmount,
}
impl Validate for ProprietaryPrice2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct ProprietaryQuantity1 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: Max35Text,
#[yaserde(rename = "Qty")]
#[cfg_attr(feature = "serde", serde(rename = "Qty"))]
pub qty: Max35Text,
}
impl Validate for ProprietaryQuantity1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct ProprietaryReference1 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: Max35Text,
#[yaserde(rename = "Ref")]
#[cfg_attr(feature = "serde", serde(rename = "Ref"))]
pub _ref: Max35Text,
}
impl Validate for ProprietaryReference1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct ProxyAccountIdentification1 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: ProxyAccountType1Choice,
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max2048Text,
}
impl Validate for ProxyAccountIdentification1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct ProxyAccountType1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<ExternalProxyAccountType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<Max35Text>,
}
impl Validate for ProxyAccountType1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct Purpose2Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<ExternalPurpose1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<Max35Text>,
}
impl Validate for Purpose2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct Rate4 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: RateType4Choice,
#[yaserde(rename = "VldtyRg")]
#[cfg_attr(feature = "serde", serde(rename = "VldtyRg"))]
pub vldty_rg: ActiveOrHistoricCurrencyAndAmountRange2,
}
impl Validate for Rate4 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct RateType4Choice {
#[yaserde(rename = "Pctg")]
#[cfg_attr(feature = "serde", serde(rename = "Pctg"))]
pub pctg: Option<PercentageRate>,
#[yaserde(rename = "Othr")]
#[cfg_attr(feature = "serde", serde(rename = "Othr"))]
pub othr: Option<Max35Text>,
}
impl Validate for RateType4Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct ReferredDocumentInformation7 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: ReferredDocumentType4,
#[yaserde(rename = "Nb")]
#[cfg_attr(feature = "serde", serde(rename = "Nb"))]
pub nb: Max35Text,
#[yaserde(rename = "RltdDt")]
#[cfg_attr(feature = "serde", serde(rename = "RltdDt"))]
pub rltd_dt: Isodate,
#[yaserde(rename = "LineDtls")]
#[cfg_attr(feature = "serde", serde(rename = "LineDtls"))]
pub line_dtls: Vec<DocumentLineInformation1>,
}
impl Validate for ReferredDocumentInformation7 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct ReferredDocumentType3Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<DocumentType6Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<Max35Text>,
}
impl Validate for ReferredDocumentType3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct ReferredDocumentType4 {
#[yaserde(rename = "CdOrPrtry")]
#[cfg_attr(feature = "serde", serde(rename = "CdOrPrtry"))]
pub cd_or_prtry: ReferredDocumentType3Choice,
#[yaserde(rename = "Issr")]
#[cfg_attr(feature = "serde", serde(rename = "Issr"))]
pub issr: Max35Text,
}
impl Validate for ReferredDocumentType4 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct RemittanceAmount2 {
#[yaserde(rename = "DuePyblAmt")]
#[cfg_attr(feature = "serde", serde(rename = "DuePyblAmt"))]
pub due_pybl_amt: ActiveOrHistoricCurrencyAndAmount,
#[yaserde(rename = "DscntApldAmt")]
#[cfg_attr(feature = "serde", serde(rename = "DscntApldAmt"))]
pub dscnt_apld_amt: Vec<DiscountAmountAndType1>,
#[yaserde(rename = "CdtNoteAmt")]
#[cfg_attr(feature = "serde", serde(rename = "CdtNoteAmt"))]
pub cdt_note_amt: ActiveOrHistoricCurrencyAndAmount,
#[yaserde(rename = "TaxAmt")]
#[cfg_attr(feature = "serde", serde(rename = "TaxAmt"))]
pub tax_amt: Vec<TaxAmountAndType1>,
#[yaserde(rename = "AdjstmntAmtAndRsn")]
#[cfg_attr(feature = "serde", serde(rename = "AdjstmntAmtAndRsn"))]
pub adjstmnt_amt_and_rsn: Vec<DocumentAdjustment1>,
#[yaserde(rename = "RmtdAmt")]
#[cfg_attr(feature = "serde", serde(rename = "RmtdAmt"))]
pub rmtd_amt: ActiveOrHistoricCurrencyAndAmount,
}
impl Validate for RemittanceAmount2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct RemittanceAmount3 {
#[yaserde(rename = "DuePyblAmt")]
#[cfg_attr(feature = "serde", serde(rename = "DuePyblAmt"))]
pub due_pybl_amt: ActiveOrHistoricCurrencyAndAmount,
#[yaserde(rename = "DscntApldAmt")]
#[cfg_attr(feature = "serde", serde(rename = "DscntApldAmt"))]
pub dscnt_apld_amt: Vec<DiscountAmountAndType1>,
#[yaserde(rename = "CdtNoteAmt")]
#[cfg_attr(feature = "serde", serde(rename = "CdtNoteAmt"))]
pub cdt_note_amt: ActiveOrHistoricCurrencyAndAmount,
#[yaserde(rename = "TaxAmt")]
#[cfg_attr(feature = "serde", serde(rename = "TaxAmt"))]
pub tax_amt: Vec<TaxAmountAndType1>,
#[yaserde(rename = "AdjstmntAmtAndRsn")]
#[cfg_attr(feature = "serde", serde(rename = "AdjstmntAmtAndRsn"))]
pub adjstmnt_amt_and_rsn: Vec<DocumentAdjustment1>,
#[yaserde(rename = "RmtdAmt")]
#[cfg_attr(feature = "serde", serde(rename = "RmtdAmt"))]
pub rmtd_amt: ActiveOrHistoricCurrencyAndAmount,
}
impl Validate for RemittanceAmount3 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct RemittanceInformation21 {
#[yaserde(rename = "Ustrd")]
#[cfg_attr(feature = "serde", serde(rename = "Ustrd"))]
pub ustrd: Vec<Max140Text>,
#[yaserde(rename = "Strd")]
#[cfg_attr(feature = "serde", serde(rename = "Strd"))]
pub strd: Vec<StructuredRemittanceInformation17>,
}
impl Validate for RemittanceInformation21 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct RemittanceLocation7 {
#[yaserde(rename = "RmtId")]
#[cfg_attr(feature = "serde", serde(rename = "RmtId"))]
pub rmt_id: Max35Text,
#[yaserde(rename = "RmtLctnDtls")]
#[cfg_attr(feature = "serde", serde(rename = "RmtLctnDtls"))]
pub rmt_lctn_dtls: Vec<RemittanceLocationData1>,
}
impl Validate for RemittanceLocation7 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct RemittanceLocationData1 {
#[yaserde(rename = "Mtd")]
#[cfg_attr(feature = "serde", serde(rename = "Mtd"))]
pub mtd: RemittanceLocationMethod2Code,
#[yaserde(rename = "ElctrncAdr")]
#[cfg_attr(feature = "serde", serde(rename = "ElctrncAdr"))]
pub elctrnc_adr: Max2048Text,
#[yaserde(rename = "PstlAdr")]
#[cfg_attr(feature = "serde", serde(rename = "PstlAdr"))]
pub pstl_adr: NameAndAddress16,
}
impl Validate for RemittanceLocationData1 {}
#[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:camt.052.001.09")]
pub enum RemittanceLocationMethod2Code {
#[yaserde(rename = "FAXI")]
#[cfg_attr(feature = "serde", serde(rename = "FAXI"))]
Faxi,
#[yaserde(rename = "EDIC")]
#[cfg_attr(feature = "serde", serde(rename = "EDIC"))]
Edic,
#[yaserde(rename = "URID")]
#[cfg_attr(feature = "serde", serde(rename = "URID"))]
Urid,
#[yaserde(rename = "EMAL")]
#[cfg_attr(feature = "serde", serde(rename = "EMAL"))]
Emal,
#[yaserde(rename = "POST")]
#[cfg_attr(feature = "serde", serde(rename = "POST"))]
Post,
#[yaserde(rename = "SMSM")]
#[cfg_attr(feature = "serde", serde(rename = "SMSM"))]
Smsm,
__Unknown__(String),
}
impl Default for RemittanceLocationMethod2Code {
fn default() -> RemittanceLocationMethod2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for RemittanceLocationMethod2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct ReportEntry11 {
#[yaserde(rename = "NtryRef")]
#[cfg_attr(feature = "serde", serde(rename = "NtryRef"))]
pub ntry_ref: Max35Text,
#[yaserde(rename = "Amt")]
#[cfg_attr(feature = "serde", serde(rename = "Amt"))]
pub amt: ActiveOrHistoricCurrencyAndAmount,
#[yaserde(rename = "CdtDbtInd")]
#[cfg_attr(feature = "serde", serde(rename = "CdtDbtInd"))]
pub cdt_dbt_ind: CreditDebitCode,
#[yaserde(rename = "RvslInd")]
#[cfg_attr(feature = "serde", serde(rename = "RvslInd"))]
pub rvsl_ind: TrueFalseIndicator,
#[yaserde(rename = "Sts")]
#[cfg_attr(feature = "serde", serde(rename = "Sts"))]
pub sts: EntryStatus1Choice,
#[yaserde(rename = "BookgDt")]
#[cfg_attr(feature = "serde", serde(rename = "BookgDt"))]
pub bookg_dt: DateAndDateTime2Choice,
#[yaserde(rename = "ValDt")]
#[cfg_attr(feature = "serde", serde(rename = "ValDt"))]
pub val_dt: DateAndDateTime2Choice,
#[yaserde(rename = "AcctSvcrRef")]
#[cfg_attr(feature = "serde", serde(rename = "AcctSvcrRef"))]
pub acct_svcr_ref: Max35Text,
#[yaserde(rename = "Avlbty")]
#[cfg_attr(feature = "serde", serde(rename = "Avlbty"))]
pub avlbty: Vec<CashAvailability1>,
#[yaserde(rename = "BkTxCd")]
#[cfg_attr(feature = "serde", serde(rename = "BkTxCd"))]
pub bk_tx_cd: BankTransactionCodeStructure4,
#[yaserde(rename = "ComssnWvrInd")]
#[cfg_attr(feature = "serde", serde(rename = "ComssnWvrInd"))]
pub comssn_wvr_ind: YesNoIndicator,
#[yaserde(rename = "AddtlInfInd")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInfInd"))]
pub addtl_inf_ind: MessageIdentification2,
#[yaserde(rename = "AmtDtls")]
#[cfg_attr(feature = "serde", serde(rename = "AmtDtls"))]
pub amt_dtls: AmountAndCurrencyExchange3,
#[yaserde(rename = "Chrgs")]
#[cfg_attr(feature = "serde", serde(rename = "Chrgs"))]
pub chrgs: Charges6,
#[yaserde(rename = "TechInptChanl")]
#[cfg_attr(feature = "serde", serde(rename = "TechInptChanl"))]
pub tech_inpt_chanl: TechnicalInputChannel1Choice,
#[yaserde(rename = "Intrst")]
#[cfg_attr(feature = "serde", serde(rename = "Intrst"))]
pub intrst: TransactionInterest4,
#[yaserde(rename = "CardTx")]
#[cfg_attr(feature = "serde", serde(rename = "CardTx"))]
pub card_tx: CardEntry5,
#[yaserde(rename = "NtryDtls")]
#[cfg_attr(feature = "serde", serde(rename = "NtryDtls"))]
pub ntry_dtls: Vec<EntryDetails10>,
#[yaserde(rename = "AddtlNtryInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlNtryInf"))]
pub addtl_ntry_inf: Max500Text,
}
impl Validate for ReportEntry11 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct ReportingSource1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<ExternalReportingSource1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<Max35Text>,
}
impl Validate for ReportingSource1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct ReturnReason5Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<ExternalReturnReason1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<Max35Text>,
}
impl Validate for ReturnReason5Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct SecuritiesAccount19 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max35Text,
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: GenericIdentification30,
#[yaserde(rename = "Nm")]
#[cfg_attr(feature = "serde", serde(rename = "Nm"))]
pub nm: Max70Text,
}
impl Validate for SecuritiesAccount19 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct SecurityIdentification19 {
#[yaserde(rename = "ISIN")]
#[cfg_attr(feature = "serde", serde(rename = "ISIN"))]
pub isin: Isinoct2015Identifier,
#[yaserde(rename = "OthrId")]
#[cfg_attr(feature = "serde", serde(rename = "OthrId"))]
pub othr_id: Vec<OtherIdentification1>,
#[yaserde(rename = "Desc")]
#[cfg_attr(feature = "serde", serde(rename = "Desc"))]
pub desc: Max140Text,
}
impl Validate for SecurityIdentification19 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct SequenceRange1 {
#[yaserde(rename = "FrSeq")]
#[cfg_attr(feature = "serde", serde(rename = "FrSeq"))]
pub fr_seq: Max35Text,
#[yaserde(rename = "ToSeq")]
#[cfg_attr(feature = "serde", serde(rename = "ToSeq"))]
pub to_seq: Max35Text,
}
impl Validate for SequenceRange1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct SequenceRange1Choice {
#[yaserde(rename = "FrSeq")]
#[cfg_attr(feature = "serde", serde(rename = "FrSeq"))]
pub fr_seq: Option<Max35Text>,
#[yaserde(rename = "ToSeq")]
#[cfg_attr(feature = "serde", serde(rename = "ToSeq"))]
pub to_seq: Option<Max35Text>,
#[yaserde(rename = "FrToSeq")]
#[cfg_attr(feature = "serde", serde(rename = "FrToSeq"))]
pub fr_to_seq: Vec<SequenceRange1>,
#[yaserde(rename = "EQSeq")]
#[cfg_attr(feature = "serde", serde(rename = "EQSeq"))]
pub eqseq: Vec<Max35Text>,
#[yaserde(rename = "NEQSeq")]
#[cfg_attr(feature = "serde", serde(rename = "NEQSeq"))]
pub neqseq: Vec<Max35Text>,
}
impl Validate for SequenceRange1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct StructuredRemittanceInformation17 {
#[yaserde(rename = "RfrdDocInf")]
#[cfg_attr(feature = "serde", serde(rename = "RfrdDocInf"))]
pub rfrd_doc_inf: Vec<ReferredDocumentInformation7>,
#[yaserde(rename = "RfrdDocAmt")]
#[cfg_attr(feature = "serde", serde(rename = "RfrdDocAmt"))]
pub rfrd_doc_amt: RemittanceAmount2,
#[yaserde(rename = "CdtrRefInf")]
#[cfg_attr(feature = "serde", serde(rename = "CdtrRefInf"))]
pub cdtr_ref_inf: CreditorReferenceInformation2,
#[yaserde(rename = "Invcr")]
#[cfg_attr(feature = "serde", serde(rename = "Invcr"))]
pub invcr: PartyIdentification135,
#[yaserde(rename = "Invcee")]
#[cfg_attr(feature = "serde", serde(rename = "Invcee"))]
pub invcee: PartyIdentification135,
#[yaserde(rename = "TaxRmt")]
#[cfg_attr(feature = "serde", serde(rename = "TaxRmt"))]
pub tax_rmt: TaxData1,
#[yaserde(rename = "GrnshmtRmt")]
#[cfg_attr(feature = "serde", serde(rename = "GrnshmtRmt"))]
pub grnshmt_rmt: Garnishment3,
#[yaserde(rename = "AddtlRmtInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlRmtInf"))]
pub addtl_rmt_inf: Vec<Max140Text>,
}
impl Validate for StructuredRemittanceInformation17 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct SupplementaryData1 {
#[yaserde(rename = "PlcAndNm")]
#[cfg_attr(feature = "serde", serde(rename = "PlcAndNm"))]
pub plc_and_nm: Max350Text,
#[yaserde(rename = "Envlp")]
#[cfg_attr(feature = "serde", serde(rename = "Envlp"))]
pub envlp: SupplementaryDataEnvelope1,
}
impl Validate for SupplementaryData1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct SupplementaryDataEnvelope1 {}
impl Validate for SupplementaryDataEnvelope1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct TaxAmount3 {
#[yaserde(rename = "Rate")]
#[cfg_attr(feature = "serde", serde(rename = "Rate"))]
pub rate: PercentageRate,
#[yaserde(rename = "TaxblBaseAmt")]
#[cfg_attr(feature = "serde", serde(rename = "TaxblBaseAmt"))]
pub taxbl_base_amt: ActiveOrHistoricCurrencyAndAmount,
#[yaserde(rename = "TtlAmt")]
#[cfg_attr(feature = "serde", serde(rename = "TtlAmt"))]
pub ttl_amt: ActiveOrHistoricCurrencyAndAmount,
#[yaserde(rename = "Dtls")]
#[cfg_attr(feature = "serde", serde(rename = "Dtls"))]
pub dtls: Vec<TaxRecordDetails3>,
}
impl Validate for TaxAmount3 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct TaxAmountAndType1 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: TaxAmountType1Choice,
#[yaserde(rename = "Amt")]
#[cfg_attr(feature = "serde", serde(rename = "Amt"))]
pub amt: ActiveOrHistoricCurrencyAndAmount,
}
impl Validate for TaxAmountAndType1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct TaxAmountType1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<ExternalTaxAmountType1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<Max35Text>,
}
impl Validate for TaxAmountType1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct TaxAuthorisation1 {
#[yaserde(rename = "Titl")]
#[cfg_attr(feature = "serde", serde(rename = "Titl"))]
pub titl: Max35Text,
#[yaserde(rename = "Nm")]
#[cfg_attr(feature = "serde", serde(rename = "Nm"))]
pub nm: Max140Text,
}
impl Validate for TaxAuthorisation1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct TaxCharges2 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max35Text,
#[yaserde(rename = "Rate")]
#[cfg_attr(feature = "serde", serde(rename = "Rate"))]
pub rate: PercentageRate,
#[yaserde(rename = "Amt")]
#[cfg_attr(feature = "serde", serde(rename = "Amt"))]
pub amt: ActiveOrHistoricCurrencyAndAmount,
}
impl Validate for TaxCharges2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct TaxData1 {
#[yaserde(rename = "Cdtr")]
#[cfg_attr(feature = "serde", serde(rename = "Cdtr"))]
pub cdtr: TaxParty1,
#[yaserde(rename = "Dbtr")]
#[cfg_attr(feature = "serde", serde(rename = "Dbtr"))]
pub dbtr: TaxParty2,
#[yaserde(rename = "UltmtDbtr")]
#[cfg_attr(feature = "serde", serde(rename = "UltmtDbtr"))]
pub ultmt_dbtr: TaxParty2,
#[yaserde(rename = "AdmstnZone")]
#[cfg_attr(feature = "serde", serde(rename = "AdmstnZone"))]
pub admstn_zone: Max35Text,
#[yaserde(rename = "RefNb")]
#[cfg_attr(feature = "serde", serde(rename = "RefNb"))]
pub ref_nb: Max140Text,
#[yaserde(rename = "Mtd")]
#[cfg_attr(feature = "serde", serde(rename = "Mtd"))]
pub mtd: Max35Text,
#[yaserde(rename = "TtlTaxblBaseAmt")]
#[cfg_attr(feature = "serde", serde(rename = "TtlTaxblBaseAmt"))]
pub ttl_taxbl_base_amt: ActiveOrHistoricCurrencyAndAmount,
#[yaserde(rename = "TtlTaxAmt")]
#[cfg_attr(feature = "serde", serde(rename = "TtlTaxAmt"))]
pub ttl_tax_amt: ActiveOrHistoricCurrencyAndAmount,
#[yaserde(rename = "Dt")]
#[cfg_attr(feature = "serde", serde(rename = "Dt"))]
pub dt: Isodate,
#[yaserde(rename = "SeqNb")]
#[cfg_attr(feature = "serde", serde(rename = "SeqNb"))]
pub seq_nb: Number,
#[yaserde(rename = "Rcrd")]
#[cfg_attr(feature = "serde", serde(rename = "Rcrd"))]
pub rcrd: Vec<TaxRecord3>,
}
impl Validate for TaxData1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct TaxInformation10 {
#[yaserde(rename = "Cdtr")]
#[cfg_attr(feature = "serde", serde(rename = "Cdtr"))]
pub cdtr: TaxParty1,
#[yaserde(rename = "Dbtr")]
#[cfg_attr(feature = "serde", serde(rename = "Dbtr"))]
pub dbtr: TaxParty2,
#[yaserde(rename = "AdmstnZone")]
#[cfg_attr(feature = "serde", serde(rename = "AdmstnZone"))]
pub admstn_zone: Max35Text,
#[yaserde(rename = "RefNb")]
#[cfg_attr(feature = "serde", serde(rename = "RefNb"))]
pub ref_nb: Max140Text,
#[yaserde(rename = "Mtd")]
#[cfg_attr(feature = "serde", serde(rename = "Mtd"))]
pub mtd: Max35Text,
#[yaserde(rename = "TtlTaxblBaseAmt")]
#[cfg_attr(feature = "serde", serde(rename = "TtlTaxblBaseAmt"))]
pub ttl_taxbl_base_amt: ActiveOrHistoricCurrencyAndAmount,
#[yaserde(rename = "TtlTaxAmt")]
#[cfg_attr(feature = "serde", serde(rename = "TtlTaxAmt"))]
pub ttl_tax_amt: ActiveOrHistoricCurrencyAndAmount,
#[yaserde(rename = "Dt")]
#[cfg_attr(feature = "serde", serde(rename = "Dt"))]
pub dt: Isodate,
#[yaserde(rename = "SeqNb")]
#[cfg_attr(feature = "serde", serde(rename = "SeqNb"))]
pub seq_nb: Number,
#[yaserde(rename = "Rcrd")]
#[cfg_attr(feature = "serde", serde(rename = "Rcrd"))]
pub rcrd: Vec<TaxRecord3>,
}
impl Validate for TaxInformation10 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct TaxParty1 {
#[yaserde(rename = "TaxId")]
#[cfg_attr(feature = "serde", serde(rename = "TaxId"))]
pub tax_id: Max35Text,
#[yaserde(rename = "RegnId")]
#[cfg_attr(feature = "serde", serde(rename = "RegnId"))]
pub regn_id: Max35Text,
#[yaserde(rename = "TaxTp")]
#[cfg_attr(feature = "serde", serde(rename = "TaxTp"))]
pub tax_tp: Max35Text,
}
impl Validate for TaxParty1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct TaxParty2 {
#[yaserde(rename = "TaxId")]
#[cfg_attr(feature = "serde", serde(rename = "TaxId"))]
pub tax_id: Max35Text,
#[yaserde(rename = "RegnId")]
#[cfg_attr(feature = "serde", serde(rename = "RegnId"))]
pub regn_id: Max35Text,
#[yaserde(rename = "TaxTp")]
#[cfg_attr(feature = "serde", serde(rename = "TaxTp"))]
pub tax_tp: Max35Text,
#[yaserde(rename = "Authstn")]
#[cfg_attr(feature = "serde", serde(rename = "Authstn"))]
pub authstn: TaxAuthorisation1,
}
impl Validate for TaxParty2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct TaxPeriod3 {
#[yaserde(rename = "Yr")]
#[cfg_attr(feature = "serde", serde(rename = "Yr"))]
pub yr: Isoyear,
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: TaxRecordPeriod1Code,
#[yaserde(rename = "FrToDt")]
#[cfg_attr(feature = "serde", serde(rename = "FrToDt"))]
pub fr_to_dt: DatePeriod2,
}
impl Validate for TaxPeriod3 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct TaxRecord3 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: Max35Text,
#[yaserde(rename = "Ctgy")]
#[cfg_attr(feature = "serde", serde(rename = "Ctgy"))]
pub ctgy: Max35Text,
#[yaserde(rename = "CtgyDtls")]
#[cfg_attr(feature = "serde", serde(rename = "CtgyDtls"))]
pub ctgy_dtls: Max35Text,
#[yaserde(rename = "DbtrSts")]
#[cfg_attr(feature = "serde", serde(rename = "DbtrSts"))]
pub dbtr_sts: Max35Text,
#[yaserde(rename = "CertId")]
#[cfg_attr(feature = "serde", serde(rename = "CertId"))]
pub cert_id: Max35Text,
#[yaserde(rename = "FrmsCd")]
#[cfg_attr(feature = "serde", serde(rename = "FrmsCd"))]
pub frms_cd: Max35Text,
#[yaserde(rename = "Prd")]
#[cfg_attr(feature = "serde", serde(rename = "Prd"))]
pub prd: TaxPeriod3,
#[yaserde(rename = "TaxAmt")]
#[cfg_attr(feature = "serde", serde(rename = "TaxAmt"))]
pub tax_amt: TaxAmount3,
#[yaserde(rename = "AddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
pub addtl_inf: Max140Text,
}
impl Validate for TaxRecord3 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct TaxRecordDetails3 {
#[yaserde(rename = "Prd")]
#[cfg_attr(feature = "serde", serde(rename = "Prd"))]
pub prd: TaxPeriod3,
#[yaserde(rename = "Amt")]
#[cfg_attr(feature = "serde", serde(rename = "Amt"))]
pub amt: ActiveOrHistoricCurrencyAndAmount,
}
impl Validate for TaxRecordDetails3 {}
#[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:camt.052.001.09")]
pub enum TaxRecordPeriod1Code {
#[yaserde(rename = "MM01")]
#[cfg_attr(feature = "serde", serde(rename = "MM01"))]
Mm01,
#[yaserde(rename = "MM02")]
#[cfg_attr(feature = "serde", serde(rename = "MM02"))]
Mm02,
#[yaserde(rename = "MM03")]
#[cfg_attr(feature = "serde", serde(rename = "MM03"))]
Mm03,
#[yaserde(rename = "MM04")]
#[cfg_attr(feature = "serde", serde(rename = "MM04"))]
Mm04,
#[yaserde(rename = "MM05")]
#[cfg_attr(feature = "serde", serde(rename = "MM05"))]
Mm05,
#[yaserde(rename = "MM06")]
#[cfg_attr(feature = "serde", serde(rename = "MM06"))]
Mm06,
#[yaserde(rename = "MM07")]
#[cfg_attr(feature = "serde", serde(rename = "MM07"))]
Mm07,
#[yaserde(rename = "MM08")]
#[cfg_attr(feature = "serde", serde(rename = "MM08"))]
Mm08,
#[yaserde(rename = "MM09")]
#[cfg_attr(feature = "serde", serde(rename = "MM09"))]
Mm09,
#[yaserde(rename = "MM10")]
#[cfg_attr(feature = "serde", serde(rename = "MM10"))]
Mm10,
#[yaserde(rename = "MM11")]
#[cfg_attr(feature = "serde", serde(rename = "MM11"))]
Mm11,
#[yaserde(rename = "MM12")]
#[cfg_attr(feature = "serde", serde(rename = "MM12"))]
Mm12,
#[yaserde(rename = "QTR1")]
#[cfg_attr(feature = "serde", serde(rename = "QTR1"))]
Qtr1,
#[yaserde(rename = "QTR2")]
#[cfg_attr(feature = "serde", serde(rename = "QTR2"))]
Qtr2,
#[yaserde(rename = "QTR3")]
#[cfg_attr(feature = "serde", serde(rename = "QTR3"))]
Qtr3,
#[yaserde(rename = "QTR4")]
#[cfg_attr(feature = "serde", serde(rename = "QTR4"))]
Qtr4,
#[yaserde(rename = "HLF1")]
#[cfg_attr(feature = "serde", serde(rename = "HLF1"))]
Hlf1,
#[yaserde(rename = "HLF2")]
#[cfg_attr(feature = "serde", serde(rename = "HLF2"))]
Hlf2,
__Unknown__(String),
}
impl Default for TaxRecordPeriod1Code {
fn default() -> TaxRecordPeriod1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for TaxRecordPeriod1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct TechnicalInputChannel1Choice {
#[yaserde(rename = "Cd")]
#[cfg_attr(feature = "serde", serde(rename = "Cd"))]
pub cd: Option<ExternalTechnicalInputChannel1Code>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<Max35Text>,
}
impl Validate for TechnicalInputChannel1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct TotalTransactions6 {
#[yaserde(rename = "TtlNtries")]
#[cfg_attr(feature = "serde", serde(rename = "TtlNtries"))]
pub ttl_ntries: NumberAndSumOfTransactions4,
#[yaserde(rename = "TtlCdtNtries")]
#[cfg_attr(feature = "serde", serde(rename = "TtlCdtNtries"))]
pub ttl_cdt_ntries: NumberAndSumOfTransactions1,
#[yaserde(rename = "TtlDbtNtries")]
#[cfg_attr(feature = "serde", serde(rename = "TtlDbtNtries"))]
pub ttl_dbt_ntries: NumberAndSumOfTransactions1,
#[yaserde(rename = "TtlNtriesPerBkTxCd")]
#[cfg_attr(feature = "serde", serde(rename = "TtlNtriesPerBkTxCd"))]
pub ttl_ntries_per_bk_tx_cd: Vec<TotalsPerBankTransactionCode5>,
}
impl Validate for TotalTransactions6 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct TotalsPerBankTransactionCode5 {
#[yaserde(rename = "NbOfNtries")]
#[cfg_attr(feature = "serde", serde(rename = "NbOfNtries"))]
pub nb_of_ntries: Max15NumericText,
#[yaserde(rename = "Sum")]
#[cfg_attr(feature = "serde", serde(rename = "Sum"))]
pub sum: DecimalNumber,
#[yaserde(rename = "TtlNetNtry")]
#[cfg_attr(feature = "serde", serde(rename = "TtlNetNtry"))]
pub ttl_net_ntry: AmountAndDirection35,
#[yaserde(rename = "CdtNtries")]
#[cfg_attr(feature = "serde", serde(rename = "CdtNtries"))]
pub cdt_ntries: NumberAndSumOfTransactions1,
#[yaserde(rename = "DbtNtries")]
#[cfg_attr(feature = "serde", serde(rename = "DbtNtries"))]
pub dbt_ntries: NumberAndSumOfTransactions1,
#[yaserde(rename = "FcstInd")]
#[cfg_attr(feature = "serde", serde(rename = "FcstInd"))]
pub fcst_ind: TrueFalseIndicator,
#[yaserde(rename = "BkTxCd")]
#[cfg_attr(feature = "serde", serde(rename = "BkTxCd"))]
pub bk_tx_cd: BankTransactionCodeStructure4,
#[yaserde(rename = "Avlbty")]
#[cfg_attr(feature = "serde", serde(rename = "Avlbty"))]
pub avlbty: Vec<CashAvailability1>,
#[yaserde(rename = "Dt")]
#[cfg_attr(feature = "serde", serde(rename = "Dt"))]
pub dt: DateAndDateTime2Choice,
}
impl Validate for TotalsPerBankTransactionCode5 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct TrackData1 {
#[yaserde(rename = "TrckNb")]
#[cfg_attr(feature = "serde", serde(rename = "TrckNb"))]
pub trck_nb: Exact1NumericText,
#[yaserde(rename = "TrckVal")]
#[cfg_attr(feature = "serde", serde(rename = "TrckVal"))]
pub trck_val: Max140Text,
}
impl Validate for TrackData1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct TransactionAgents5 {
#[yaserde(rename = "InstgAgt")]
#[cfg_attr(feature = "serde", serde(rename = "InstgAgt"))]
pub instg_agt: BranchAndFinancialInstitutionIdentification6,
#[yaserde(rename = "InstdAgt")]
#[cfg_attr(feature = "serde", serde(rename = "InstdAgt"))]
pub instd_agt: BranchAndFinancialInstitutionIdentification6,
#[yaserde(rename = "DbtrAgt")]
#[cfg_attr(feature = "serde", serde(rename = "DbtrAgt"))]
pub dbtr_agt: BranchAndFinancialInstitutionIdentification6,
#[yaserde(rename = "CdtrAgt")]
#[cfg_attr(feature = "serde", serde(rename = "CdtrAgt"))]
pub cdtr_agt: BranchAndFinancialInstitutionIdentification6,
#[yaserde(rename = "IntrmyAgt1")]
#[cfg_attr(feature = "serde", serde(rename = "IntrmyAgt1"))]
pub intrmy_agt_1: BranchAndFinancialInstitutionIdentification6,
#[yaserde(rename = "IntrmyAgt2")]
#[cfg_attr(feature = "serde", serde(rename = "IntrmyAgt2"))]
pub intrmy_agt_2: BranchAndFinancialInstitutionIdentification6,
#[yaserde(rename = "IntrmyAgt3")]
#[cfg_attr(feature = "serde", serde(rename = "IntrmyAgt3"))]
pub intrmy_agt_3: BranchAndFinancialInstitutionIdentification6,
#[yaserde(rename = "RcvgAgt")]
#[cfg_attr(feature = "serde", serde(rename = "RcvgAgt"))]
pub rcvg_agt: BranchAndFinancialInstitutionIdentification6,
#[yaserde(rename = "DlvrgAgt")]
#[cfg_attr(feature = "serde", serde(rename = "DlvrgAgt"))]
pub dlvrg_agt: BranchAndFinancialInstitutionIdentification6,
#[yaserde(rename = "IssgAgt")]
#[cfg_attr(feature = "serde", serde(rename = "IssgAgt"))]
pub issg_agt: BranchAndFinancialInstitutionIdentification6,
#[yaserde(rename = "SttlmPlc")]
#[cfg_attr(feature = "serde", serde(rename = "SttlmPlc"))]
pub sttlm_plc: BranchAndFinancialInstitutionIdentification6,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Vec<ProprietaryAgent4>,
}
impl Validate for TransactionAgents5 {}
#[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:camt.052.001.09")]
pub enum TransactionChannel1Code {
#[yaserde(rename = "MAIL")]
#[cfg_attr(feature = "serde", serde(rename = "MAIL"))]
Mail,
#[yaserde(rename = "TLPH")]
#[cfg_attr(feature = "serde", serde(rename = "TLPH"))]
Tlph,
#[yaserde(rename = "ECOM")]
#[cfg_attr(feature = "serde", serde(rename = "ECOM"))]
Ecom,
#[yaserde(rename = "TVPY")]
#[cfg_attr(feature = "serde", serde(rename = "TVPY"))]
Tvpy,
__Unknown__(String),
}
impl Default for TransactionChannel1Code {
fn default() -> TransactionChannel1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for TransactionChannel1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct TransactionDates3 {
#[yaserde(rename = "AccptncDtTm")]
#[cfg_attr(feature = "serde", serde(rename = "AccptncDtTm"))]
pub accptnc_dt_tm: IsodateTime,
#[yaserde(rename = "TradActvtyCtrctlSttlmDt")]
#[cfg_attr(feature = "serde", serde(rename = "TradActvtyCtrctlSttlmDt"))]
pub trad_actvty_ctrctl_sttlm_dt: Isodate,
#[yaserde(rename = "TradDt")]
#[cfg_attr(feature = "serde", serde(rename = "TradDt"))]
pub trad_dt: Isodate,
#[yaserde(rename = "IntrBkSttlmDt")]
#[cfg_attr(feature = "serde", serde(rename = "IntrBkSttlmDt"))]
pub intr_bk_sttlm_dt: Isodate,
#[yaserde(rename = "StartDt")]
#[cfg_attr(feature = "serde", serde(rename = "StartDt"))]
pub start_dt: Isodate,
#[yaserde(rename = "EndDt")]
#[cfg_attr(feature = "serde", serde(rename = "EndDt"))]
pub end_dt: Isodate,
#[yaserde(rename = "TxDtTm")]
#[cfg_attr(feature = "serde", serde(rename = "TxDtTm"))]
pub tx_dt_tm: IsodateTime,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Vec<ProprietaryDate3>,
}
impl Validate for TransactionDates3 {}
#[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:camt.052.001.09")]
pub enum TransactionEnvironment1Code {
#[yaserde(rename = "MERC")]
#[cfg_attr(feature = "serde", serde(rename = "MERC"))]
Merc,
#[yaserde(rename = "PRIV")]
#[cfg_attr(feature = "serde", serde(rename = "PRIV"))]
Priv,
#[yaserde(rename = "PUBL")]
#[cfg_attr(feature = "serde", serde(rename = "PUBL"))]
Publ,
__Unknown__(String),
}
impl Default for TransactionEnvironment1Code {
fn default() -> TransactionEnvironment1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for TransactionEnvironment1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct TransactionIdentifier1 {
#[yaserde(rename = "TxDtTm")]
#[cfg_attr(feature = "serde", serde(rename = "TxDtTm"))]
pub tx_dt_tm: IsodateTime,
#[yaserde(rename = "TxRef")]
#[cfg_attr(feature = "serde", serde(rename = "TxRef"))]
pub tx_ref: Max35Text,
}
impl Validate for TransactionIdentifier1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct TransactionInterest4 {
#[yaserde(rename = "TtlIntrstAndTaxAmt")]
#[cfg_attr(feature = "serde", serde(rename = "TtlIntrstAndTaxAmt"))]
pub ttl_intrst_and_tax_amt: ActiveOrHistoricCurrencyAndAmount,
#[yaserde(rename = "Rcrd")]
#[cfg_attr(feature = "serde", serde(rename = "Rcrd"))]
pub rcrd: Vec<InterestRecord2>,
}
impl Validate for TransactionInterest4 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct TransactionParties9 {
#[yaserde(rename = "InitgPty")]
#[cfg_attr(feature = "serde", serde(rename = "InitgPty"))]
pub initg_pty: Party40Choice,
#[yaserde(rename = "Dbtr")]
#[cfg_attr(feature = "serde", serde(rename = "Dbtr"))]
pub dbtr: Party40Choice,
#[yaserde(rename = "DbtrAcct")]
#[cfg_attr(feature = "serde", serde(rename = "DbtrAcct"))]
pub dbtr_acct: CashAccount40,
#[yaserde(rename = "UltmtDbtr")]
#[cfg_attr(feature = "serde", serde(rename = "UltmtDbtr"))]
pub ultmt_dbtr: Party40Choice,
#[yaserde(rename = "Cdtr")]
#[cfg_attr(feature = "serde", serde(rename = "Cdtr"))]
pub cdtr: Party40Choice,
#[yaserde(rename = "CdtrAcct")]
#[cfg_attr(feature = "serde", serde(rename = "CdtrAcct"))]
pub cdtr_acct: CashAccount40,
#[yaserde(rename = "UltmtCdtr")]
#[cfg_attr(feature = "serde", serde(rename = "UltmtCdtr"))]
pub ultmt_cdtr: Party40Choice,
#[yaserde(rename = "TradgPty")]
#[cfg_attr(feature = "serde", serde(rename = "TradgPty"))]
pub tradg_pty: Party40Choice,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Vec<ProprietaryParty5>,
}
impl Validate for TransactionParties9 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct TransactionPrice4Choice {
#[yaserde(rename = "DealPric")]
#[cfg_attr(feature = "serde", serde(rename = "DealPric"))]
pub deal_pric: Option<Price7>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Vec<ProprietaryPrice2>,
}
impl Validate for TransactionPrice4Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct TransactionQuantities3Choice {
#[yaserde(rename = "Qty")]
#[cfg_attr(feature = "serde", serde(rename = "Qty"))]
pub qty: Option<FinancialInstrumentQuantity1Choice>,
#[yaserde(rename = "OrgnlAndCurFaceAmt")]
#[cfg_attr(feature = "serde", serde(rename = "OrgnlAndCurFaceAmt"))]
pub orgnl_and_cur_face_amt: Option<OriginalAndCurrentQuantities1>,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Option<ProprietaryQuantity1>,
}
impl Validate for TransactionQuantities3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct TransactionReferences6 {
#[yaserde(rename = "MsgId")]
#[cfg_attr(feature = "serde", serde(rename = "MsgId"))]
pub msg_id: Max35Text,
#[yaserde(rename = "AcctSvcrRef")]
#[cfg_attr(feature = "serde", serde(rename = "AcctSvcrRef"))]
pub acct_svcr_ref: Max35Text,
#[yaserde(rename = "PmtInfId")]
#[cfg_attr(feature = "serde", serde(rename = "PmtInfId"))]
pub pmt_inf_id: Max35Text,
#[yaserde(rename = "InstrId")]
#[cfg_attr(feature = "serde", serde(rename = "InstrId"))]
pub instr_id: Max35Text,
#[yaserde(rename = "EndToEndId")]
#[cfg_attr(feature = "serde", serde(rename = "EndToEndId"))]
pub end_to_end_id: Max35Text,
#[yaserde(rename = "UETR")]
#[cfg_attr(feature = "serde", serde(rename = "UETR"))]
pub uetr: Uuidv4Identifier,
#[yaserde(rename = "TxId")]
#[cfg_attr(feature = "serde", serde(rename = "TxId"))]
pub tx_id: Max35Text,
#[yaserde(rename = "MndtId")]
#[cfg_attr(feature = "serde", serde(rename = "MndtId"))]
pub mndt_id: Max35Text,
#[yaserde(rename = "ChqNb")]
#[cfg_attr(feature = "serde", serde(rename = "ChqNb"))]
pub chq_nb: Max35Text,
#[yaserde(rename = "ClrSysRef")]
#[cfg_attr(feature = "serde", serde(rename = "ClrSysRef"))]
pub clr_sys_ref: Max35Text,
#[yaserde(rename = "AcctOwnrTxId")]
#[cfg_attr(feature = "serde", serde(rename = "AcctOwnrTxId"))]
pub acct_ownr_tx_id: Max35Text,
#[yaserde(rename = "AcctSvcrTxId")]
#[cfg_attr(feature = "serde", serde(rename = "AcctSvcrTxId"))]
pub acct_svcr_tx_id: Max35Text,
#[yaserde(rename = "MktInfrstrctrTxId")]
#[cfg_attr(feature = "serde", serde(rename = "MktInfrstrctrTxId"))]
pub mkt_infrstrctr_tx_id: Max35Text,
#[yaserde(rename = "PrcgId")]
#[cfg_attr(feature = "serde", serde(rename = "PrcgId"))]
pub prcg_id: Max35Text,
#[yaserde(rename = "Prtry")]
#[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
pub prtry: Vec<ProprietaryReference1>,
}
impl Validate for TransactionReferences6 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct TrueFalseIndicator (pub bool);
crate::simple_type!(TrueFalseIndicator);
impl Validate for TrueFalseIndicator {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Uuidv4Identifier (pub String);
crate::simple_type!(Uuidv4Identifier);
impl Validate for Uuidv4Identifier {}
#[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:camt.052.001.09")]
pub enum UnitOfMeasure1Code {
#[yaserde(rename = "PIEC")]
#[cfg_attr(feature = "serde", serde(rename = "PIEC"))]
Piec,
#[yaserde(rename = "TONS")]
#[cfg_attr(feature = "serde", serde(rename = "TONS"))]
Tons,
#[yaserde(rename = "FOOT")]
#[cfg_attr(feature = "serde", serde(rename = "FOOT"))]
Foot,
#[yaserde(rename = "GBGA")]
#[cfg_attr(feature = "serde", serde(rename = "GBGA"))]
Gbga,
#[yaserde(rename = "USGA")]
#[cfg_attr(feature = "serde", serde(rename = "USGA"))]
Usga,
#[yaserde(rename = "GRAM")]
#[cfg_attr(feature = "serde", serde(rename = "GRAM"))]
Gram,
#[yaserde(rename = "INCH")]
#[cfg_attr(feature = "serde", serde(rename = "INCH"))]
Inch,
#[yaserde(rename = "KILO")]
#[cfg_attr(feature = "serde", serde(rename = "KILO"))]
Kilo,
#[yaserde(rename = "PUND")]
#[cfg_attr(feature = "serde", serde(rename = "PUND"))]
Pund,
#[yaserde(rename = "METR")]
#[cfg_attr(feature = "serde", serde(rename = "METR"))]
Metr,
#[yaserde(rename = "CMET")]
#[cfg_attr(feature = "serde", serde(rename = "CMET"))]
Cmet,
#[yaserde(rename = "MMET")]
#[cfg_attr(feature = "serde", serde(rename = "MMET"))]
Mmet,
#[yaserde(rename = "LITR")]
#[cfg_attr(feature = "serde", serde(rename = "LITR"))]
Litr,
#[yaserde(rename = "CELI")]
#[cfg_attr(feature = "serde", serde(rename = "CELI"))]
Celi,
#[yaserde(rename = "MILI")]
#[cfg_attr(feature = "serde", serde(rename = "MILI"))]
Mili,
#[yaserde(rename = "GBOU")]
#[cfg_attr(feature = "serde", serde(rename = "GBOU"))]
Gbou,
#[yaserde(rename = "USOU")]
#[cfg_attr(feature = "serde", serde(rename = "USOU"))]
Usou,
#[yaserde(rename = "GBQA")]
#[cfg_attr(feature = "serde", serde(rename = "GBQA"))]
Gbqa,
#[yaserde(rename = "USQA")]
#[cfg_attr(feature = "serde", serde(rename = "USQA"))]
Usqa,
#[yaserde(rename = "GBPI")]
#[cfg_attr(feature = "serde", serde(rename = "GBPI"))]
Gbpi,
#[yaserde(rename = "USPI")]
#[cfg_attr(feature = "serde", serde(rename = "USPI"))]
Uspi,
#[yaserde(rename = "MILE")]
#[cfg_attr(feature = "serde", serde(rename = "MILE"))]
Mile,
#[yaserde(rename = "KMET")]
#[cfg_attr(feature = "serde", serde(rename = "KMET"))]
Kmet,
#[yaserde(rename = "YARD")]
#[cfg_attr(feature = "serde", serde(rename = "YARD"))]
Yard,
#[yaserde(rename = "SQKI")]
#[cfg_attr(feature = "serde", serde(rename = "SQKI"))]
Sqki,
#[yaserde(rename = "HECT")]
#[cfg_attr(feature = "serde", serde(rename = "HECT"))]
Hect,
#[yaserde(rename = "ARES")]
#[cfg_attr(feature = "serde", serde(rename = "ARES"))]
Ares,
#[yaserde(rename = "SMET")]
#[cfg_attr(feature = "serde", serde(rename = "SMET"))]
Smet,
#[yaserde(rename = "SCMT")]
#[cfg_attr(feature = "serde", serde(rename = "SCMT"))]
Scmt,
#[yaserde(rename = "SMIL")]
#[cfg_attr(feature = "serde", serde(rename = "SMIL"))]
Smil,
#[yaserde(rename = "SQMI")]
#[cfg_attr(feature = "serde", serde(rename = "SQMI"))]
Sqmi,
#[yaserde(rename = "SQYA")]
#[cfg_attr(feature = "serde", serde(rename = "SQYA"))]
Sqya,
#[yaserde(rename = "SQFO")]
#[cfg_attr(feature = "serde", serde(rename = "SQFO"))]
Sqfo,
#[yaserde(rename = "SQIN")]
#[cfg_attr(feature = "serde", serde(rename = "SQIN"))]
Sqin,
#[yaserde(rename = "ACRE")]
#[cfg_attr(feature = "serde", serde(rename = "ACRE"))]
Acre,
__Unknown__(String),
}
impl Default for UnitOfMeasure1Code {
fn default() -> UnitOfMeasure1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for UnitOfMeasure1Code {}
#[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:camt.052.001.09")]
pub enum UserInterface2Code {
#[yaserde(rename = "MDSP")]
#[cfg_attr(feature = "serde", serde(rename = "MDSP"))]
Mdsp,
#[yaserde(rename = "CDSP")]
#[cfg_attr(feature = "serde", serde(rename = "CDSP"))]
Cdsp,
__Unknown__(String),
}
impl Default for UserInterface2Code {
fn default() -> UserInterface2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for UserInterface2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct YesNoIndicator (pub bool);
crate::simple_type!(YesNoIndicator);
impl Validate for YesNoIndicator {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.052.001.09")]
pub struct YieldedOrValueType1Choice {
#[yaserde(rename = "Yldd")]
#[cfg_attr(feature = "serde", serde(rename = "Yldd"))]
pub yldd: Option<YesNoIndicator>,
#[yaserde(rename = "ValTp")]
#[cfg_attr(feature = "serde", serde(rename = "ValTp"))]
pub val_tp: Option<PriceValueType1Code>,
}
impl Validate for YieldedOrValueType1Choice {}
impl crate::MxMessage for Document {
const BUSINESS_AREA: crate::BusinessArea = crate::BusinessArea::camt;
const FUNCTIONALITY: &'static str = "052";
const VARIANT: &'static str = "001";
const VERSION: &'static str = "09";
const MESSAGE_NAME: &'static str = "camt.052.001.09";
const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:camt.052.001.09";
}