#![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:caaa.009.001.14")]
pub struct AcceptorReconciliationRequest14 {
#[yaserde(rename = "Envt")]
#[cfg_attr(feature = "serde", serde(rename = "Envt"))]
pub envt: CardPaymentEnvironment82,
#[yaserde(rename = "Tx")]
#[cfg_attr(feature = "serde", serde(rename = "Tx"))]
pub tx: TransactionReconciliation5,
}
impl Validate for AcceptorReconciliationRequest14 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct AcceptorReconciliationRequestV14 {
#[yaserde(rename = "Hdr")]
#[cfg_attr(feature = "serde", serde(rename = "Hdr"))]
pub hdr: Header70,
#[yaserde(rename = "RcncltnReq")]
#[cfg_attr(feature = "serde", serde(rename = "RcncltnReq"))]
pub rcncltn_req: AcceptorReconciliationRequest14,
#[yaserde(rename = "SctyTrlr")]
#[cfg_attr(feature = "serde", serde(rename = "SctyTrlr"))]
pub scty_trlr: ContentInformationType37,
}
impl Validate for AcceptorReconciliationRequestV14 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct Acquirer10 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: GenericIdentification177,
#[yaserde(rename = "ParamsVrsn")]
#[cfg_attr(feature = "serde", serde(rename = "ParamsVrsn"))]
pub params_vrsn: Max256Text,
}
impl Validate for Acquirer10 {}
#[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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
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:caaa.009.001.14")]
pub struct AddressVerification1 {
#[yaserde(rename = "AdrDgts")]
#[cfg_attr(feature = "serde", serde(rename = "AdrDgts"))]
pub adr_dgts: Max5NumericText,
#[yaserde(rename = "PstlCdDgts")]
#[cfg_attr(feature = "serde", serde(rename = "PstlCdDgts"))]
pub pstl_cd_dgts: Max5NumericText,
}
impl Validate for AddressVerification1 {}
#[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:caaa.009.001.14")]
pub enum Algorithm26Code {
#[yaserde(rename = "HS25")]
#[cfg_attr(feature = "serde", serde(rename = "HS25"))]
Hs25,
#[yaserde(rename = "HS38")]
#[cfg_attr(feature = "serde", serde(rename = "HS38"))]
Hs38,
#[yaserde(rename = "HS51")]
#[cfg_attr(feature = "serde", serde(rename = "HS51"))]
Hs51,
#[yaserde(rename = "HS01")]
#[cfg_attr(feature = "serde", serde(rename = "HS01"))]
Hs01,
#[yaserde(rename = "SH31")]
#[cfg_attr(feature = "serde", serde(rename = "SH31"))]
Sh31,
#[yaserde(rename = "SH32")]
#[cfg_attr(feature = "serde", serde(rename = "SH32"))]
Sh32,
#[yaserde(rename = "SH33")]
#[cfg_attr(feature = "serde", serde(rename = "SH33"))]
Sh33,
#[yaserde(rename = "SH35")]
#[cfg_attr(feature = "serde", serde(rename = "SH35"))]
Sh35,
#[yaserde(rename = "SHK1")]
#[cfg_attr(feature = "serde", serde(rename = "SHK1"))]
Shk1,
#[yaserde(rename = "SHK2")]
#[cfg_attr(feature = "serde", serde(rename = "SHK2"))]
Shk2,
#[yaserde(rename = "SMS3")]
#[cfg_attr(feature = "serde", serde(rename = "SMS3"))]
Sms3,
__Unknown__(String),
}
impl Default for Algorithm26Code {
fn default() -> Algorithm26Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for Algorithm26Code {}
#[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:caaa.009.001.14")]
pub enum Algorithm27Code {
#[yaserde(rename = "MACC")]
#[cfg_attr(feature = "serde", serde(rename = "MACC"))]
Macc,
#[yaserde(rename = "MCCS")]
#[cfg_attr(feature = "serde", serde(rename = "MCCS"))]
Mccs,
#[yaserde(rename = "CMA1")]
#[cfg_attr(feature = "serde", serde(rename = "CMA1"))]
Cma1,
#[yaserde(rename = "MCC1")]
#[cfg_attr(feature = "serde", serde(rename = "MCC1"))]
Mcc1,
#[yaserde(rename = "CMA9")]
#[cfg_attr(feature = "serde", serde(rename = "CMA9"))]
Cma9,
#[yaserde(rename = "CMA5")]
#[cfg_attr(feature = "serde", serde(rename = "CMA5"))]
Cma5,
#[yaserde(rename = "CMA2")]
#[cfg_attr(feature = "serde", serde(rename = "CMA2"))]
Cma2,
#[yaserde(rename = "CM31")]
#[cfg_attr(feature = "serde", serde(rename = "CM31"))]
Cm31,
#[yaserde(rename = "CM32")]
#[cfg_attr(feature = "serde", serde(rename = "CM32"))]
Cm32,
#[yaserde(rename = "CM33")]
#[cfg_attr(feature = "serde", serde(rename = "CM33"))]
Cm33,
#[yaserde(rename = "MCS3")]
#[cfg_attr(feature = "serde", serde(rename = "MCS3"))]
Mcs3,
#[yaserde(rename = "CCA1")]
#[cfg_attr(feature = "serde", serde(rename = "CCA1"))]
Cca1,
#[yaserde(rename = "CCA2")]
#[cfg_attr(feature = "serde", serde(rename = "CCA2"))]
Cca2,
#[yaserde(rename = "CCA3")]
#[cfg_attr(feature = "serde", serde(rename = "CCA3"))]
Cca3,
S34C,
S34R,
__Unknown__(String),
}
impl Default for Algorithm27Code {
fn default() -> Algorithm27Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for Algorithm27Code {}
#[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:caaa.009.001.14")]
pub enum Algorithm28Code {
#[yaserde(rename = "EA2C")]
#[cfg_attr(feature = "serde", serde(rename = "EA2C"))]
Ea2C,
#[yaserde(rename = "E3DC")]
#[cfg_attr(feature = "serde", serde(rename = "E3DC"))]
E3Dc,
#[yaserde(rename = "DKP9")]
#[cfg_attr(feature = "serde", serde(rename = "DKP9"))]
Dkp9,
#[yaserde(rename = "UKPT")]
#[cfg_attr(feature = "serde", serde(rename = "UKPT"))]
Ukpt,
#[yaserde(rename = "UKA2")]
#[cfg_attr(feature = "serde", serde(rename = "UKA2"))]
Uka2,
#[yaserde(rename = "EA9C")]
#[cfg_attr(feature = "serde", serde(rename = "EA9C"))]
Ea9C,
#[yaserde(rename = "EA5C")]
#[cfg_attr(feature = "serde", serde(rename = "EA5C"))]
Ea5C,
#[yaserde(rename = "DA12")]
#[cfg_attr(feature = "serde", serde(rename = "DA12"))]
Da12,
#[yaserde(rename = "DA19")]
#[cfg_attr(feature = "serde", serde(rename = "DA19"))]
Da19,
#[yaserde(rename = "DA25")]
#[cfg_attr(feature = "serde", serde(rename = "DA25"))]
Da25,
N108,
#[yaserde(rename = "EA5R")]
#[cfg_attr(feature = "serde", serde(rename = "EA5R"))]
Ea5R,
#[yaserde(rename = "EA9R")]
#[cfg_attr(feature = "serde", serde(rename = "EA9R"))]
Ea9R,
#[yaserde(rename = "EA2R")]
#[cfg_attr(feature = "serde", serde(rename = "EA2R"))]
Ea2R,
#[yaserde(rename = "E3DR")]
#[cfg_attr(feature = "serde", serde(rename = "E3DR"))]
E3Dr,
E36C,
E36R,
#[yaserde(rename = "SD5C")]
#[cfg_attr(feature = "serde", serde(rename = "SD5C"))]
Sd5C,
#[yaserde(rename = "UKA1")]
#[cfg_attr(feature = "serde", serde(rename = "UKA1"))]
Uka1,
#[yaserde(rename = "UKA3")]
#[cfg_attr(feature = "serde", serde(rename = "UKA3"))]
Uka3,
#[yaserde(rename = "SM4C")]
#[cfg_attr(feature = "serde", serde(rename = "SM4C"))]
Sm4C,
#[yaserde(rename = "SM4R")]
#[cfg_attr(feature = "serde", serde(rename = "SM4R"))]
Sm4R,
__Unknown__(String),
}
impl Default for Algorithm28Code {
fn default() -> Algorithm28Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for Algorithm28Code {}
#[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:caaa.009.001.14")]
pub enum Algorithm29Code {
#[yaserde(rename = "ERS2")]
#[cfg_attr(feature = "serde", serde(rename = "ERS2"))]
Ers2,
#[yaserde(rename = "ERS1")]
#[cfg_attr(feature = "serde", serde(rename = "ERS1"))]
Ers1,
#[yaserde(rename = "RPSS")]
#[cfg_attr(feature = "serde", serde(rename = "RPSS"))]
Rpss,
#[yaserde(rename = "ERS3")]
#[cfg_attr(feature = "serde", serde(rename = "ERS3"))]
Ers3,
#[yaserde(rename = "ED32")]
#[cfg_attr(feature = "serde", serde(rename = "ED32"))]
Ed32,
#[yaserde(rename = "ED33")]
#[cfg_attr(feature = "serde", serde(rename = "ED33"))]
Ed33,
#[yaserde(rename = "ED35")]
#[cfg_attr(feature = "serde", serde(rename = "ED35"))]
Ed35,
#[yaserde(rename = "ED23")]
#[cfg_attr(feature = "serde", serde(rename = "ED23"))]
Ed23,
#[yaserde(rename = "ED25")]
#[cfg_attr(feature = "serde", serde(rename = "ED25"))]
Ed25,
#[yaserde(rename = "ES22")]
#[cfg_attr(feature = "serde", serde(rename = "ES22"))]
Es22,
#[yaserde(rename = "ES32")]
#[cfg_attr(feature = "serde", serde(rename = "ES32"))]
Es32,
#[yaserde(rename = "ES33")]
#[cfg_attr(feature = "serde", serde(rename = "ES33"))]
Es33,
#[yaserde(rename = "ES35")]
#[cfg_attr(feature = "serde", serde(rename = "ES35"))]
Es35,
#[yaserde(rename = "ES23")]
#[cfg_attr(feature = "serde", serde(rename = "ES23"))]
Es23,
#[yaserde(rename = "ES25")]
#[cfg_attr(feature = "serde", serde(rename = "ES25"))]
Es25,
#[yaserde(rename = "ED22")]
#[cfg_attr(feature = "serde", serde(rename = "ED22"))]
Ed22,
#[yaserde(rename = "EF32")]
#[cfg_attr(feature = "serde", serde(rename = "EF32"))]
Ef32,
#[yaserde(rename = "EF22")]
#[cfg_attr(feature = "serde", serde(rename = "EF22"))]
Ef22,
#[yaserde(rename = "EF33")]
#[cfg_attr(feature = "serde", serde(rename = "EF33"))]
Ef33,
#[yaserde(rename = "EF35")]
#[cfg_attr(feature = "serde", serde(rename = "EF35"))]
Ef35,
#[yaserde(rename = "EF23")]
#[cfg_attr(feature = "serde", serde(rename = "EF23"))]
Ef23,
#[yaserde(rename = "EO33")]
#[cfg_attr(feature = "serde", serde(rename = "EO33"))]
Eo33,
#[yaserde(rename = "EF25")]
#[cfg_attr(feature = "serde", serde(rename = "EF25"))]
Ef25,
#[yaserde(rename = "EO32")]
#[cfg_attr(feature = "serde", serde(rename = "EO32"))]
Eo32,
#[yaserde(rename = "EO22")]
#[cfg_attr(feature = "serde", serde(rename = "EO22"))]
Eo22,
#[yaserde(rename = "EO35")]
#[cfg_attr(feature = "serde", serde(rename = "EO35"))]
Eo35,
#[yaserde(rename = "EO23")]
#[cfg_attr(feature = "serde", serde(rename = "EO23"))]
Eo23,
#[yaserde(rename = "EO25")]
#[cfg_attr(feature = "serde", serde(rename = "EO25"))]
Eo25,
#[yaserde(rename = "DD22")]
#[cfg_attr(feature = "serde", serde(rename = "DD22"))]
Dd22,
#[yaserde(rename = "DD32")]
#[cfg_attr(feature = "serde", serde(rename = "DD32"))]
Dd32,
#[yaserde(rename = "DD33")]
#[cfg_attr(feature = "serde", serde(rename = "DD33"))]
Dd33,
#[yaserde(rename = "DD35")]
#[cfg_attr(feature = "serde", serde(rename = "DD35"))]
Dd35,
#[yaserde(rename = "DD23")]
#[cfg_attr(feature = "serde", serde(rename = "DD23"))]
Dd23,
#[yaserde(rename = "DD25")]
#[cfg_attr(feature = "serde", serde(rename = "DD25"))]
Dd25,
#[yaserde(rename = "SM22")]
#[cfg_attr(feature = "serde", serde(rename = "SM22"))]
Sm22,
#[yaserde(rename = "SM33")]
#[cfg_attr(feature = "serde", serde(rename = "SM33"))]
Sm33,
#[yaserde(rename = "SM32")]
#[cfg_attr(feature = "serde", serde(rename = "SM32"))]
Sm32,
#[yaserde(rename = "SM35")]
#[cfg_attr(feature = "serde", serde(rename = "SM35"))]
Sm35,
#[yaserde(rename = "SM23")]
#[cfg_attr(feature = "serde", serde(rename = "SM23"))]
Sm23,
#[yaserde(rename = "SM25")]
#[cfg_attr(feature = "serde", serde(rename = "SM25"))]
Sm25,
S2S3,
__Unknown__(String),
}
impl Default for Algorithm29Code {
fn default() -> Algorithm29Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for Algorithm29Code {}
#[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:caaa.009.001.14")]
pub enum Algorithm7Code {
#[yaserde(rename = "ERSA")]
#[cfg_attr(feature = "serde", serde(rename = "ERSA"))]
Ersa,
#[yaserde(rename = "RSAO")]
#[cfg_attr(feature = "serde", serde(rename = "RSAO"))]
Rsao,
__Unknown__(String),
}
impl Default for Algorithm7Code {
fn default() -> Algorithm7Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for Algorithm7Code {}
#[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:caaa.009.001.14")]
pub enum Algorithm8Code {
#[yaserde(rename = "MGF1")]
#[cfg_attr(feature = "serde", serde(rename = "MGF1"))]
Mgf1,
__Unknown__(String),
}
impl Default for Algorithm8Code {
fn default() -> Algorithm8Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for Algorithm8Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct AlgorithmIdentification31 {
#[yaserde(rename = "Algo")]
#[cfg_attr(feature = "serde", serde(rename = "Algo"))]
pub algo: Algorithm27Code,
#[yaserde(rename = "Param")]
#[cfg_attr(feature = "serde", serde(rename = "Param"))]
pub param: Parameter7,
}
impl Validate for AlgorithmIdentification31 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct AlgorithmIdentification32 {
#[yaserde(rename = "Algo")]
#[cfg_attr(feature = "serde", serde(rename = "Algo"))]
pub algo: Algorithm28Code,
#[yaserde(rename = "Param")]
#[cfg_attr(feature = "serde", serde(rename = "Param"))]
pub param: Parameter12,
}
impl Validate for AlgorithmIdentification32 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct AlgorithmIdentification33 {
#[yaserde(rename = "Algo")]
#[cfg_attr(feature = "serde", serde(rename = "Algo"))]
pub algo: Algorithm29Code,
#[yaserde(rename = "Param")]
#[cfg_attr(feature = "serde", serde(rename = "Param"))]
pub param: Parameter16,
}
impl Validate for AlgorithmIdentification33 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct AlgorithmIdentification34 {
#[yaserde(rename = "Algo")]
#[cfg_attr(feature = "serde", serde(rename = "Algo"))]
pub algo: Algorithm8Code,
#[yaserde(rename = "Param")]
#[cfg_attr(feature = "serde", serde(rename = "Param"))]
pub param: Parameter18,
}
impl Validate for AlgorithmIdentification34 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct AlgorithmIdentification35 {
#[yaserde(rename = "Algo")]
#[cfg_attr(feature = "serde", serde(rename = "Algo"))]
pub algo: Algorithm7Code,
#[yaserde(rename = "Param")]
#[cfg_attr(feature = "serde", serde(rename = "Param"))]
pub param: Parameter17,
}
impl Validate for AlgorithmIdentification35 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct AlgorithmIdentification36 {
#[yaserde(rename = "Algo")]
#[cfg_attr(feature = "serde", serde(rename = "Algo"))]
pub algo: Algorithm26Code,
}
impl Validate for AlgorithmIdentification36 {}
#[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:caaa.009.001.14")]
pub enum AmountUnit1Code {
#[yaserde(rename = "MONE")]
#[cfg_attr(feature = "serde", serde(rename = "MONE"))]
Mone,
#[yaserde(rename = "POIN")]
#[cfg_attr(feature = "serde", serde(rename = "POIN"))]
Poin,
__Unknown__(String),
}
impl Default for AmountUnit1Code {
fn default() -> AmountUnit1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AmountUnit1Code {}
#[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:caaa.009.001.14")]
pub enum AttributeType1Code {
#[yaserde(rename = "CNAT")]
#[cfg_attr(feature = "serde", serde(rename = "CNAT"))]
Cnat,
#[yaserde(rename = "LATT")]
#[cfg_attr(feature = "serde", serde(rename = "LATT"))]
Latt,
#[yaserde(rename = "OATT")]
#[cfg_attr(feature = "serde", serde(rename = "OATT"))]
Oatt,
#[yaserde(rename = "OUAT")]
#[cfg_attr(feature = "serde", serde(rename = "OUAT"))]
Ouat,
#[yaserde(rename = "CATT")]
#[cfg_attr(feature = "serde", serde(rename = "CATT"))]
Catt,
__Unknown__(String),
}
impl Default for AttributeType1Code {
fn default() -> AttributeType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AttributeType1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct AuthenticatedData10 {
#[yaserde(rename = "Vrsn")]
#[cfg_attr(feature = "serde", serde(rename = "Vrsn"))]
pub vrsn: Number,
#[yaserde(rename = "Rcpt")]
#[cfg_attr(feature = "serde", serde(rename = "Rcpt"))]
pub rcpt: Vec<Recipient15Choice>,
#[yaserde(rename = "MACAlgo")]
#[cfg_attr(feature = "serde", serde(rename = "MACAlgo"))]
pub mac_algo: AlgorithmIdentification31,
#[yaserde(rename = "NcpsltdCntt")]
#[cfg_attr(feature = "serde", serde(rename = "NcpsltdCntt"))]
pub ncpsltd_cntt: EncapsulatedContent3,
#[yaserde(rename = "MAC")]
#[cfg_attr(feature = "serde", serde(rename = "MAC"))]
pub mac: Max140Binary,
}
impl Validate for AuthenticatedData10 {}
#[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:caaa.009.001.14")]
pub enum AuthenticationEntity2Code {
#[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,
#[yaserde(rename = "ACQR")]
#[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
Acqr,
#[yaserde(rename = "ISSR")]
#[cfg_attr(feature = "serde", serde(rename = "ISSR"))]
Issr,
#[yaserde(rename = "TRML")]
#[cfg_attr(feature = "serde", serde(rename = "TRML"))]
Trml,
__Unknown__(String),
}
impl Default for AuthenticationEntity2Code {
fn default() -> AuthenticationEntity2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AuthenticationEntity2Code {}
#[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:caaa.009.001.14")]
pub enum AuthenticationMethod6Code {
#[yaserde(rename = "NPIN")]
#[cfg_attr(feature = "serde", serde(rename = "NPIN"))]
Npin,
#[yaserde(rename = "PPSG")]
#[cfg_attr(feature = "serde", serde(rename = "PPSG"))]
Ppsg,
#[yaserde(rename = "PSWD")]
#[cfg_attr(feature = "serde", serde(rename = "PSWD"))]
Pswd,
#[yaserde(rename = "SCRT")]
#[cfg_attr(feature = "serde", serde(rename = "SCRT"))]
Scrt,
#[yaserde(rename = "SCNL")]
#[cfg_attr(feature = "serde", serde(rename = "SCNL"))]
Scnl,
#[yaserde(rename = "SNCT")]
#[cfg_attr(feature = "serde", serde(rename = "SNCT"))]
Snct,
#[yaserde(rename = "CPSG")]
#[cfg_attr(feature = "serde", serde(rename = "CPSG"))]
Cpsg,
#[yaserde(rename = "ADDB")]
#[cfg_attr(feature = "serde", serde(rename = "ADDB"))]
Addb,
#[yaserde(rename = "BIOM")]
#[cfg_attr(feature = "serde", serde(rename = "BIOM"))]
Biom,
#[yaserde(rename = "CDHI")]
#[cfg_attr(feature = "serde", serde(rename = "CDHI"))]
Cdhi,
#[yaserde(rename = "CRYP")]
#[cfg_attr(feature = "serde", serde(rename = "CRYP"))]
Cryp,
#[yaserde(rename = "CSCV")]
#[cfg_attr(feature = "serde", serde(rename = "CSCV"))]
Cscv,
#[yaserde(rename = "PSVE")]
#[cfg_attr(feature = "serde", serde(rename = "PSVE"))]
Psve,
#[yaserde(rename = "CSEC")]
#[cfg_attr(feature = "serde", serde(rename = "CSEC"))]
Csec,
#[yaserde(rename = "ADDS")]
#[cfg_attr(feature = "serde", serde(rename = "ADDS"))]
Adds,
#[yaserde(rename = "MANU")]
#[cfg_attr(feature = "serde", serde(rename = "MANU"))]
Manu,
#[yaserde(rename = "FPIN")]
#[cfg_attr(feature = "serde", serde(rename = "FPIN"))]
Fpin,
#[yaserde(rename = "TOKP")]
#[cfg_attr(feature = "serde", serde(rename = "TOKP"))]
Tokp,
__Unknown__(String),
}
impl Default for AuthenticationMethod6Code {
fn default() -> AuthenticationMethod6Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AuthenticationMethod6Code {}
#[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:caaa.009.001.14")]
pub enum AuthenticationMethod8Code {
#[yaserde(rename = "TOKA")]
#[cfg_attr(feature = "serde", serde(rename = "TOKA"))]
Toka,
#[yaserde(rename = "ADDB")]
#[cfg_attr(feature = "serde", serde(rename = "ADDB"))]
Addb,
#[yaserde(rename = "BYPS")]
#[cfg_attr(feature = "serde", serde(rename = "BYPS"))]
Byps,
#[yaserde(rename = "BIOM")]
#[cfg_attr(feature = "serde", serde(rename = "BIOM"))]
Biom,
#[yaserde(rename = "CDHI")]
#[cfg_attr(feature = "serde", serde(rename = "CDHI"))]
Cdhi,
#[yaserde(rename = "CRYP")]
#[cfg_attr(feature = "serde", serde(rename = "CRYP"))]
Cryp,
#[yaserde(rename = "CSCV")]
#[cfg_attr(feature = "serde", serde(rename = "CSCV"))]
Cscv,
#[yaserde(rename = "MANU")]
#[cfg_attr(feature = "serde", serde(rename = "MANU"))]
Manu,
#[yaserde(rename = "MERC")]
#[cfg_attr(feature = "serde", serde(rename = "MERC"))]
Merc,
#[yaserde(rename = "MOBL")]
#[cfg_attr(feature = "serde", serde(rename = "MOBL"))]
Mobl,
#[yaserde(rename = "FPIN")]
#[cfg_attr(feature = "serde", serde(rename = "FPIN"))]
Fpin,
#[yaserde(rename = "NPIN")]
#[cfg_attr(feature = "serde", serde(rename = "NPIN"))]
Npin,
#[yaserde(rename = "OTHR")]
#[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
Othr,
#[yaserde(rename = "PPSG")]
#[cfg_attr(feature = "serde", serde(rename = "PPSG"))]
Ppsg,
#[yaserde(rename = "PSVE")]
#[cfg_attr(feature = "serde", serde(rename = "PSVE"))]
Psve,
#[yaserde(rename = "PSWD")]
#[cfg_attr(feature = "serde", serde(rename = "PSWD"))]
Pswd,
#[yaserde(rename = "TOKP")]
#[cfg_attr(feature = "serde", serde(rename = "TOKP"))]
Tokp,
#[yaserde(rename = "SCRT")]
#[cfg_attr(feature = "serde", serde(rename = "SCRT"))]
Scrt,
#[yaserde(rename = "SCNL")]
#[cfg_attr(feature = "serde", serde(rename = "SCNL"))]
Scnl,
#[yaserde(rename = "CSEC")]
#[cfg_attr(feature = "serde", serde(rename = "CSEC"))]
Csec,
#[yaserde(rename = "SNCT")]
#[cfg_attr(feature = "serde", serde(rename = "SNCT"))]
Snct,
#[yaserde(rename = "ADDS")]
#[cfg_attr(feature = "serde", serde(rename = "ADDS"))]
Adds,
#[yaserde(rename = "CPSG")]
#[cfg_attr(feature = "serde", serde(rename = "CPSG"))]
Cpsg,
#[yaserde(rename = "TOKN")]
#[cfg_attr(feature = "serde", serde(rename = "TOKN"))]
Tokn,
#[yaserde(rename = "UKNW")]
#[cfg_attr(feature = "serde", serde(rename = "UKNW"))]
Uknw,
__Unknown__(String),
}
impl Default for AuthenticationMethod8Code {
fn default() -> AuthenticationMethod8Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AuthenticationMethod8Code {}
#[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:caaa.009.001.14")]
pub enum AuthenticationResult1Code {
#[yaserde(rename = "DENY")]
#[cfg_attr(feature = "serde", serde(rename = "DENY"))]
Deny,
#[yaserde(rename = "MRCH")]
#[cfg_attr(feature = "serde", serde(rename = "MRCH"))]
Mrch,
#[yaserde(rename = "CARD")]
#[cfg_attr(feature = "serde", serde(rename = "CARD"))]
Card,
#[yaserde(rename = "AUTH")]
#[cfg_attr(feature = "serde", serde(rename = "AUTH"))]
Auth,
#[yaserde(rename = "CRPT")]
#[cfg_attr(feature = "serde", serde(rename = "CRPT"))]
Crpt,
#[yaserde(rename = "UCRP")]
#[cfg_attr(feature = "serde", serde(rename = "UCRP"))]
Ucrp,
__Unknown__(String),
}
impl Default for AuthenticationResult1Code {
fn default() -> AuthenticationResult1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for AuthenticationResult1Code {}
#[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:caaa.009.001.14")]
pub enum BytePadding1Code {
#[yaserde(rename = "LNGT")]
#[cfg_attr(feature = "serde", serde(rename = "LNGT"))]
Lngt,
#[yaserde(rename = "NUL8")]
#[cfg_attr(feature = "serde", serde(rename = "NUL8"))]
Nul8,
#[yaserde(rename = "NULG")]
#[cfg_attr(feature = "serde", serde(rename = "NULG"))]
Nulg,
#[yaserde(rename = "NULL")]
#[cfg_attr(feature = "serde", serde(rename = "NULL"))]
Null,
#[yaserde(rename = "RAND")]
#[cfg_attr(feature = "serde", serde(rename = "RAND"))]
Rand,
__Unknown__(String),
}
impl Default for BytePadding1Code {
fn default() -> BytePadding1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for BytePadding1Code {}
#[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:caaa.009.001.14")]
pub enum CardDataReading5Code {
#[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,
#[yaserde(rename = "CDFL")]
#[cfg_attr(feature = "serde", serde(rename = "CDFL"))]
Cdfl,
__Unknown__(String),
}
impl Default for CardDataReading5Code {
fn default() -> CardDataReading5Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for CardDataReading5Code {}
#[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:caaa.009.001.14")]
pub enum CardDataReading8Code {
#[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,
#[yaserde(rename = "CDFL")]
#[cfg_attr(feature = "serde", serde(rename = "CDFL"))]
Cdfl,
#[yaserde(rename = "SICC")]
#[cfg_attr(feature = "serde", serde(rename = "SICC"))]
Sicc,
#[yaserde(rename = "UNKW")]
#[cfg_attr(feature = "serde", serde(rename = "UNKW"))]
Unkw,
#[yaserde(rename = "QRCD")]
#[cfg_attr(feature = "serde", serde(rename = "QRCD"))]
Qrcd,
#[yaserde(rename = "OPTC")]
#[cfg_attr(feature = "serde", serde(rename = "OPTC"))]
Optc,
__Unknown__(String),
}
impl Default for CardDataReading8Code {
fn default() -> CardDataReading8Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for CardDataReading8Code {}
#[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:caaa.009.001.14")]
pub enum CardIdentificationType1Code {
#[yaserde(rename = "ACCT")]
#[cfg_attr(feature = "serde", serde(rename = "ACCT"))]
Acct,
#[yaserde(rename = "BARC")]
#[cfg_attr(feature = "serde", serde(rename = "BARC"))]
Barc,
#[yaserde(rename = "ISO2")]
#[cfg_attr(feature = "serde", serde(rename = "ISO2"))]
Iso2,
#[yaserde(rename = "PHON")]
#[cfg_attr(feature = "serde", serde(rename = "PHON"))]
Phon,
#[yaserde(rename = "CPAN")]
#[cfg_attr(feature = "serde", serde(rename = "CPAN"))]
Cpan,
#[yaserde(rename = "PRIV")]
#[cfg_attr(feature = "serde", serde(rename = "PRIV"))]
Priv,
#[yaserde(rename = "UUID")]
#[cfg_attr(feature = "serde", serde(rename = "UUID"))]
Uuid,
__Unknown__(String),
}
impl Default for CardIdentificationType1Code {
fn default() -> CardIdentificationType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for CardIdentificationType1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct CardPaymentEnvironment82 {
#[yaserde(rename = "Acqrr")]
#[cfg_attr(feature = "serde", serde(rename = "Acqrr"))]
pub acqrr: Acquirer10,
#[yaserde(rename = "SvcPrvdr")]
#[cfg_attr(feature = "serde", serde(rename = "SvcPrvdr"))]
pub svc_prvdr: Acquirer10,
#[yaserde(rename = "Mrchnt")]
#[cfg_attr(feature = "serde", serde(rename = "Mrchnt"))]
pub mrchnt: Organisation45,
#[yaserde(rename = "POI")]
#[cfg_attr(feature = "serde", serde(rename = "POI"))]
pub poi: PointOfInteraction16,
#[yaserde(rename = "Card")]
#[cfg_attr(feature = "serde", serde(rename = "Card"))]
pub card: PaymentCard35,
#[yaserde(rename = "Chck")]
#[cfg_attr(feature = "serde", serde(rename = "Chck"))]
pub chck: Check1,
#[yaserde(rename = "StordValAcct")]
#[cfg_attr(feature = "serde", serde(rename = "StordValAcct"))]
pub stord_val_acct: Vec<StoredValueAccount2>,
#[yaserde(rename = "LltyAcct")]
#[cfg_attr(feature = "serde", serde(rename = "LltyAcct"))]
pub llty_acct: Vec<LoyaltyAccount3>,
#[yaserde(rename = "CstmrDvc")]
#[cfg_attr(feature = "serde", serde(rename = "CstmrDvc"))]
pub cstmr_dvc: CustomerDevice3,
#[yaserde(rename = "Wllt")]
#[cfg_attr(feature = "serde", serde(rename = "Wllt"))]
pub wllt: CustomerDevice3,
#[yaserde(rename = "PmtTkn")]
#[cfg_attr(feature = "serde", serde(rename = "PmtTkn"))]
pub pmt_tkn: Token1,
#[yaserde(rename = "MrchntTkn")]
#[cfg_attr(feature = "serde", serde(rename = "MrchntTkn"))]
pub mrchnt_tkn: MerchantToken2,
#[yaserde(rename = "Crdhldr")]
#[cfg_attr(feature = "serde", serde(rename = "Crdhldr"))]
pub crdhldr: Cardholder21,
#[yaserde(rename = "PrtctdCrdhldrData")]
#[cfg_attr(feature = "serde", serde(rename = "PrtctdCrdhldrData"))]
pub prtctd_crdhldr_data: ContentInformationType40,
#[yaserde(rename = "SaleEnvt")]
#[cfg_attr(feature = "serde", serde(rename = "SaleEnvt"))]
pub sale_envt: RetailerSaleEnvironment2,
}
impl Validate for CardPaymentEnvironment82 {}
#[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:caaa.009.001.14")]
pub enum CardProductType1Code {
#[yaserde(rename = "COMM")]
#[cfg_attr(feature = "serde", serde(rename = "COMM"))]
Comm,
#[yaserde(rename = "CONS")]
#[cfg_attr(feature = "serde", serde(rename = "CONS"))]
Cons,
__Unknown__(String),
}
impl Default for CardProductType1Code {
fn default() -> CardProductType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for CardProductType1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct Cardholder21 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: PersonIdentification15,
#[yaserde(rename = "Nm")]
#[cfg_attr(feature = "serde", serde(rename = "Nm"))]
pub nm: Max45Text,
#[yaserde(rename = "Lang")]
#[cfg_attr(feature = "serde", serde(rename = "Lang"))]
pub lang: LanguageCode,
#[yaserde(rename = "BllgAdr")]
#[cfg_attr(feature = "serde", serde(rename = "BllgAdr"))]
pub bllg_adr: PostalAddress22,
#[yaserde(rename = "ShppgAdr")]
#[cfg_attr(feature = "serde", serde(rename = "ShppgAdr"))]
pub shppg_adr: PostalAddress22,
#[yaserde(rename = "TripNb")]
#[cfg_attr(feature = "serde", serde(rename = "TripNb"))]
pub trip_nb: Max35Text,
#[yaserde(rename = "Vhcl")]
#[cfg_attr(feature = "serde", serde(rename = "Vhcl"))]
pub vhcl: Vehicle1,
#[yaserde(rename = "Authntcn")]
#[cfg_attr(feature = "serde", serde(rename = "Authntcn"))]
pub authntcn: Vec<CardholderAuthentication17>,
#[yaserde(rename = "TxVrfctnRslt")]
#[cfg_attr(feature = "serde", serde(rename = "TxVrfctnRslt"))]
pub tx_vrfctn_rslt: Vec<TransactionVerificationResult4>,
#[yaserde(rename = "PrsnlData")]
#[cfg_attr(feature = "serde", serde(rename = "PrsnlData"))]
pub prsnl_data: Max70Text,
#[yaserde(rename = "MobData")]
#[cfg_attr(feature = "serde", serde(rename = "MobData"))]
pub mob_data: Vec<MobileData6>,
}
impl Validate for Cardholder21 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct CardholderAuthentication17 {
#[yaserde(rename = "AuthntcnMtd")]
#[cfg_attr(feature = "serde", serde(rename = "AuthntcnMtd"))]
pub authntcn_mtd: AuthenticationMethod8Code,
#[yaserde(rename = "AuthntcnXmptn")]
#[cfg_attr(feature = "serde", serde(rename = "AuthntcnXmptn"))]
pub authntcn_xmptn: Exemption1Code,
#[yaserde(rename = "AuthntcnVal")]
#[cfg_attr(feature = "serde", serde(rename = "AuthntcnVal"))]
pub authntcn_val: Max5000Binary,
#[yaserde(rename = "PrtctdAuthntcnVal")]
#[cfg_attr(feature = "serde", serde(rename = "PrtctdAuthntcnVal"))]
pub prtctd_authntcn_val: ContentInformationType40,
#[yaserde(rename = "CrdhldrOnLinePIN")]
#[cfg_attr(feature = "serde", serde(rename = "CrdhldrOnLinePIN"))]
pub crdhldr_on_line_pin: OnLinePIN11,
#[yaserde(rename = "CrdhldrId")]
#[cfg_attr(feature = "serde", serde(rename = "CrdhldrId"))]
pub crdhldr_id: PersonIdentification15,
#[yaserde(rename = "AdrVrfctn")]
#[cfg_attr(feature = "serde", serde(rename = "AdrVrfctn"))]
pub adr_vrfctn: AddressVerification1,
#[yaserde(rename = "AuthntcnTp")]
#[cfg_attr(feature = "serde", serde(rename = "AuthntcnTp"))]
pub authntcn_tp: Max35Text,
#[yaserde(rename = "AuthntcnLvl")]
#[cfg_attr(feature = "serde", serde(rename = "AuthntcnLvl"))]
pub authntcn_lvl: Max35Text,
#[yaserde(rename = "AuthntcnRslt")]
#[cfg_attr(feature = "serde", serde(rename = "AuthntcnRslt"))]
pub authntcn_rslt: AuthenticationResult1Code,
#[yaserde(rename = "AuthntcnAddtlInf")]
#[cfg_attr(feature = "serde", serde(rename = "AuthntcnAddtlInf"))]
pub authntcn_addtl_inf: ExternallyDefinedData5,
}
impl Validate for CardholderAuthentication17 {}
#[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:caaa.009.001.14")]
pub enum CardholderVerificationCapability4Code {
#[yaserde(rename = "APKI")]
#[cfg_attr(feature = "serde", serde(rename = "APKI"))]
Apki,
#[yaserde(rename = "CHDT")]
#[cfg_attr(feature = "serde", serde(rename = "CHDT"))]
Chdt,
#[yaserde(rename = "MNSG")]
#[cfg_attr(feature = "serde", serde(rename = "MNSG"))]
Mnsg,
#[yaserde(rename = "MNVR")]
#[cfg_attr(feature = "serde", serde(rename = "MNVR"))]
Mnvr,
#[yaserde(rename = "FBIG")]
#[cfg_attr(feature = "serde", serde(rename = "FBIG"))]
Fbig,
#[yaserde(rename = "FBIO")]
#[cfg_attr(feature = "serde", serde(rename = "FBIO"))]
Fbio,
#[yaserde(rename = "FDSG")]
#[cfg_attr(feature = "serde", serde(rename = "FDSG"))]
Fdsg,
#[yaserde(rename = "FCPN")]
#[cfg_attr(feature = "serde", serde(rename = "FCPN"))]
Fcpn,
#[yaserde(rename = "FEPN")]
#[cfg_attr(feature = "serde", serde(rename = "FEPN"))]
Fepn,
#[yaserde(rename = "NPIN")]
#[cfg_attr(feature = "serde", serde(rename = "NPIN"))]
Npin,
#[yaserde(rename = "PKIS")]
#[cfg_attr(feature = "serde", serde(rename = "PKIS"))]
Pkis,
#[yaserde(rename = "SCEC")]
#[cfg_attr(feature = "serde", serde(rename = "SCEC"))]
Scec,
#[yaserde(rename = "NBIO")]
#[cfg_attr(feature = "serde", serde(rename = "NBIO"))]
Nbio,
#[yaserde(rename = "NOVF")]
#[cfg_attr(feature = "serde", serde(rename = "NOVF"))]
Novf,
#[yaserde(rename = "OTHR")]
#[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
Othr,
__Unknown__(String),
}
impl Default for CardholderVerificationCapability4Code {
fn default() -> CardholderVerificationCapability4Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for CardholderVerificationCapability4Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct CertificateIssuer1 {
#[yaserde(rename = "RltvDstngshdNm")]
#[cfg_attr(feature = "serde", serde(rename = "RltvDstngshdNm"))]
pub rltv_dstngshd_nm: Vec<RelativeDistinguishedName1>,
}
impl Validate for CertificateIssuer1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct Check1 {
#[yaserde(rename = "BkId")]
#[cfg_attr(feature = "serde", serde(rename = "BkId"))]
pub bk_id: Max35Text,
#[yaserde(rename = "AcctNb")]
#[cfg_attr(feature = "serde", serde(rename = "AcctNb"))]
pub acct_nb: Max35Text,
#[yaserde(rename = "ChckNb")]
#[cfg_attr(feature = "serde", serde(rename = "ChckNb"))]
pub chck_nb: Max35Text,
#[yaserde(rename = "ChckCardNb")]
#[cfg_attr(feature = "serde", serde(rename = "ChckCardNb"))]
pub chck_card_nb: Max35Text,
#[yaserde(rename = "ChckTrckData2")]
#[cfg_attr(feature = "serde", serde(rename = "ChckTrckData2"))]
pub chck_trck_data_2: TrackData2,
#[yaserde(rename = "ChckTp")]
#[cfg_attr(feature = "serde", serde(rename = "ChckTp"))]
pub chck_tp: CheckType1Code,
#[yaserde(rename = "Ctry")]
#[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
pub ctry: Max3Text,
}
impl Validate for Check1 {}
#[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:caaa.009.001.14")]
pub enum CheckType1Code {
#[yaserde(rename = "BANK")]
#[cfg_attr(feature = "serde", serde(rename = "BANK"))]
Bank,
#[yaserde(rename = "BUSI")]
#[cfg_attr(feature = "serde", serde(rename = "BUSI"))]
Busi,
#[yaserde(rename = "GOVC")]
#[cfg_attr(feature = "serde", serde(rename = "GOVC"))]
Govc,
#[yaserde(rename = "PAYR")]
#[cfg_attr(feature = "serde", serde(rename = "PAYR"))]
Payr,
#[yaserde(rename = "PERS")]
#[cfg_attr(feature = "serde", serde(rename = "PERS"))]
Pers,
__Unknown__(String),
}
impl Default for CheckType1Code {
fn default() -> CheckType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for CheckType1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct CommunicationAddress9 {
#[yaserde(rename = "PstlAdr")]
#[cfg_attr(feature = "serde", serde(rename = "PstlAdr"))]
pub pstl_adr: PostalAddress22,
#[yaserde(rename = "Email")]
#[cfg_attr(feature = "serde", serde(rename = "Email"))]
pub email: Max256Text,
#[yaserde(rename = "URLAdr")]
#[cfg_attr(feature = "serde", serde(rename = "URLAdr"))]
pub url_adr: Max256Text,
#[yaserde(rename = "Phne")]
#[cfg_attr(feature = "serde", serde(rename = "Phne"))]
pub phne: PhoneNumber,
#[yaserde(rename = "CstmrSvc")]
#[cfg_attr(feature = "serde", serde(rename = "CstmrSvc"))]
pub cstmr_svc: PhoneNumber,
#[yaserde(rename = "AddtlCtctInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlCtctInf"))]
pub addtl_ctct_inf: Max256Text,
}
impl Validate for CommunicationAddress9 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct CommunicationCharacteristics5 {
#[yaserde(rename = "ComTp")]
#[cfg_attr(feature = "serde", serde(rename = "ComTp"))]
pub com_tp: PoicommunicationType2Code,
#[yaserde(rename = "RmotPty")]
#[cfg_attr(feature = "serde", serde(rename = "RmotPty"))]
pub rmot_pty: Vec<PartyType7Code>,
#[yaserde(rename = "Actv")]
#[cfg_attr(feature = "serde", serde(rename = "Actv"))]
pub actv: TrueFalseIndicator,
#[yaserde(rename = "Params")]
#[cfg_attr(feature = "serde", serde(rename = "Params"))]
pub params: NetworkParameters7,
#[yaserde(rename = "PhysIntrfc")]
#[cfg_attr(feature = "serde", serde(rename = "PhysIntrfc"))]
pub phys_intrfc: PhysicalInterfaceParameter1,
}
impl Validate for CommunicationCharacteristics5 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct ContentInformationType37 {
#[yaserde(rename = "CnttTp")]
#[cfg_attr(feature = "serde", serde(rename = "CnttTp"))]
pub cntt_tp: ContentType2Code,
#[yaserde(rename = "AuthntcdData")]
#[cfg_attr(feature = "serde", serde(rename = "AuthntcdData"))]
pub authntcd_data: AuthenticatedData10,
}
impl Validate for ContentInformationType37 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct ContentInformationType39 {
#[yaserde(rename = "CnttTp")]
#[cfg_attr(feature = "serde", serde(rename = "CnttTp"))]
pub cntt_tp: ContentType2Code,
#[yaserde(rename = "EnvlpdData")]
#[cfg_attr(feature = "serde", serde(rename = "EnvlpdData"))]
pub envlpd_data: EnvelopedData11,
#[yaserde(rename = "AuthntcdData")]
#[cfg_attr(feature = "serde", serde(rename = "AuthntcdData"))]
pub authntcd_data: AuthenticatedData10,
#[yaserde(rename = "SgndData")]
#[cfg_attr(feature = "serde", serde(rename = "SgndData"))]
pub sgnd_data: SignedData9,
#[yaserde(rename = "DgstdData")]
#[cfg_attr(feature = "serde", serde(rename = "DgstdData"))]
pub dgstd_data: DigestedData6,
}
impl Validate for ContentInformationType39 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct ContentInformationType40 {
#[yaserde(rename = "CnttTp")]
#[cfg_attr(feature = "serde", serde(rename = "CnttTp"))]
pub cntt_tp: ContentType2Code,
#[yaserde(rename = "EnvlpdData")]
#[cfg_attr(feature = "serde", serde(rename = "EnvlpdData"))]
pub envlpd_data: EnvelopedData11,
}
impl Validate for ContentInformationType40 {}
#[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:caaa.009.001.14")]
pub enum ContentType2Code {
#[yaserde(rename = "DATA")]
#[cfg_attr(feature = "serde", serde(rename = "DATA"))]
Data,
#[yaserde(rename = "SIGN")]
#[cfg_attr(feature = "serde", serde(rename = "SIGN"))]
Sign,
#[yaserde(rename = "EVLP")]
#[cfg_attr(feature = "serde", serde(rename = "EVLP"))]
Evlp,
#[yaserde(rename = "DGST")]
#[cfg_attr(feature = "serde", serde(rename = "DGST"))]
Dgst,
#[yaserde(rename = "AUTH")]
#[cfg_attr(feature = "serde", serde(rename = "AUTH"))]
Auth,
__Unknown__(String),
}
impl Default for ContentType2Code {
fn default() -> ContentType2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for ContentType2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct CountryCode (pub String);
crate::simple_type!(CountryCode);
impl Validate for CountryCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct CryptographicKey19 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max350Text,
#[yaserde(rename = "KeyId")]
#[cfg_attr(feature = "serde", serde(rename = "KeyId"))]
pub key_id: Max350Text,
#[yaserde(rename = "AddtlId")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlId"))]
pub addtl_id: Max35Binary,
#[yaserde(rename = "Nm")]
#[cfg_attr(feature = "serde", serde(rename = "Nm"))]
pub nm: Max256Text,
#[yaserde(rename = "SctyPrfl")]
#[cfg_attr(feature = "serde", serde(rename = "SctyPrfl"))]
pub scty_prfl: Max35Text,
#[yaserde(rename = "ItmNb")]
#[cfg_attr(feature = "serde", serde(rename = "ItmNb"))]
pub itm_nb: Max35Text,
#[yaserde(rename = "SeqNb")]
#[cfg_attr(feature = "serde", serde(rename = "SeqNb"))]
pub seq_nb: Number,
#[yaserde(rename = "Vrsn")]
#[cfg_attr(feature = "serde", serde(rename = "Vrsn"))]
pub vrsn: Max256Text,
#[yaserde(rename = "KeyVrsn")]
#[cfg_attr(feature = "serde", serde(rename = "KeyVrsn"))]
pub key_vrsn: Max256Text,
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: CryptographicKeyType5Code,
#[yaserde(rename = "Fctn")]
#[cfg_attr(feature = "serde", serde(rename = "Fctn"))]
pub fctn: Vec<KeyUsage1Code>,
#[yaserde(rename = "ActvtnDt")]
#[cfg_attr(feature = "serde", serde(rename = "ActvtnDt"))]
pub actvtn_dt: IsodateTime,
#[yaserde(rename = "DeactvtnDt")]
#[cfg_attr(feature = "serde", serde(rename = "DeactvtnDt"))]
pub deactvtn_dt: IsodateTime,
#[yaserde(rename = "KeyVal")]
#[cfg_attr(feature = "serde", serde(rename = "KeyVal"))]
pub key_val: ContentInformationType39,
#[yaserde(rename = "CmpntWthAuthrsdAccs")]
#[cfg_attr(feature = "serde", serde(rename = "CmpntWthAuthrsdAccs"))]
pub cmpnt_wth_authrsd_accs: Vec<GenericIdentification186>,
#[yaserde(rename = "PrtctdCmpntWthAuthrsdAccs")]
#[cfg_attr(feature = "serde", serde(rename = "PrtctdCmpntWthAuthrsdAccs"))]
pub prtctd_cmpnt_wth_authrsd_accs: Vec<ContentInformationType39>,
#[yaserde(rename = "KeyChckVal")]
#[cfg_attr(feature = "serde", serde(rename = "KeyChckVal"))]
pub key_chck_val: Max35Binary,
#[yaserde(rename = "AddtlMgmtInf")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlMgmtInf"))]
pub addtl_mgmt_inf: Vec<GenericInformation1>,
#[yaserde(rename = "DerivtnAlgoIdr")]
#[cfg_attr(feature = "serde", serde(rename = "DerivtnAlgoIdr"))]
pub derivtn_algo_idr: Max140Text,
#[yaserde(rename = "AlgoIdr")]
#[cfg_attr(feature = "serde", serde(rename = "AlgoIdr"))]
pub algo_idr: Max140Text,
}
impl Validate for CryptographicKey19 {}
#[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:caaa.009.001.14")]
pub enum CryptographicKeyType5Code {
#[yaserde(rename = "AES2")]
#[cfg_attr(feature = "serde", serde(rename = "AES2"))]
Aes2,
#[yaserde(rename = "EDE3")]
#[cfg_attr(feature = "serde", serde(rename = "EDE3"))]
Ede3,
#[yaserde(rename = "DKP9")]
#[cfg_attr(feature = "serde", serde(rename = "DKP9"))]
Dkp9,
#[yaserde(rename = "AES9")]
#[cfg_attr(feature = "serde", serde(rename = "AES9"))]
Aes9,
#[yaserde(rename = "AES5")]
#[cfg_attr(feature = "serde", serde(rename = "AES5"))]
Aes5,
#[yaserde(rename = "EDE4")]
#[cfg_attr(feature = "serde", serde(rename = "EDE4"))]
Ede4,
#[yaserde(rename = "UKA2")]
#[cfg_attr(feature = "serde", serde(rename = "UKA2"))]
Uka2,
#[yaserde(rename = "UKA6")]
#[cfg_attr(feature = "serde", serde(rename = "UKA6"))]
Uka6,
#[yaserde(rename = "RSAC")]
#[cfg_attr(feature = "serde", serde(rename = "RSAC"))]
Rsac,
#[yaserde(rename = "ECCC")]
#[cfg_attr(feature = "serde", serde(rename = "ECCC"))]
Eccc,
#[yaserde(rename = "DKAE")]
#[cfg_attr(feature = "serde", serde(rename = "DKAE"))]
Dkae,
#[yaserde(rename = "UKA8")]
#[cfg_attr(feature = "serde", serde(rename = "UKA8"))]
Uka8,
__Unknown__(String),
}
impl Default for CryptographicKeyType5Code {
fn default() -> CryptographicKeyType5Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for CryptographicKeyType5Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct CustomerDevice3 {
#[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: Max70Text,
#[yaserde(rename = "Prvdr")]
#[cfg_attr(feature = "serde", serde(rename = "Prvdr"))]
pub prvdr: Max35Text,
}
impl Validate for CustomerDevice3 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
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)]
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:caaa.009.001.14")]
pub struct DigestedData6 {
#[yaserde(rename = "Vrsn")]
#[cfg_attr(feature = "serde", serde(rename = "Vrsn"))]
pub vrsn: Number,
#[yaserde(rename = "DgstAlgo")]
#[cfg_attr(feature = "serde", serde(rename = "DgstAlgo"))]
pub dgst_algo: AlgorithmIdentification36,
#[yaserde(rename = "NcpsltdCntt")]
#[cfg_attr(feature = "serde", serde(rename = "NcpsltdCntt"))]
pub ncpsltd_cntt: EncapsulatedContent3,
#[yaserde(rename = "Dgst")]
#[cfg_attr(feature = "serde", serde(rename = "Dgst"))]
pub dgst: Max140Binary,
}
impl Validate for DigestedData6 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct DisplayCapabilities7 {
#[yaserde(rename = "Dstn")]
#[cfg_attr(feature = "serde", serde(rename = "Dstn"))]
pub dstn: Vec<UserInterface9Code>,
#[yaserde(rename = "AvlblFrmt")]
#[cfg_attr(feature = "serde", serde(rename = "AvlblFrmt"))]
pub avlbl_frmt: Vec<OutputFormat1Code>,
#[yaserde(rename = "NbOfLines")]
#[cfg_attr(feature = "serde", serde(rename = "NbOfLines"))]
pub nb_of_lines: Number,
#[yaserde(rename = "LineWidth")]
#[cfg_attr(feature = "serde", serde(rename = "LineWidth"))]
pub line_width: Number,
#[yaserde(rename = "AvlblLang")]
#[cfg_attr(feature = "serde", serde(rename = "AvlblLang"))]
pub avlbl_lang: Vec<LanguageCode>,
}
impl Validate for DisplayCapabilities7 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct Document {
#[yaserde(rename = "AccptrRcncltnReq")]
#[cfg_attr(feature = "serde", serde(rename = "AccptrRcncltnReq"))]
pub accptr_rcncltn_req: AcceptorReconciliationRequestV14,
}
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:caaa.009.001.14")]
pub struct EncapsulatedContent3 {
#[yaserde(rename = "CnttTp")]
#[cfg_attr(feature = "serde", serde(rename = "CnttTp"))]
pub cntt_tp: ContentType2Code,
#[yaserde(rename = "Cntt")]
#[cfg_attr(feature = "serde", serde(rename = "Cntt"))]
pub cntt: Max100KBinary,
}
impl Validate for EncapsulatedContent3 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct EncryptedContent7 {
#[yaserde(rename = "CnttTp")]
#[cfg_attr(feature = "serde", serde(rename = "CnttTp"))]
pub cntt_tp: ContentType2Code,
#[yaserde(rename = "CnttNcrptnAlgo")]
#[cfg_attr(feature = "serde", serde(rename = "CnttNcrptnAlgo"))]
pub cntt_ncrptn_algo: AlgorithmIdentification32,
#[yaserde(rename = "NcrptdData")]
#[cfg_attr(feature = "serde", serde(rename = "NcrptdData"))]
pub ncrptd_data: Max100KBinary,
}
impl Validate for EncryptedContent7 {}
#[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:caaa.009.001.14")]
pub enum EncryptionFormat2Code {
#[yaserde(rename = "TR31")]
#[cfg_attr(feature = "serde", serde(rename = "TR31"))]
Tr31,
#[yaserde(rename = "TR34")]
#[cfg_attr(feature = "serde", serde(rename = "TR34"))]
Tr34,
I238,
__Unknown__(String),
}
impl Default for EncryptionFormat2Code {
fn default() -> EncryptionFormat2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for EncryptionFormat2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct EnvelopedData11 {
#[yaserde(rename = "Vrsn")]
#[cfg_attr(feature = "serde", serde(rename = "Vrsn"))]
pub vrsn: Number,
#[yaserde(rename = "OrgtrInf")]
#[cfg_attr(feature = "serde", serde(rename = "OrgtrInf"))]
pub orgtr_inf: OriginatorInformation1,
#[yaserde(rename = "Rcpt")]
#[cfg_attr(feature = "serde", serde(rename = "Rcpt"))]
pub rcpt: Vec<Recipient15Choice>,
#[yaserde(rename = "NcrptdCntt")]
#[cfg_attr(feature = "serde", serde(rename = "NcrptdCntt"))]
pub ncrptd_cntt: EncryptedContent7,
}
impl Validate for EnvelopedData11 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Exact3AlphaNumericText (pub String);
crate::simple_type!(Exact3AlphaNumericText);
impl Validate for Exact3AlphaNumericText {}
#[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 Exact4NumericText (pub String);
crate::simple_type!(Exact4NumericText);
impl Validate for Exact4NumericText {}
#[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:caaa.009.001.14")]
pub enum Exemption1Code {
#[yaserde(rename = "LOWA")]
#[cfg_attr(feature = "serde", serde(rename = "LOWA"))]
Lowa,
#[yaserde(rename = "MINT")]
#[cfg_attr(feature = "serde", serde(rename = "MINT"))]
Mint,
#[yaserde(rename = "RECP")]
#[cfg_attr(feature = "serde", serde(rename = "RECP"))]
Recp,
#[yaserde(rename = "SCPE")]
#[cfg_attr(feature = "serde", serde(rename = "SCPE"))]
Scpe,
#[yaserde(rename = "SCAD")]
#[cfg_attr(feature = "serde", serde(rename = "SCAD"))]
Scad,
#[yaserde(rename = "TRAE")]
#[cfg_attr(feature = "serde", serde(rename = "TRAE"))]
Trae,
#[yaserde(rename = "PKGE")]
#[cfg_attr(feature = "serde", serde(rename = "PKGE"))]
Pkge,
#[yaserde(rename = "TMBE")]
#[cfg_attr(feature = "serde", serde(rename = "TMBE"))]
Tmbe,
__Unknown__(String),
}
impl Default for Exemption1Code {
fn default() -> Exemption1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for Exemption1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct ExternallyDefinedData5 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max1025Text,
#[yaserde(rename = "Val")]
#[cfg_attr(feature = "serde", serde(rename = "Val"))]
pub val: Max100KBinary,
#[yaserde(rename = "PrtctdVal")]
#[cfg_attr(feature = "serde", serde(rename = "PrtctdVal"))]
pub prtctd_val: ContentInformationType39,
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: Max1025Text,
}
impl Validate for ExternallyDefinedData5 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct GenericIdentification176 {
#[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: PartyType33Code,
#[yaserde(rename = "Issr")]
#[cfg_attr(feature = "serde", serde(rename = "Issr"))]
pub issr: PartyType33Code,
#[yaserde(rename = "Ctry")]
#[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
pub ctry: Min2Max3AlphaText,
#[yaserde(rename = "ShrtNm")]
#[cfg_attr(feature = "serde", serde(rename = "ShrtNm"))]
pub shrt_nm: Max35Text,
}
impl Validate for GenericIdentification176 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct GenericIdentification177 {
#[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: PartyType33Code,
#[yaserde(rename = "Issr")]
#[cfg_attr(feature = "serde", serde(rename = "Issr"))]
pub issr: PartyType33Code,
#[yaserde(rename = "Ctry")]
#[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
pub ctry: Min2Max3AlphaText,
#[yaserde(rename = "ShrtNm")]
#[cfg_attr(feature = "serde", serde(rename = "ShrtNm"))]
pub shrt_nm: Max35Text,
#[yaserde(rename = "RmotAccs")]
#[cfg_attr(feature = "serde", serde(rename = "RmotAccs"))]
pub rmot_accs: NetworkParameters7,
#[yaserde(rename = "Glctn")]
#[cfg_attr(feature = "serde", serde(rename = "Glctn"))]
pub glctn: Geolocation1,
}
impl Validate for GenericIdentification177 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct GenericIdentification186 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max256Text,
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: PartyType7Code,
}
impl Validate for GenericIdentification186 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct GenericIdentification192 {
#[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: PartyType35Code,
#[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 GenericIdentification192 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct GenericIdentification4 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max35Text,
#[yaserde(rename = "IdTp")]
#[cfg_attr(feature = "serde", serde(rename = "IdTp"))]
pub id_tp: Max35Text,
}
impl Validate for GenericIdentification4 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct GenericIdentification48 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max35Text,
#[yaserde(rename = "Vrsn")]
#[cfg_attr(feature = "serde", serde(rename = "Vrsn"))]
pub vrsn: Max35Text,
#[yaserde(rename = "Issr")]
#[cfg_attr(feature = "serde", serde(rename = "Issr"))]
pub issr: Max35Text,
}
impl Validate for GenericIdentification48 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct GenericInformation1 {
#[yaserde(rename = "Nm")]
#[cfg_attr(feature = "serde", serde(rename = "Nm"))]
pub nm: Max70Text,
#[yaserde(rename = "Val")]
#[cfg_attr(feature = "serde", serde(rename = "Val"))]
pub val: Max140Text,
}
impl Validate for GenericInformation1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct Geolocation1 {
#[yaserde(rename = "GeogcCordints")]
#[cfg_attr(feature = "serde", serde(rename = "GeogcCordints"))]
pub geogc_cordints: GeolocationGeographicCoordinates1,
#[yaserde(rename = "UTMCordints")]
#[cfg_attr(feature = "serde", serde(rename = "UTMCordints"))]
pub utm_cordints: GeolocationUTMCoordinates1,
}
impl Validate for Geolocation1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct GeolocationGeographicCoordinates1 {
#[yaserde(rename = "Lat")]
#[cfg_attr(feature = "serde", serde(rename = "Lat"))]
pub lat: Max35Text,
#[yaserde(rename = "Long")]
#[cfg_attr(feature = "serde", serde(rename = "Long"))]
pub long: Max35Text,
}
impl Validate for GeolocationGeographicCoordinates1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct GeolocationUTMCoordinates1 {
#[yaserde(rename = "UTMZone")]
#[cfg_attr(feature = "serde", serde(rename = "UTMZone"))]
pub utm_zone: Max35Text,
#[yaserde(rename = "UTMEstwrd")]
#[cfg_attr(feature = "serde", serde(rename = "UTMEstwrd"))]
pub utm_estwrd: Max35Text,
#[yaserde(rename = "UTMNrthwrd")]
#[cfg_attr(feature = "serde", serde(rename = "UTMNrthwrd"))]
pub utm_nrthwrd: Max35Text,
}
impl Validate for GeolocationUTMCoordinates1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct Header70 {
#[yaserde(rename = "MsgFctn")]
#[cfg_attr(feature = "serde", serde(rename = "MsgFctn"))]
pub msg_fctn: MessageFunction46Code,
#[yaserde(rename = "PrtcolVrsn")]
#[cfg_attr(feature = "serde", serde(rename = "PrtcolVrsn"))]
pub prtcol_vrsn: Max6Text,
#[yaserde(rename = "XchgId")]
#[cfg_attr(feature = "serde", serde(rename = "XchgId"))]
pub xchg_id: Number,
#[yaserde(rename = "ReTrnsmssnCntr")]
#[cfg_attr(feature = "serde", serde(rename = "ReTrnsmssnCntr"))]
pub re_trnsmssn_cntr: Max3NumericText,
#[yaserde(rename = "CreDtTm")]
#[cfg_attr(feature = "serde", serde(rename = "CreDtTm"))]
pub cre_dt_tm: IsodateTime,
#[yaserde(rename = "InitgPty")]
#[cfg_attr(feature = "serde", serde(rename = "InitgPty"))]
pub initg_pty: GenericIdentification176,
#[yaserde(rename = "RcptPty")]
#[cfg_attr(feature = "serde", serde(rename = "RcptPty"))]
pub rcpt_pty: GenericIdentification177,
#[yaserde(rename = "Tracblt")]
#[cfg_attr(feature = "serde", serde(rename = "Tracblt"))]
pub tracblt: Vec<Traceability8>,
}
impl Validate for Header70 {}
#[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 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:caaa.009.001.14")]
pub struct IssuerAndSerialNumber2 {
#[yaserde(rename = "Issr")]
#[cfg_attr(feature = "serde", serde(rename = "Issr"))]
pub issr: CertificateIssuer1,
#[yaserde(rename = "SrlNb")]
#[cfg_attr(feature = "serde", serde(rename = "SrlNb"))]
pub srl_nb: Max500Binary,
}
impl Validate for IssuerAndSerialNumber2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct Kek9 {
#[yaserde(rename = "Vrsn")]
#[cfg_attr(feature = "serde", serde(rename = "Vrsn"))]
pub vrsn: Number,
#[yaserde(rename = "KEKId")]
#[cfg_attr(feature = "serde", serde(rename = "KEKId"))]
pub kek_id: Kekidentifier7,
#[yaserde(rename = "KeyNcrptnAlgo")]
#[cfg_attr(feature = "serde", serde(rename = "KeyNcrptnAlgo"))]
pub key_ncrptn_algo: AlgorithmIdentification32,
#[yaserde(rename = "NcrptdKey")]
#[cfg_attr(feature = "serde", serde(rename = "NcrptdKey"))]
pub ncrptd_key: Max500Binary,
}
impl Validate for Kek9 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct Kekidentifier7 {
#[yaserde(rename = "KeyId")]
#[cfg_attr(feature = "serde", serde(rename = "KeyId"))]
pub key_id: Max140Text,
#[yaserde(rename = "KeyVrsn")]
#[cfg_attr(feature = "serde", serde(rename = "KeyVrsn"))]
pub key_vrsn: Max140Text,
#[yaserde(rename = "SeqNb")]
#[cfg_attr(feature = "serde", serde(rename = "SeqNb"))]
pub seq_nb: Number,
#[yaserde(rename = "DerivtnId")]
#[cfg_attr(feature = "serde", serde(rename = "DerivtnId"))]
pub derivtn_id: Max500Binary,
}
impl Validate for Kekidentifier7 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct KeyTransport10 {
#[yaserde(rename = "Vrsn")]
#[cfg_attr(feature = "serde", serde(rename = "Vrsn"))]
pub vrsn: Number,
#[yaserde(rename = "RcptId")]
#[cfg_attr(feature = "serde", serde(rename = "RcptId"))]
pub rcpt_id: Recipient13Choice,
#[yaserde(rename = "KeyNcrptnAlgo")]
#[cfg_attr(feature = "serde", serde(rename = "KeyNcrptnAlgo"))]
pub key_ncrptn_algo: AlgorithmIdentification35,
#[yaserde(rename = "NcrptdKey")]
#[cfg_attr(feature = "serde", serde(rename = "NcrptdKey"))]
pub ncrptd_key: Max5000Binary,
}
impl Validate for KeyTransport10 {}
#[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:caaa.009.001.14")]
pub enum KeyUsage1Code {
#[yaserde(rename = "ENCR")]
#[cfg_attr(feature = "serde", serde(rename = "ENCR"))]
Encr,
#[yaserde(rename = "DCPT")]
#[cfg_attr(feature = "serde", serde(rename = "DCPT"))]
Dcpt,
#[yaserde(rename = "DENC")]
#[cfg_attr(feature = "serde", serde(rename = "DENC"))]
Denc,
#[yaserde(rename = "DDEC")]
#[cfg_attr(feature = "serde", serde(rename = "DDEC"))]
Ddec,
#[yaserde(rename = "TRNI")]
#[cfg_attr(feature = "serde", serde(rename = "TRNI"))]
Trni,
#[yaserde(rename = "TRNX")]
#[cfg_attr(feature = "serde", serde(rename = "TRNX"))]
Trnx,
#[yaserde(rename = "MACG")]
#[cfg_attr(feature = "serde", serde(rename = "MACG"))]
Macg,
#[yaserde(rename = "MACV")]
#[cfg_attr(feature = "serde", serde(rename = "MACV"))]
Macv,
#[yaserde(rename = "SIGG")]
#[cfg_attr(feature = "serde", serde(rename = "SIGG"))]
Sigg,
#[yaserde(rename = "SUGV")]
#[cfg_attr(feature = "serde", serde(rename = "SUGV"))]
Sugv,
#[yaserde(rename = "PINE")]
#[cfg_attr(feature = "serde", serde(rename = "PINE"))]
Pine,
#[yaserde(rename = "PIND")]
#[cfg_attr(feature = "serde", serde(rename = "PIND"))]
Pind,
#[yaserde(rename = "PINV")]
#[cfg_attr(feature = "serde", serde(rename = "PINV"))]
Pinv,
#[yaserde(rename = "KEYG")]
#[cfg_attr(feature = "serde", serde(rename = "KEYG"))]
Keyg,
#[yaserde(rename = "KEYI")]
#[cfg_attr(feature = "serde", serde(rename = "KEYI"))]
Keyi,
#[yaserde(rename = "KEYX")]
#[cfg_attr(feature = "serde", serde(rename = "KEYX"))]
Keyx,
#[yaserde(rename = "KEYD")]
#[cfg_attr(feature = "serde", serde(rename = "KEYD"))]
Keyd,
__Unknown__(String),
}
impl Default for KeyUsage1Code {
fn default() -> KeyUsage1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for KeyUsage1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct LanguageCode (pub String);
crate::simple_type!(LanguageCode);
impl Validate for LanguageCode {}
#[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:caaa.009.001.14")]
pub enum LocationCategory3Code {
#[yaserde(rename = "INDR")]
#[cfg_attr(feature = "serde", serde(rename = "INDR"))]
Indr,
#[yaserde(rename = "IPMP")]
#[cfg_attr(feature = "serde", serde(rename = "IPMP"))]
Ipmp,
#[yaserde(rename = "MPOI")]
#[cfg_attr(feature = "serde", serde(rename = "MPOI"))]
Mpoi,
#[yaserde(rename = "MPMP")]
#[cfg_attr(feature = "serde", serde(rename = "MPMP"))]
Mpmp,
#[yaserde(rename = "MSLE")]
#[cfg_attr(feature = "serde", serde(rename = "MSLE"))]
Msle,
#[yaserde(rename = "SSLE")]
#[cfg_attr(feature = "serde", serde(rename = "SSLE"))]
Ssle,
#[yaserde(rename = "VNDG")]
#[cfg_attr(feature = "serde", serde(rename = "VNDG"))]
Vndg,
__Unknown__(String),
}
impl Default for LocationCategory3Code {
fn default() -> LocationCategory3Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for LocationCategory3Code {}
#[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:caaa.009.001.14")]
pub enum LocationCategory4Code {
#[yaserde(rename = "ABRD")]
#[cfg_attr(feature = "serde", serde(rename = "ABRD"))]
Abrd,
#[yaserde(rename = "NMDC")]
#[cfg_attr(feature = "serde", serde(rename = "NMDC"))]
Nmdc,
#[yaserde(rename = "FIXD")]
#[cfg_attr(feature = "serde", serde(rename = "FIXD"))]
Fixd,
#[yaserde(rename = "VIRT")]
#[cfg_attr(feature = "serde", serde(rename = "VIRT"))]
Virt,
__Unknown__(String),
}
impl Default for LocationCategory4Code {
fn default() -> LocationCategory4Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for LocationCategory4Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct LoyaltyAccount3 {
#[yaserde(rename = "LltyId")]
#[cfg_attr(feature = "serde", serde(rename = "LltyId"))]
pub llty_id: Max35Text,
#[yaserde(rename = "NtryMd")]
#[cfg_attr(feature = "serde", serde(rename = "NtryMd"))]
pub ntry_md: CardDataReading8Code,
#[yaserde(rename = "IdTp")]
#[cfg_attr(feature = "serde", serde(rename = "IdTp"))]
pub id_tp: CardIdentificationType1Code,
#[yaserde(rename = "Brnd")]
#[cfg_attr(feature = "serde", serde(rename = "Brnd"))]
pub brnd: Max35Text,
#[yaserde(rename = "Prvdr")]
#[cfg_attr(feature = "serde", serde(rename = "Prvdr"))]
pub prvdr: Max35Text,
#[yaserde(rename = "OwnrNm")]
#[cfg_attr(feature = "serde", serde(rename = "OwnrNm"))]
pub ownr_nm: Max45Text,
#[yaserde(rename = "Unit")]
#[cfg_attr(feature = "serde", serde(rename = "Unit"))]
pub unit: AmountUnit1Code,
#[yaserde(rename = "Ccy")]
#[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
pub ccy: ActiveCurrencyCode,
#[yaserde(rename = "Bal")]
#[cfg_attr(feature = "serde", serde(rename = "Bal"))]
pub bal: ImpliedCurrencyAndAmount,
}
impl Validate for LoyaltyAccount3 {}
#[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:caaa.009.001.14")]
pub enum LoyaltyHandling1Code {
#[yaserde(rename = "ALLO")]
#[cfg_attr(feature = "serde", serde(rename = "ALLO"))]
Allo,
#[yaserde(rename = "DENY")]
#[cfg_attr(feature = "serde", serde(rename = "DENY"))]
Deny,
#[yaserde(rename = "PRCS")]
#[cfg_attr(feature = "serde", serde(rename = "PRCS"))]
Prcs,
#[yaserde(rename = "PROP")]
#[cfg_attr(feature = "serde", serde(rename = "PROP"))]
Prop,
#[yaserde(rename = "REQU")]
#[cfg_attr(feature = "serde", serde(rename = "REQU"))]
Requ,
__Unknown__(String),
}
impl Default for LoyaltyHandling1Code {
fn default() -> LoyaltyHandling1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for LoyaltyHandling1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max100KBinary (pub String);
crate::simple_type!(Max100KBinary);
impl Validate for Max100KBinary {
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() > 102400 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 102400 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[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 Max104Text (pub String);
crate::simple_type!(Max104Text);
impl Validate for Max104Text {
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() > 104 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 104 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max10KBinary (pub String);
crate::simple_type!(Max10KBinary);
impl Validate for Max10KBinary {
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() > 10240 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 10240 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max10Text (pub String);
crate::simple_type!(Max10Text);
impl Validate for Max10Text {
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() > 10 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 10 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max11NumericText (pub String);
crate::simple_type!(Max11NumericText);
impl Validate for Max11NumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max140Binary (pub String);
crate::simple_type!(Max140Binary);
impl Validate for Max140Binary {
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 Max140Text (pub String);
crate::simple_type!(Max140Text);
impl Validate for Max140Text {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 140 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 140 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max15NumericText (pub String);
crate::simple_type!(Max15NumericText);
impl Validate for Max15NumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max16Text (pub String);
crate::simple_type!(Max16Text);
impl Validate for Max16Text {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 16 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 16 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max19NumericText (pub String);
crate::simple_type!(Max19NumericText);
impl Validate for Max19NumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max256Text (pub String);
crate::simple_type!(Max256Text);
impl Validate for Max256Text {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 256 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 256 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max2KBinary (pub String);
crate::simple_type!(Max2KBinary);
impl Validate for Max2KBinary {
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 Max2NumericText (pub String);
crate::simple_type!(Max2NumericText);
impl Validate for Max2NumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max3000Binary (pub String);
crate::simple_type!(Max3000Binary);
impl Validate for Max3000Binary {
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() > 3000 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 3000 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max30Text (pub String);
crate::simple_type!(Max30Text);
impl Validate for Max30Text {
fn validate(&self) -> Result<(), String> {
if self.0.len() > 30 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 30 \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 Max35Binary (pub String);
crate::simple_type!(Max35Binary);
impl Validate for Max35Binary {
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 Max35NumericText (pub String);
crate::simple_type!(Max35NumericText);
impl Validate for Max35NumericText {}
#[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 Max37Text (pub String);
crate::simple_type!(Max37Text);
impl Validate for Max37Text {
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() > 37 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 37 \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 Max3Text (pub String);
crate::simple_type!(Max3Text);
impl Validate for Max3Text {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 3 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 3 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max45Text (pub String);
crate::simple_type!(Max45Text);
impl Validate for Max45Text {
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() > 45 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 45 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max5000Binary (pub String);
crate::simple_type!(Max5000Binary);
impl Validate for Max5000Binary {
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() > 5000 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 5000 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max500Binary (pub String);
crate::simple_type!(Max500Binary);
impl Validate for Max500Binary {
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 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 Max6Text (pub String);
crate::simple_type!(Max6Text);
impl Validate for Max6Text {
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() > 6 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 6 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max70Text (pub String);
crate::simple_type!(Max70Text);
impl Validate for Max70Text {
fn validate(&self) -> Result<(), String> {
#[allow(clippy::len_zero)]
if self.0.len() < 1 {
return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
}
if self.0.len() > 70 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 70 \nActual: 0 length == {}", self.0.len()));
}
Ok(())
}
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max76Text (pub String);
crate::simple_type!(Max76Text);
impl Validate for Max76Text {
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() > 76 {
return Err(format!("MaxLength validation error. \nExpected: 0 length <= 76 \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:caaa.009.001.14")]
pub struct MemoryCharacteristics1 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max35Text,
#[yaserde(rename = "TtlSz")]
#[cfg_attr(feature = "serde", serde(rename = "TtlSz"))]
pub ttl_sz: DecimalNumber,
#[yaserde(rename = "FreeSz")]
#[cfg_attr(feature = "serde", serde(rename = "FreeSz"))]
pub free_sz: DecimalNumber,
#[yaserde(rename = "Unit")]
#[cfg_attr(feature = "serde", serde(rename = "Unit"))]
pub unit: MemoryUnit1Code,
}
impl Validate for MemoryCharacteristics1 {}
#[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:caaa.009.001.14")]
pub enum MemoryUnit1Code {
#[yaserde(rename = "BYTE")]
#[cfg_attr(feature = "serde", serde(rename = "BYTE"))]
Byte,
#[yaserde(rename = "EXAB")]
#[cfg_attr(feature = "serde", serde(rename = "EXAB"))]
Exab,
#[yaserde(rename = "GIGA")]
#[cfg_attr(feature = "serde", serde(rename = "GIGA"))]
Giga,
#[yaserde(rename = "KILO")]
#[cfg_attr(feature = "serde", serde(rename = "KILO"))]
Kilo,
#[yaserde(rename = "MEGA")]
#[cfg_attr(feature = "serde", serde(rename = "MEGA"))]
Mega,
#[yaserde(rename = "PETA")]
#[cfg_attr(feature = "serde", serde(rename = "PETA"))]
Peta,
#[yaserde(rename = "TERA")]
#[cfg_attr(feature = "serde", serde(rename = "TERA"))]
Tera,
__Unknown__(String),
}
impl Default for MemoryUnit1Code {
fn default() -> MemoryUnit1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for MemoryUnit1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct MerchantToken2 {
#[yaserde(rename = "Tkn")]
#[cfg_attr(feature = "serde", serde(rename = "Tkn"))]
pub tkn: Max35Text,
#[yaserde(rename = "TknXpryDt")]
#[cfg_attr(feature = "serde", serde(rename = "TknXpryDt"))]
pub tkn_xpry_dt: Max10Text,
#[yaserde(rename = "TknChrtc")]
#[cfg_attr(feature = "serde", serde(rename = "TknChrtc"))]
pub tkn_chrtc: Vec<Max35Text>,
#[yaserde(rename = "TknRqstr")]
#[cfg_attr(feature = "serde", serde(rename = "TknRqstr"))]
pub tkn_rqstr: PaymentTokenIdentifiers1,
#[yaserde(rename = "TknAssrncLvl")]
#[cfg_attr(feature = "serde", serde(rename = "TknAssrncLvl"))]
pub tkn_assrnc_lvl: Number,
#[yaserde(rename = "TknAssrncData")]
#[cfg_attr(feature = "serde", serde(rename = "TknAssrncData"))]
pub tkn_assrnc_data: Max500Binary,
#[yaserde(rename = "TknAssrncMtd")]
#[cfg_attr(feature = "serde", serde(rename = "TknAssrncMtd"))]
pub tkn_assrnc_mtd: Max2NumericText,
#[yaserde(rename = "TknInittdInd")]
#[cfg_attr(feature = "serde", serde(rename = "TknInittdInd"))]
pub tkn_inittd_ind: TrueFalseIndicator,
}
impl Validate for MerchantToken2 {}
#[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:caaa.009.001.14")]
pub enum MessageFunction46Code {
#[yaserde(rename = "AUTQ")]
#[cfg_attr(feature = "serde", serde(rename = "AUTQ"))]
Autq,
#[yaserde(rename = "AUTP")]
#[cfg_attr(feature = "serde", serde(rename = "AUTP"))]
Autp,
#[yaserde(rename = "CCAV")]
#[cfg_attr(feature = "serde", serde(rename = "CCAV"))]
Ccav,
#[yaserde(rename = "CCAK")]
#[cfg_attr(feature = "serde", serde(rename = "CCAK"))]
Ccak,
#[yaserde(rename = "CCAQ")]
#[cfg_attr(feature = "serde", serde(rename = "CCAQ"))]
Ccaq,
#[yaserde(rename = "CCAP")]
#[cfg_attr(feature = "serde", serde(rename = "CCAP"))]
Ccap,
#[yaserde(rename = "CMPV")]
#[cfg_attr(feature = "serde", serde(rename = "CMPV"))]
Cmpv,
#[yaserde(rename = "CMPK")]
#[cfg_attr(feature = "serde", serde(rename = "CMPK"))]
Cmpk,
#[yaserde(rename = "DCAV")]
#[cfg_attr(feature = "serde", serde(rename = "DCAV"))]
Dcav,
#[yaserde(rename = "DCRR")]
#[cfg_attr(feature = "serde", serde(rename = "DCRR"))]
Dcrr,
#[yaserde(rename = "DCCQ")]
#[cfg_attr(feature = "serde", serde(rename = "DCCQ"))]
Dccq,
#[yaserde(rename = "DCCP")]
#[cfg_attr(feature = "serde", serde(rename = "DCCP"))]
Dccp,
#[yaserde(rename = "DGNP")]
#[cfg_attr(feature = "serde", serde(rename = "DGNP"))]
Dgnp,
#[yaserde(rename = "DGNQ")]
#[cfg_attr(feature = "serde", serde(rename = "DGNQ"))]
Dgnq,
#[yaserde(rename = "FAUQ")]
#[cfg_attr(feature = "serde", serde(rename = "FAUQ"))]
Fauq,
#[yaserde(rename = "FAUP")]
#[cfg_attr(feature = "serde", serde(rename = "FAUP"))]
Faup,
#[yaserde(rename = "FCMV")]
#[cfg_attr(feature = "serde", serde(rename = "FCMV"))]
Fcmv,
#[yaserde(rename = "FCMK")]
#[cfg_attr(feature = "serde", serde(rename = "FCMK"))]
Fcmk,
#[yaserde(rename = "FRVA")]
#[cfg_attr(feature = "serde", serde(rename = "FRVA"))]
Frva,
#[yaserde(rename = "FRVR")]
#[cfg_attr(feature = "serde", serde(rename = "FRVR"))]
Frvr,
#[yaserde(rename = "RCLQ")]
#[cfg_attr(feature = "serde", serde(rename = "RCLQ"))]
Rclq,
#[yaserde(rename = "RCLP")]
#[cfg_attr(feature = "serde", serde(rename = "RCLP"))]
Rclp,
#[yaserde(rename = "RVRA")]
#[cfg_attr(feature = "serde", serde(rename = "RVRA"))]
Rvra,
#[yaserde(rename = "RVRR")]
#[cfg_attr(feature = "serde", serde(rename = "RVRR"))]
Rvrr,
#[yaserde(rename = "CDDQ")]
#[cfg_attr(feature = "serde", serde(rename = "CDDQ"))]
Cddq,
#[yaserde(rename = "CDDK")]
#[cfg_attr(feature = "serde", serde(rename = "CDDK"))]
Cddk,
#[yaserde(rename = "CDDR")]
#[cfg_attr(feature = "serde", serde(rename = "CDDR"))]
Cddr,
#[yaserde(rename = "CDDP")]
#[cfg_attr(feature = "serde", serde(rename = "CDDP"))]
Cddp,
#[yaserde(rename = "TRNR")]
#[cfg_attr(feature = "serde", serde(rename = "TRNR"))]
Trnr,
#[yaserde(rename = "TRNA")]
#[cfg_attr(feature = "serde", serde(rename = "TRNA"))]
Trna,
#[yaserde(rename = "NFRQ")]
#[cfg_attr(feature = "serde", serde(rename = "NFRQ"))]
Nfrq,
#[yaserde(rename = "NFRP")]
#[cfg_attr(feature = "serde", serde(rename = "NFRP"))]
Nfrp,
#[yaserde(rename = "TRPQ")]
#[cfg_attr(feature = "serde", serde(rename = "TRPQ"))]
Trpq,
#[yaserde(rename = "TRPP")]
#[cfg_attr(feature = "serde", serde(rename = "TRPP"))]
Trpp,
#[yaserde(rename = "DCRQ")]
#[cfg_attr(feature = "serde", serde(rename = "DCRQ"))]
Dcrq,
#[yaserde(rename = "DCRP")]
#[cfg_attr(feature = "serde", serde(rename = "DCRP"))]
Dcrp,
__Unknown__(String),
}
impl Default for MessageFunction46Code {
fn default() -> MessageFunction46Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for MessageFunction46Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Min2Max3AlphaText (pub String);
crate::simple_type!(Min2Max3AlphaText);
impl Validate for Min2Max3AlphaText {}
#[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 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:caaa.009.001.14")]
pub struct MobileData6 {
#[yaserde(rename = "MobCtryCd")]
#[cfg_attr(feature = "serde", serde(rename = "MobCtryCd"))]
pub mob_ctry_cd: Min2Max3AlphaText,
#[yaserde(rename = "MobNtwkCd")]
#[cfg_attr(feature = "serde", serde(rename = "MobNtwkCd"))]
pub mob_ntwk_cd: Min2Max3NumericText,
#[yaserde(rename = "MobMskdMSISDN")]
#[cfg_attr(feature = "serde", serde(rename = "MobMskdMSISDN"))]
pub mob_mskd_msisdn: Max35Text,
#[yaserde(rename = "Glctn")]
#[cfg_attr(feature = "serde", serde(rename = "Glctn"))]
pub glctn: Geolocation1,
#[yaserde(rename = "SnstvMobData")]
#[cfg_attr(feature = "serde", serde(rename = "SnstvMobData"))]
pub snstv_mob_data: SensitiveMobileData1,
#[yaserde(rename = "PrtctdMobData")]
#[cfg_attr(feature = "serde", serde(rename = "PrtctdMobData"))]
pub prtctd_mob_data: ContentInformationType40,
}
impl Validate for MobileData6 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct NetworkParameters7 {
#[yaserde(rename = "Adr")]
#[cfg_attr(feature = "serde", serde(rename = "Adr"))]
pub adr: Vec<NetworkParameters9>,
#[yaserde(rename = "UsrNm")]
#[cfg_attr(feature = "serde", serde(rename = "UsrNm"))]
pub usr_nm: Max35Text,
#[yaserde(rename = "AccsCd")]
#[cfg_attr(feature = "serde", serde(rename = "AccsCd"))]
pub accs_cd: Max35Binary,
#[yaserde(rename = "SvrCert")]
#[cfg_attr(feature = "serde", serde(rename = "SvrCert"))]
pub svr_cert: Vec<Max10KBinary>,
#[yaserde(rename = "SvrCertIdr")]
#[cfg_attr(feature = "serde", serde(rename = "SvrCertIdr"))]
pub svr_cert_idr: Vec<Max140Binary>,
#[yaserde(rename = "ClntCert")]
#[cfg_attr(feature = "serde", serde(rename = "ClntCert"))]
pub clnt_cert: Vec<Max10KBinary>,
#[yaserde(rename = "SctyPrfl")]
#[cfg_attr(feature = "serde", serde(rename = "SctyPrfl"))]
pub scty_prfl: Max35Text,
}
impl Validate for NetworkParameters7 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct NetworkParameters9 {
#[yaserde(rename = "NtwkTp")]
#[cfg_attr(feature = "serde", serde(rename = "NtwkTp"))]
pub ntwk_tp: NetworkType1Code,
#[yaserde(rename = "AdrVal")]
#[cfg_attr(feature = "serde", serde(rename = "AdrVal"))]
pub adr_val: Max500Text,
}
impl Validate for NetworkParameters9 {}
#[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:caaa.009.001.14")]
pub enum NetworkType1Code {
#[yaserde(rename = "IPNW")]
#[cfg_attr(feature = "serde", serde(rename = "IPNW"))]
Ipnw,
#[yaserde(rename = "PSTN")]
#[cfg_attr(feature = "serde", serde(rename = "PSTN"))]
Pstn,
__Unknown__(String),
}
impl Default for NetworkType1Code {
fn default() -> NetworkType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for NetworkType1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Number (pub String);
crate::simple_type!(Number);
impl Validate for Number {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
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:caaa.009.001.14")]
pub struct OnLinePIN11 {
#[yaserde(rename = "NcrptdPINBlck")]
#[cfg_attr(feature = "serde", serde(rename = "NcrptdPINBlck"))]
pub ncrptd_pin_blck: ContentInformationType40,
#[yaserde(rename = "PINFrmt")]
#[cfg_attr(feature = "serde", serde(rename = "PINFrmt"))]
pub pin_frmt: Pinformat3Code,
#[yaserde(rename = "AddtlInpt")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlInpt"))]
pub addtl_inpt: Max35Text,
}
impl Validate for OnLinePIN11 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct Organisation45 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: GenericIdentification192,
#[yaserde(rename = "CmonNm")]
#[cfg_attr(feature = "serde", serde(rename = "CmonNm"))]
pub cmon_nm: Max70Text,
#[yaserde(rename = "LctnCtgy")]
#[cfg_attr(feature = "serde", serde(rename = "LctnCtgy"))]
pub lctn_ctgy: LocationCategory4Code,
#[yaserde(rename = "LctnAndCtct")]
#[cfg_attr(feature = "serde", serde(rename = "LctnAndCtct"))]
pub lctn_and_ctct: CommunicationAddress9,
#[yaserde(rename = "SchmeData")]
#[cfg_attr(feature = "serde", serde(rename = "SchmeData"))]
pub schme_data: Max140Text,
}
impl Validate for Organisation45 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct OriginatorInformation1 {
#[yaserde(rename = "Cert")]
#[cfg_attr(feature = "serde", serde(rename = "Cert"))]
pub cert: Vec<Max5000Binary>,
}
impl Validate for OriginatorInformation1 {}
#[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:caaa.009.001.14")]
pub enum OutputFormat1Code {
#[yaserde(rename = "MREF")]
#[cfg_attr(feature = "serde", serde(rename = "MREF"))]
Mref,
#[yaserde(rename = "TEXT")]
#[cfg_attr(feature = "serde", serde(rename = "TEXT"))]
Text,
#[yaserde(rename = "HTML")]
#[cfg_attr(feature = "serde", serde(rename = "HTML"))]
Html,
__Unknown__(String),
}
impl Default for OutputFormat1Code {
fn default() -> OutputFormat1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for OutputFormat1Code {}
#[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:caaa.009.001.14")]
pub enum Pinformat3Code {
#[yaserde(rename = "ISO0")]
#[cfg_attr(feature = "serde", serde(rename = "ISO0"))]
Iso0,
#[yaserde(rename = "ISO1")]
#[cfg_attr(feature = "serde", serde(rename = "ISO1"))]
Iso1,
#[yaserde(rename = "ISO2")]
#[cfg_attr(feature = "serde", serde(rename = "ISO2"))]
Iso2,
#[yaserde(rename = "ISO3")]
#[cfg_attr(feature = "serde", serde(rename = "ISO3"))]
Iso3,
#[yaserde(rename = "ISO4")]
#[cfg_attr(feature = "serde", serde(rename = "ISO4"))]
Iso4,
#[yaserde(rename = "ISO5")]
#[cfg_attr(feature = "serde", serde(rename = "ISO5"))]
Iso5,
__Unknown__(String),
}
impl Default for Pinformat3Code {
fn default() -> Pinformat3Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for Pinformat3Code {}
#[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:caaa.009.001.14")]
pub enum PoicommunicationType2Code {
#[yaserde(rename = "BLTH")]
#[cfg_attr(feature = "serde", serde(rename = "BLTH"))]
Blth,
#[yaserde(rename = "ETHR")]
#[cfg_attr(feature = "serde", serde(rename = "ETHR"))]
Ethr,
#[yaserde(rename = "GPRS")]
#[cfg_attr(feature = "serde", serde(rename = "GPRS"))]
Gprs,
#[yaserde(rename = "GSMF")]
#[cfg_attr(feature = "serde", serde(rename = "GSMF"))]
Gsmf,
#[yaserde(rename = "PSTN")]
#[cfg_attr(feature = "serde", serde(rename = "PSTN"))]
Pstn,
#[yaserde(rename = "RS23")]
#[cfg_attr(feature = "serde", serde(rename = "RS23"))]
Rs23,
#[yaserde(rename = "USBD")]
#[cfg_attr(feature = "serde", serde(rename = "USBD"))]
Usbd,
#[yaserde(rename = "USBH")]
#[cfg_attr(feature = "serde", serde(rename = "USBH"))]
Usbh,
#[yaserde(rename = "WIFI")]
#[cfg_attr(feature = "serde", serde(rename = "WIFI"))]
Wifi,
#[yaserde(rename = "WT2G")]
#[cfg_attr(feature = "serde", serde(rename = "WT2G"))]
Wt2G,
#[yaserde(rename = "WT3G")]
#[cfg_attr(feature = "serde", serde(rename = "WT3G"))]
Wt3G,
#[yaserde(rename = "WT4G")]
#[cfg_attr(feature = "serde", serde(rename = "WT4G"))]
Wt4G,
#[yaserde(rename = "WT5G")]
#[cfg_attr(feature = "serde", serde(rename = "WT5G"))]
Wt5G,
__Unknown__(String),
}
impl Default for PoicommunicationType2Code {
fn default() -> PoicommunicationType2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for PoicommunicationType2Code {}
#[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:caaa.009.001.14")]
pub enum PoicomponentAssessment1Code {
#[yaserde(rename = "APPL")]
#[cfg_attr(feature = "serde", serde(rename = "APPL"))]
Appl,
#[yaserde(rename = "CERT")]
#[cfg_attr(feature = "serde", serde(rename = "CERT"))]
Cert,
#[yaserde(rename = "EVAL")]
#[cfg_attr(feature = "serde", serde(rename = "EVAL"))]
Eval,
__Unknown__(String),
}
impl Default for PoicomponentAssessment1Code {
fn default() -> PoicomponentAssessment1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for PoicomponentAssessment1Code {}
#[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:caaa.009.001.14")]
pub enum PoicomponentStatus1Code {
#[yaserde(rename = "WAIT")]
#[cfg_attr(feature = "serde", serde(rename = "WAIT"))]
Wait,
#[yaserde(rename = "OUTD")]
#[cfg_attr(feature = "serde", serde(rename = "OUTD"))]
Outd,
#[yaserde(rename = "OPER")]
#[cfg_attr(feature = "serde", serde(rename = "OPER"))]
Oper,
#[yaserde(rename = "DACT")]
#[cfg_attr(feature = "serde", serde(rename = "DACT"))]
Dact,
__Unknown__(String),
}
impl Default for PoicomponentStatus1Code {
fn default() -> PoicomponentStatus1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for PoicomponentStatus1Code {}
#[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:caaa.009.001.14")]
pub enum PoicomponentType7Code {
#[yaserde(rename = "AQPP")]
#[cfg_attr(feature = "serde", serde(rename = "AQPP"))]
Aqpp,
#[yaserde(rename = "APPR")]
#[cfg_attr(feature = "serde", serde(rename = "APPR"))]
Appr,
#[yaserde(rename = "TLPR")]
#[cfg_attr(feature = "serde", serde(rename = "TLPR"))]
Tlpr,
#[yaserde(rename = "SCPR")]
#[cfg_attr(feature = "serde", serde(rename = "SCPR"))]
Scpr,
#[yaserde(rename = "SERV")]
#[cfg_attr(feature = "serde", serde(rename = "SERV"))]
Serv,
#[yaserde(rename = "TERM")]
#[cfg_attr(feature = "serde", serde(rename = "TERM"))]
Term,
#[yaserde(rename = "DVCE")]
#[cfg_attr(feature = "serde", serde(rename = "DVCE"))]
Dvce,
#[yaserde(rename = "SECM")]
#[cfg_attr(feature = "serde", serde(rename = "SECM"))]
Secm,
#[yaserde(rename = "APLI")]
#[cfg_attr(feature = "serde", serde(rename = "APLI"))]
Apli,
#[yaserde(rename = "EMVK")]
#[cfg_attr(feature = "serde", serde(rename = "EMVK"))]
Emvk,
#[yaserde(rename = "EMVO")]
#[cfg_attr(feature = "serde", serde(rename = "EMVO"))]
Emvo,
#[yaserde(rename = "MDWR")]
#[cfg_attr(feature = "serde", serde(rename = "MDWR"))]
Mdwr,
#[yaserde(rename = "DRVR")]
#[cfg_attr(feature = "serde", serde(rename = "DRVR"))]
Drvr,
#[yaserde(rename = "OPST")]
#[cfg_attr(feature = "serde", serde(rename = "OPST"))]
Opst,
#[yaserde(rename = "MRPR")]
#[cfg_attr(feature = "serde", serde(rename = "MRPR"))]
Mrpr,
#[yaserde(rename = "CRTF")]
#[cfg_attr(feature = "serde", serde(rename = "CRTF"))]
Crtf,
#[yaserde(rename = "TMSP")]
#[cfg_attr(feature = "serde", serde(rename = "TMSP"))]
Tmsp,
#[yaserde(rename = "SACP")]
#[cfg_attr(feature = "serde", serde(rename = "SACP"))]
Sacp,
#[yaserde(rename = "SAPR")]
#[cfg_attr(feature = "serde", serde(rename = "SAPR"))]
Sapr,
#[yaserde(rename = "LOGF")]
#[cfg_attr(feature = "serde", serde(rename = "LOGF"))]
Logf,
#[yaserde(rename = "MDFL")]
#[cfg_attr(feature = "serde", serde(rename = "MDFL"))]
Mdfl,
#[yaserde(rename = "SOFT")]
#[cfg_attr(feature = "serde", serde(rename = "SOFT"))]
Soft,
#[yaserde(rename = "CONF")]
#[cfg_attr(feature = "serde", serde(rename = "CONF"))]
Conf,
#[yaserde(rename = "RPFL")]
#[cfg_attr(feature = "serde", serde(rename = "RPFL"))]
Rpfl,
#[yaserde(rename = "PROB")]
#[cfg_attr(feature = "serde", serde(rename = "PROB"))]
Prob,
__Unknown__(String),
}
impl Default for PoicomponentType7Code {
fn default() -> PoicomponentType7Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for PoicomponentType7Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct PackageType5 {
#[yaserde(rename = "PackgId")]
#[cfg_attr(feature = "serde", serde(rename = "PackgId"))]
pub packg_id: GenericIdentification176,
#[yaserde(rename = "PackgLngth")]
#[cfg_attr(feature = "serde", serde(rename = "PackgLngth"))]
pub packg_lngth: PositiveNumber,
#[yaserde(rename = "OffsetStart")]
#[cfg_attr(feature = "serde", serde(rename = "OffsetStart"))]
pub offset_start: PositiveNumber,
#[yaserde(rename = "OffsetEnd")]
#[cfg_attr(feature = "serde", serde(rename = "OffsetEnd"))]
pub offset_end: PositiveNumber,
#[yaserde(rename = "PackgBlck")]
#[cfg_attr(feature = "serde", serde(rename = "PackgBlck"))]
pub packg_blck: Vec<ExternallyDefinedData5>,
}
impl Validate for PackageType5 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct Parameter12 {
#[yaserde(rename = "NcrptnFrmt")]
#[cfg_attr(feature = "serde", serde(rename = "NcrptnFrmt"))]
pub ncrptn_frmt: EncryptionFormat2Code,
#[yaserde(rename = "InitlstnVctr")]
#[cfg_attr(feature = "serde", serde(rename = "InitlstnVctr"))]
pub initlstn_vctr: Max500Binary,
#[yaserde(rename = "BPddg")]
#[cfg_attr(feature = "serde", serde(rename = "BPddg"))]
pub b_pddg: BytePadding1Code,
}
impl Validate for Parameter12 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct Parameter16 {
#[yaserde(rename = "DgstAlgo")]
#[cfg_attr(feature = "serde", serde(rename = "DgstAlgo"))]
pub dgst_algo: Algorithm26Code,
#[yaserde(rename = "MskGnrtrAlgo")]
#[cfg_attr(feature = "serde", serde(rename = "MskGnrtrAlgo"))]
pub msk_gnrtr_algo: AlgorithmIdentification34,
#[yaserde(rename = "SaltLngth")]
#[cfg_attr(feature = "serde", serde(rename = "SaltLngth"))]
pub salt_lngth: Number,
#[yaserde(rename = "TrlrFld")]
#[cfg_attr(feature = "serde", serde(rename = "TrlrFld"))]
pub trlr_fld: Number,
#[yaserde(rename = "OIDCrvNm")]
#[cfg_attr(feature = "serde", serde(rename = "OIDCrvNm"))]
pub oid_crv_nm: Max140Text,
}
impl Validate for Parameter16 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct Parameter17 {
#[yaserde(rename = "NcrptnFrmt")]
#[cfg_attr(feature = "serde", serde(rename = "NcrptnFrmt"))]
pub ncrptn_frmt: EncryptionFormat2Code,
#[yaserde(rename = "DgstAlgo")]
#[cfg_attr(feature = "serde", serde(rename = "DgstAlgo"))]
pub dgst_algo: Algorithm26Code,
#[yaserde(rename = "MskGnrtrAlgo")]
#[cfg_attr(feature = "serde", serde(rename = "MskGnrtrAlgo"))]
pub msk_gnrtr_algo: AlgorithmIdentification34,
}
impl Validate for Parameter17 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct Parameter18 {
#[yaserde(rename = "DgstAlgo")]
#[cfg_attr(feature = "serde", serde(rename = "DgstAlgo"))]
pub dgst_algo: Algorithm26Code,
}
impl Validate for Parameter18 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct Parameter7 {
#[yaserde(rename = "InitlstnVctr")]
#[cfg_attr(feature = "serde", serde(rename = "InitlstnVctr"))]
pub initlstn_vctr: Max500Binary,
#[yaserde(rename = "BPddg")]
#[cfg_attr(feature = "serde", serde(rename = "BPddg"))]
pub b_pddg: BytePadding1Code,
}
impl Validate for Parameter7 {}
#[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:caaa.009.001.14")]
pub enum PartyType33Code {
#[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,
#[yaserde(rename = "MTMG")]
#[cfg_attr(feature = "serde", serde(rename = "MTMG"))]
Mtmg,
#[yaserde(rename = "TAXH")]
#[cfg_attr(feature = "serde", serde(rename = "TAXH"))]
Taxh,
#[yaserde(rename = "TMGT")]
#[cfg_attr(feature = "serde", serde(rename = "TMGT"))]
Tmgt,
__Unknown__(String),
}
impl Default for PartyType33Code {
fn default() -> PartyType33Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for PartyType33Code {}
#[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:caaa.009.001.14")]
pub enum PartyType35Code {
#[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,
#[yaserde(rename = "MKTP")]
#[cfg_attr(feature = "serde", serde(rename = "MKTP"))]
Mktp,
#[yaserde(rename = "PFAC")]
#[cfg_attr(feature = "serde", serde(rename = "PFAC"))]
Pfac,
__Unknown__(String),
}
impl Default for PartyType35Code {
fn default() -> PartyType35Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for PartyType35Code {}
#[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:caaa.009.001.14")]
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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub enum PartyType7Code {
#[yaserde(rename = "ACQR")]
#[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
Acqr,
#[yaserde(rename = "ITAG")]
#[cfg_attr(feature = "serde", serde(rename = "ITAG"))]
Itag,
#[yaserde(rename = "PCPT")]
#[cfg_attr(feature = "serde", serde(rename = "PCPT"))]
Pcpt,
#[yaserde(rename = "TMGT")]
#[cfg_attr(feature = "serde", serde(rename = "TMGT"))]
Tmgt,
#[yaserde(rename = "SALE")]
#[cfg_attr(feature = "serde", serde(rename = "SALE"))]
Sale,
__Unknown__(String),
}
impl Default for PartyType7Code {
fn default() -> PartyType7Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for PartyType7Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct PaymentCard35 {
#[yaserde(rename = "PrtctdCardData")]
#[cfg_attr(feature = "serde", serde(rename = "PrtctdCardData"))]
pub prtctd_card_data: ContentInformationType40,
#[yaserde(rename = "PrvtCardData")]
#[cfg_attr(feature = "serde", serde(rename = "PrvtCardData"))]
pub prvt_card_data: Max100KBinary,
#[yaserde(rename = "PlainCardData")]
#[cfg_attr(feature = "serde", serde(rename = "PlainCardData"))]
pub plain_card_data: PlainCardData22,
#[yaserde(rename = "PmtAcctRef")]
#[cfg_attr(feature = "serde", serde(rename = "PmtAcctRef"))]
pub pmt_acct_ref: Max70Text,
#[yaserde(rename = "MskdPAN")]
#[cfg_attr(feature = "serde", serde(rename = "MskdPAN"))]
pub mskd_pan: Max30Text,
#[yaserde(rename = "IssrBIN")]
#[cfg_attr(feature = "serde", serde(rename = "IssrBIN"))]
pub issr_bin: Max15NumericText,
#[yaserde(rename = "CardCtryCd")]
#[cfg_attr(feature = "serde", serde(rename = "CardCtryCd"))]
pub card_ctry_cd: Max3Text,
#[yaserde(rename = "CardCcyCd")]
#[cfg_attr(feature = "serde", serde(rename = "CardCcyCd"))]
pub card_ccy_cd: Exact3AlphaNumericText,
#[yaserde(rename = "CardPdctPrfl")]
#[cfg_attr(feature = "serde", serde(rename = "CardPdctPrfl"))]
pub card_pdct_prfl: Max35Text,
#[yaserde(rename = "CardBrnd")]
#[cfg_attr(feature = "serde", serde(rename = "CardBrnd"))]
pub card_brnd: Max35Text,
#[yaserde(rename = "CardPdctTp")]
#[cfg_attr(feature = "serde", serde(rename = "CardPdctTp"))]
pub card_pdct_tp: CardProductType1Code,
#[yaserde(rename = "CardPdctSubTp")]
#[cfg_attr(feature = "serde", serde(rename = "CardPdctSubTp"))]
pub card_pdct_sub_tp: Max35Text,
#[yaserde(rename = "IntrnlCard")]
#[cfg_attr(feature = "serde", serde(rename = "IntrnlCard"))]
pub intrnl_card: TrueFalseIndicator,
#[yaserde(rename = "AllwdPdct")]
#[cfg_attr(feature = "serde", serde(rename = "AllwdPdct"))]
pub allwd_pdct: Vec<Max70Text>,
#[yaserde(rename = "SvcOptn")]
#[cfg_attr(feature = "serde", serde(rename = "SvcOptn"))]
pub svc_optn: Max35Text,
#[yaserde(rename = "AddtlCardData")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlCardData"))]
pub addtl_card_data: Max70Text,
}
impl Validate for PaymentCard35 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct PaymentTokenIdentifiers1 {
#[yaserde(rename = "PrvdrId")]
#[cfg_attr(feature = "serde", serde(rename = "PrvdrId"))]
pub prvdr_id: Max35Text,
#[yaserde(rename = "RqstrId")]
#[cfg_attr(feature = "serde", serde(rename = "RqstrId"))]
pub rqstr_id: Max35Text,
}
impl Validate for PaymentTokenIdentifiers1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct PersonIdentification15 {
#[yaserde(rename = "DrvrLicNb")]
#[cfg_attr(feature = "serde", serde(rename = "DrvrLicNb"))]
pub drvr_lic_nb: Max35Text,
#[yaserde(rename = "DrvrLicLctn")]
#[cfg_attr(feature = "serde", serde(rename = "DrvrLicLctn"))]
pub drvr_lic_lctn: Max35Text,
#[yaserde(rename = "DrvrLicNm")]
#[cfg_attr(feature = "serde", serde(rename = "DrvrLicNm"))]
pub drvr_lic_nm: Max35Text,
#[yaserde(rename = "DrvrId")]
#[cfg_attr(feature = "serde", serde(rename = "DrvrId"))]
pub drvr_id: Max35Text,
#[yaserde(rename = "CstmrNb")]
#[cfg_attr(feature = "serde", serde(rename = "CstmrNb"))]
pub cstmr_nb: Max35Text,
#[yaserde(rename = "SclSctyNb")]
#[cfg_attr(feature = "serde", serde(rename = "SclSctyNb"))]
pub scl_scty_nb: Max35Text,
#[yaserde(rename = "AlnRegnNb")]
#[cfg_attr(feature = "serde", serde(rename = "AlnRegnNb"))]
pub aln_regn_nb: Max35Text,
#[yaserde(rename = "PsptNb")]
#[cfg_attr(feature = "serde", serde(rename = "PsptNb"))]
pub pspt_nb: Max35Text,
#[yaserde(rename = "TaxIdNb")]
#[cfg_attr(feature = "serde", serde(rename = "TaxIdNb"))]
pub tax_id_nb: Max35Text,
#[yaserde(rename = "IdntyCardNb")]
#[cfg_attr(feature = "serde", serde(rename = "IdntyCardNb"))]
pub idnty_card_nb: Max35Text,
#[yaserde(rename = "MplyrIdNb")]
#[cfg_attr(feature = "serde", serde(rename = "MplyrIdNb"))]
pub mplyr_id_nb: Max35Text,
#[yaserde(rename = "MplyeeIdNb")]
#[cfg_attr(feature = "serde", serde(rename = "MplyeeIdNb"))]
pub mplyee_id_nb: Max35Text,
#[yaserde(rename = "JobNb")]
#[cfg_attr(feature = "serde", serde(rename = "JobNb"))]
pub job_nb: Max35Text,
#[yaserde(rename = "Dept")]
#[cfg_attr(feature = "serde", serde(rename = "Dept"))]
pub dept: Max35Text,
#[yaserde(rename = "EmailAdr")]
#[cfg_attr(feature = "serde", serde(rename = "EmailAdr"))]
pub email_adr: Max256Text,
#[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<GenericIdentification4>,
}
impl Validate for PersonIdentification15 {}
#[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:caaa.009.001.14")]
pub struct PhysicalInterfaceParameter1 {
#[yaserde(rename = "IntrfcNm")]
#[cfg_attr(feature = "serde", serde(rename = "IntrfcNm"))]
pub intrfc_nm: Max35Text,
#[yaserde(rename = "IntrfcTp")]
#[cfg_attr(feature = "serde", serde(rename = "IntrfcTp"))]
pub intrfc_tp: PoicommunicationType2Code,
#[yaserde(rename = "UsrNm")]
#[cfg_attr(feature = "serde", serde(rename = "UsrNm"))]
pub usr_nm: Max35Text,
#[yaserde(rename = "AccsCd")]
#[cfg_attr(feature = "serde", serde(rename = "AccsCd"))]
pub accs_cd: Max35Binary,
#[yaserde(rename = "SctyPrfl")]
#[cfg_attr(feature = "serde", serde(rename = "SctyPrfl"))]
pub scty_prfl: Max35Text,
#[yaserde(rename = "AddtlParams")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlParams"))]
pub addtl_params: Max2KBinary,
}
impl Validate for PhysicalInterfaceParameter1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct PlainCardData17 {
#[yaserde(rename = "PAN")]
#[cfg_attr(feature = "serde", serde(rename = "PAN"))]
pub pan: Min8Max28NumericText,
#[yaserde(rename = "Trck1")]
#[cfg_attr(feature = "serde", serde(rename = "Trck1"))]
pub trck_1: Max76Text,
#[yaserde(rename = "Trck2")]
#[cfg_attr(feature = "serde", serde(rename = "Trck2"))]
pub trck_2: Max37Text,
#[yaserde(rename = "Trck3")]
#[cfg_attr(feature = "serde", serde(rename = "Trck3"))]
pub trck_3: Max104Text,
#[yaserde(rename = "AddtlCardData")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlCardData"))]
pub addtl_card_data: Vec<Max35Text>,
#[yaserde(rename = "NtryMd")]
#[cfg_attr(feature = "serde", serde(rename = "NtryMd"))]
pub ntry_md: CardDataReading5Code,
}
impl Validate for PlainCardData17 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct PlainCardData22 {
#[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: Max10Text,
#[yaserde(rename = "XpryDt")]
#[cfg_attr(feature = "serde", serde(rename = "XpryDt"))]
pub xpry_dt: Max10Text,
#[yaserde(rename = "SvcCd")]
#[cfg_attr(feature = "serde", serde(rename = "SvcCd"))]
pub svc_cd: Exact3NumericText,
#[yaserde(rename = "Trck1")]
#[cfg_attr(feature = "serde", serde(rename = "Trck1"))]
pub trck_1: Max76Text,
#[yaserde(rename = "Trck2")]
#[cfg_attr(feature = "serde", serde(rename = "Trck2"))]
pub trck_2: Max37Text,
#[yaserde(rename = "Trck3")]
#[cfg_attr(feature = "serde", serde(rename = "Trck3"))]
pub trck_3: Max104Text,
#[yaserde(rename = "CrdhldrNm")]
#[cfg_attr(feature = "serde", serde(rename = "CrdhldrNm"))]
pub crdhldr_nm: Max45Text,
}
impl Validate for PlainCardData22 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct PointOfInteraction16 {
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: GenericIdentification177,
#[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: PointOfInteractionCapabilities11,
#[yaserde(rename = "TmZone")]
#[cfg_attr(feature = "serde", serde(rename = "TmZone"))]
pub tm_zone: Max70Text,
#[yaserde(rename = "TermnlIntgtn")]
#[cfg_attr(feature = "serde", serde(rename = "TermnlIntgtn"))]
pub termnl_intgtn: LocationCategory3Code,
#[yaserde(rename = "Cmpnt")]
#[cfg_attr(feature = "serde", serde(rename = "Cmpnt"))]
pub cmpnt: Vec<PointOfInteractionComponent18>,
}
impl Validate for PointOfInteraction16 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct PointOfInteractionCapabilities11 {
#[yaserde(rename = "CardRdngCpblties")]
#[cfg_attr(feature = "serde", serde(rename = "CardRdngCpblties"))]
pub card_rdng_cpblties: Vec<CardDataReading8Code>,
#[yaserde(rename = "CrdhldrVrfctnCpblties")]
#[cfg_attr(feature = "serde", serde(rename = "CrdhldrVrfctnCpblties"))]
pub crdhldr_vrfctn_cpblties: Vec<CardholderVerificationCapability4Code>,
#[yaserde(rename = "PINLngthCpblties")]
#[cfg_attr(feature = "serde", serde(rename = "PINLngthCpblties"))]
pub pin_lngth_cpblties: PositiveNumber,
#[yaserde(rename = "ApprvlCdLngth")]
#[cfg_attr(feature = "serde", serde(rename = "ApprvlCdLngth"))]
pub apprvl_cd_lngth: PositiveNumber,
#[yaserde(rename = "MxScrptLngth")]
#[cfg_attr(feature = "serde", serde(rename = "MxScrptLngth"))]
pub mx_scrpt_lngth: PositiveNumber,
#[yaserde(rename = "CardCaptrCpbl")]
#[cfg_attr(feature = "serde", serde(rename = "CardCaptrCpbl"))]
pub card_captr_cpbl: TrueFalseIndicator,
#[yaserde(rename = "OnLineCpblties")]
#[cfg_attr(feature = "serde", serde(rename = "OnLineCpblties"))]
pub on_line_cpblties: OnLineCapability1Code,
#[yaserde(rename = "MsgCpblties")]
#[cfg_attr(feature = "serde", serde(rename = "MsgCpblties"))]
pub msg_cpblties: Vec<DisplayCapabilities7>,
}
impl Validate for PointOfInteractionCapabilities11 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct PointOfInteractionComponent18 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: PoicomponentType7Code,
#[yaserde(rename = "SubTpInf")]
#[cfg_attr(feature = "serde", serde(rename = "SubTpInf"))]
pub sub_tp_inf: Max70Text,
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: PointOfInteractionComponentIdentification2,
#[yaserde(rename = "Sts")]
#[cfg_attr(feature = "serde", serde(rename = "Sts"))]
pub sts: PointOfInteractionComponentStatus3,
#[yaserde(rename = "StdCmplc")]
#[cfg_attr(feature = "serde", serde(rename = "StdCmplc"))]
pub std_cmplc: Vec<GenericIdentification48>,
#[yaserde(rename = "Chrtcs")]
#[cfg_attr(feature = "serde", serde(rename = "Chrtcs"))]
pub chrtcs: PointOfInteractionComponentCharacteristics11,
#[yaserde(rename = "Assmnt")]
#[cfg_attr(feature = "serde", serde(rename = "Assmnt"))]
pub assmnt: Vec<PointOfInteractionComponentAssessment1>,
#[yaserde(rename = "Packg")]
#[cfg_attr(feature = "serde", serde(rename = "Packg"))]
pub packg: Vec<PackageType5>,
#[yaserde(rename = "PrbVal")]
#[cfg_attr(feature = "serde", serde(rename = "PrbVal"))]
pub prb_val: Max35Binary,
}
impl Validate for PointOfInteractionComponent18 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct PointOfInteractionComponentAssessment1 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: PoicomponentAssessment1Code,
#[yaserde(rename = "Assgnr")]
#[cfg_attr(feature = "serde", serde(rename = "Assgnr"))]
pub assgnr: Vec<Max35Text>,
#[yaserde(rename = "DlvryDt")]
#[cfg_attr(feature = "serde", serde(rename = "DlvryDt"))]
pub dlvry_dt: IsodateTime,
#[yaserde(rename = "XprtnDt")]
#[cfg_attr(feature = "serde", serde(rename = "XprtnDt"))]
pub xprtn_dt: IsodateTime,
#[yaserde(rename = "Nb")]
#[cfg_attr(feature = "serde", serde(rename = "Nb"))]
pub nb: Max35Text,
}
impl Validate for PointOfInteractionComponentAssessment1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct PointOfInteractionComponentCharacteristics11 {
#[yaserde(rename = "Mmry")]
#[cfg_attr(feature = "serde", serde(rename = "Mmry"))]
pub mmry: Vec<MemoryCharacteristics1>,
#[yaserde(rename = "Com")]
#[cfg_attr(feature = "serde", serde(rename = "Com"))]
pub com: Vec<CommunicationCharacteristics5>,
#[yaserde(rename = "SctyAccsMdls")]
#[cfg_attr(feature = "serde", serde(rename = "SctyAccsMdls"))]
pub scty_accs_mdls: Number,
#[yaserde(rename = "SbcbrIdntyMdls")]
#[cfg_attr(feature = "serde", serde(rename = "SbcbrIdntyMdls"))]
pub sbcbr_idnty_mdls: Number,
#[yaserde(rename = "SctyElmt")]
#[cfg_attr(feature = "serde", serde(rename = "SctyElmt"))]
pub scty_elmt: Vec<CryptographicKey19>,
}
impl Validate for PointOfInteractionComponentCharacteristics11 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct PointOfInteractionComponentIdentification2 {
#[yaserde(rename = "ItmNb")]
#[cfg_attr(feature = "serde", serde(rename = "ItmNb"))]
pub itm_nb: Max35Text,
#[yaserde(rename = "PrvdrId")]
#[cfg_attr(feature = "serde", serde(rename = "PrvdrId"))]
pub prvdr_id: Max35Text,
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max256Text,
#[yaserde(rename = "SrlNb")]
#[cfg_attr(feature = "serde", serde(rename = "SrlNb"))]
pub srl_nb: Max256Text,
}
impl Validate for PointOfInteractionComponentIdentification2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct PointOfInteractionComponentStatus3 {
#[yaserde(rename = "VrsnNb")]
#[cfg_attr(feature = "serde", serde(rename = "VrsnNb"))]
pub vrsn_nb: Max256Text,
#[yaserde(rename = "Sts")]
#[cfg_attr(feature = "serde", serde(rename = "Sts"))]
pub sts: PoicomponentStatus1Code,
#[yaserde(rename = "XpryDt")]
#[cfg_attr(feature = "serde", serde(rename = "XpryDt"))]
pub xpry_dt: Isodate,
}
impl Validate for PointOfInteractionComponentStatus3 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct PositiveNumber (pub String);
crate::simple_type!(PositiveNumber);
impl Validate for PositiveNumber {
fn validate(&self) -> Result<(), String> {
if self.0 < "1".parse::<String>().unwrap() {
return Err(format!("MinInclusive validation error: invalid value of 0! \nExpected: 0 >= 1.\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:caaa.009.001.14")]
pub struct PostalAddress22 {
#[yaserde(rename = "AdrTp")]
#[cfg_attr(feature = "serde", serde(rename = "AdrTp"))]
pub adr_tp: AddressType2Code,
#[yaserde(rename = "Dept")]
#[cfg_attr(feature = "serde", serde(rename = "Dept"))]
pub dept: Max70Text,
#[yaserde(rename = "SubDept")]
#[cfg_attr(feature = "serde", serde(rename = "SubDept"))]
pub sub_dept: Max70Text,
#[yaserde(rename = "AdrLine")]
#[cfg_attr(feature = "serde", serde(rename = "AdrLine"))]
pub adr_line: Vec<Max70Text>,
#[yaserde(rename = "StrtNm")]
#[cfg_attr(feature = "serde", serde(rename = "StrtNm"))]
pub strt_nm: Max70Text,
#[yaserde(rename = "BldgNb")]
#[cfg_attr(feature = "serde", serde(rename = "BldgNb"))]
pub bldg_nb: Max16Text,
#[yaserde(rename = "PstCd")]
#[cfg_attr(feature = "serde", serde(rename = "PstCd"))]
pub pst_cd: Max16Text,
#[yaserde(rename = "TwnNm")]
#[cfg_attr(feature = "serde", serde(rename = "TwnNm"))]
pub twn_nm: Max70Text,
#[yaserde(rename = "CtrySubDvsn")]
#[cfg_attr(feature = "serde", serde(rename = "CtrySubDvsn"))]
pub ctry_sub_dvsn: Vec<Max35Text>,
#[yaserde(rename = "CtryCd")]
#[cfg_attr(feature = "serde", serde(rename = "CtryCd"))]
pub ctry_cd: Min2Max3AlphaText,
}
impl Validate for PostalAddress22 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct Recipient13Choice {
#[yaserde(rename = "IssrAndSrlNb")]
#[cfg_attr(feature = "serde", serde(rename = "IssrAndSrlNb"))]
pub issr_and_srl_nb: Option<IssuerAndSerialNumber2>,
#[yaserde(rename = "SbjtKeyIdr")]
#[cfg_attr(feature = "serde", serde(rename = "SbjtKeyIdr"))]
pub sbjt_key_idr: Option<Max140Binary>,
}
impl Validate for Recipient13Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct Recipient15Choice {
#[yaserde(rename = "KeyTrnsprt")]
#[cfg_attr(feature = "serde", serde(rename = "KeyTrnsprt"))]
pub key_trnsprt: Option<KeyTransport10>,
#[yaserde(rename = "KEK")]
#[cfg_attr(feature = "serde", serde(rename = "KEK"))]
pub kek: Option<Kek9>,
#[yaserde(rename = "KeyIdr")]
#[cfg_attr(feature = "serde", serde(rename = "KeyIdr"))]
pub key_idr: Option<Kekidentifier7>,
}
impl Validate for Recipient15Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct RelativeDistinguishedName1 {
#[yaserde(rename = "AttrTp")]
#[cfg_attr(feature = "serde", serde(rename = "AttrTp"))]
pub attr_tp: AttributeType1Code,
#[yaserde(rename = "AttrVal")]
#[cfg_attr(feature = "serde", serde(rename = "AttrVal"))]
pub attr_val: Max140Text,
}
impl Validate for RelativeDistinguishedName1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct RetailerSaleEnvironment2 {
#[yaserde(rename = "SaleCpblties")]
#[cfg_attr(feature = "serde", serde(rename = "SaleCpblties"))]
pub sale_cpblties: Vec<SaleCapabilities1Code>,
#[yaserde(rename = "Ccy")]
#[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
pub ccy: ActiveCurrencyCode,
#[yaserde(rename = "MinAmtToDlvr")]
#[cfg_attr(feature = "serde", serde(rename = "MinAmtToDlvr"))]
pub min_amt_to_dlvr: ImpliedCurrencyAndAmount,
#[yaserde(rename = "MaxCshBckAmt")]
#[cfg_attr(feature = "serde", serde(rename = "MaxCshBckAmt"))]
pub max_csh_bck_amt: ImpliedCurrencyAndAmount,
#[yaserde(rename = "MinSpltAmt")]
#[cfg_attr(feature = "serde", serde(rename = "MinSpltAmt"))]
pub min_splt_amt: ImpliedCurrencyAndAmount,
#[yaserde(rename = "DbtPrefrdFlg")]
#[cfg_attr(feature = "serde", serde(rename = "DbtPrefrdFlg"))]
pub dbt_prefrd_flg: TrueFalseIndicator,
#[yaserde(rename = "LltyHdlg")]
#[cfg_attr(feature = "serde", serde(rename = "LltyHdlg"))]
pub llty_hdlg: LoyaltyHandling1Code,
}
impl Validate for RetailerSaleEnvironment2 {}
#[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:caaa.009.001.14")]
pub enum SaleCapabilities1Code {
#[yaserde(rename = "CHDI")]
#[cfg_attr(feature = "serde", serde(rename = "CHDI"))]
Chdi,
#[yaserde(rename = "CHER")]
#[cfg_attr(feature = "serde", serde(rename = "CHER"))]
Cher,
#[yaserde(rename = "CHIN")]
#[cfg_attr(feature = "serde", serde(rename = "CHIN"))]
Chin,
#[yaserde(rename = "CHST")]
#[cfg_attr(feature = "serde", serde(rename = "CHST"))]
Chst,
#[yaserde(rename = "CUDI")]
#[cfg_attr(feature = "serde", serde(rename = "CUDI"))]
Cudi,
#[yaserde(rename = "CUAS")]
#[cfg_attr(feature = "serde", serde(rename = "CUAS"))]
Cuas,
#[yaserde(rename = "CUER")]
#[cfg_attr(feature = "serde", serde(rename = "CUER"))]
Cuer,
#[yaserde(rename = "CUIN")]
#[cfg_attr(feature = "serde", serde(rename = "CUIN"))]
Cuin,
#[yaserde(rename = "POIR")]
#[cfg_attr(feature = "serde", serde(rename = "POIR"))]
Poir,
#[yaserde(rename = "PRDC")]
#[cfg_attr(feature = "serde", serde(rename = "PRDC"))]
Prdc,
#[yaserde(rename = "PRRP")]
#[cfg_attr(feature = "serde", serde(rename = "PRRP"))]
Prrp,
#[yaserde(rename = "PRVC")]
#[cfg_attr(feature = "serde", serde(rename = "PRVC"))]
Prvc,
__Unknown__(String),
}
impl Default for SaleCapabilities1Code {
fn default() -> SaleCapabilities1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for SaleCapabilities1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct SensitiveMobileData1 {
#[yaserde(rename = "MSISDN")]
#[cfg_attr(feature = "serde", serde(rename = "MSISDN"))]
pub msisdn: Max35NumericText,
#[yaserde(rename = "IMSI")]
#[cfg_attr(feature = "serde", serde(rename = "IMSI"))]
pub imsi: Max35NumericText,
#[yaserde(rename = "IMEI")]
#[cfg_attr(feature = "serde", serde(rename = "IMEI"))]
pub imei: Max35NumericText,
}
impl Validate for SensitiveMobileData1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct SignedData9 {
#[yaserde(rename = "Vrsn")]
#[cfg_attr(feature = "serde", serde(rename = "Vrsn"))]
pub vrsn: Number,
#[yaserde(rename = "DgstAlgo")]
#[cfg_attr(feature = "serde", serde(rename = "DgstAlgo"))]
pub dgst_algo: Vec<AlgorithmIdentification36>,
#[yaserde(rename = "NcpsltdCntt")]
#[cfg_attr(feature = "serde", serde(rename = "NcpsltdCntt"))]
pub ncpsltd_cntt: EncapsulatedContent3,
#[yaserde(rename = "Cert")]
#[cfg_attr(feature = "serde", serde(rename = "Cert"))]
pub cert: Vec<Max5000Binary>,
#[yaserde(rename = "Sgnr")]
#[cfg_attr(feature = "serde", serde(rename = "Sgnr"))]
pub sgnr: Vec<Signer8>,
}
impl Validate for SignedData9 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct Signer8 {
#[yaserde(rename = "Vrsn")]
#[cfg_attr(feature = "serde", serde(rename = "Vrsn"))]
pub vrsn: Number,
#[yaserde(rename = "SgnrId")]
#[cfg_attr(feature = "serde", serde(rename = "SgnrId"))]
pub sgnr_id: Recipient13Choice,
#[yaserde(rename = "DgstAlgo")]
#[cfg_attr(feature = "serde", serde(rename = "DgstAlgo"))]
pub dgst_algo: AlgorithmIdentification36,
#[yaserde(rename = "SgndAttrbts")]
#[cfg_attr(feature = "serde", serde(rename = "SgndAttrbts"))]
pub sgnd_attrbts: Vec<GenericInformation1>,
#[yaserde(rename = "SgntrAlgo")]
#[cfg_attr(feature = "serde", serde(rename = "SgntrAlgo"))]
pub sgntr_algo: AlgorithmIdentification33,
#[yaserde(rename = "Sgntr")]
#[cfg_attr(feature = "serde", serde(rename = "Sgntr"))]
pub sgntr: Max3000Binary,
}
impl Validate for Signer8 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct StoredValueAccount2 {
#[yaserde(rename = "AcctTp")]
#[cfg_attr(feature = "serde", serde(rename = "AcctTp"))]
pub acct_tp: StoredValueAccountType1Code,
#[yaserde(rename = "IdTp")]
#[cfg_attr(feature = "serde", serde(rename = "IdTp"))]
pub id_tp: CardIdentificationType1Code,
#[yaserde(rename = "Id")]
#[cfg_attr(feature = "serde", serde(rename = "Id"))]
pub id: Max35Text,
#[yaserde(rename = "Brnd")]
#[cfg_attr(feature = "serde", serde(rename = "Brnd"))]
pub brnd: Max35Text,
#[yaserde(rename = "Prvdr")]
#[cfg_attr(feature = "serde", serde(rename = "Prvdr"))]
pub prvdr: Max35Text,
#[yaserde(rename = "OwnrNm")]
#[cfg_attr(feature = "serde", serde(rename = "OwnrNm"))]
pub ownr_nm: Max45Text,
#[yaserde(rename = "XpryDt")]
#[cfg_attr(feature = "serde", serde(rename = "XpryDt"))]
pub xpry_dt: Max10Text,
#[yaserde(rename = "NtryMd")]
#[cfg_attr(feature = "serde", serde(rename = "NtryMd"))]
pub ntry_md: CardDataReading8Code,
#[yaserde(rename = "Ccy")]
#[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
pub ccy: ActiveCurrencyCode,
#[yaserde(rename = "Bal")]
#[cfg_attr(feature = "serde", serde(rename = "Bal"))]
pub bal: ImpliedCurrencyAndAmount,
}
impl Validate for StoredValueAccount2 {}
#[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:caaa.009.001.14")]
pub enum StoredValueAccountType1Code {
#[yaserde(rename = "BNKA")]
#[cfg_attr(feature = "serde", serde(rename = "BNKA"))]
Bnka,
#[yaserde(rename = "CWVC")]
#[cfg_attr(feature = "serde", serde(rename = "CWVC"))]
Cwvc,
#[yaserde(rename = "CPYA")]
#[cfg_attr(feature = "serde", serde(rename = "CPYA"))]
Cpya,
#[yaserde(rename = "ELMY")]
#[cfg_attr(feature = "serde", serde(rename = "ELMY"))]
Elmy,
#[yaserde(rename = "GIFT")]
#[cfg_attr(feature = "serde", serde(rename = "GIFT"))]
Gift,
#[yaserde(rename = "GCER")]
#[cfg_attr(feature = "serde", serde(rename = "GCER"))]
Gcer,
#[yaserde(rename = "MLVC")]
#[cfg_attr(feature = "serde", serde(rename = "MLVC"))]
Mlvc,
#[yaserde(rename = "OLVC")]
#[cfg_attr(feature = "serde", serde(rename = "OLVC"))]
Olvc,
#[yaserde(rename = "MERC")]
#[cfg_attr(feature = "serde", serde(rename = "MERC"))]
Merc,
#[yaserde(rename = "OTHR")]
#[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
Othr,
#[yaserde(rename = "PHON")]
#[cfg_attr(feature = "serde", serde(rename = "PHON"))]
Phon,
#[yaserde(rename = "CARD")]
#[cfg_attr(feature = "serde", serde(rename = "CARD"))]
Card,
#[yaserde(rename = "TRVL")]
#[cfg_attr(feature = "serde", serde(rename = "TRVL"))]
Trvl,
__Unknown__(String),
}
impl Default for StoredValueAccountType1Code {
fn default() -> StoredValueAccountType1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for StoredValueAccountType1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct Token1 {
#[yaserde(rename = "PmtTkn")]
#[cfg_attr(feature = "serde", serde(rename = "PmtTkn"))]
pub pmt_tkn: Max19NumericText,
#[yaserde(rename = "TknXpryDt")]
#[cfg_attr(feature = "serde", serde(rename = "TknXpryDt"))]
pub tkn_xpry_dt: Exact4NumericText,
#[yaserde(rename = "TknRqstrId")]
#[cfg_attr(feature = "serde", serde(rename = "TknRqstrId"))]
pub tkn_rqstr_id: Max11NumericText,
#[yaserde(rename = "TknAssrncData")]
#[cfg_attr(feature = "serde", serde(rename = "TknAssrncData"))]
pub tkn_assrnc_data: Max140Text,
#[yaserde(rename = "TknAssrncMtd")]
#[cfg_attr(feature = "serde", serde(rename = "TknAssrncMtd"))]
pub tkn_assrnc_mtd: Max2NumericText,
#[yaserde(rename = "TknInittdInd")]
#[cfg_attr(feature = "serde", serde(rename = "TknInittdInd"))]
pub tkn_inittd_ind: TrueFalseIndicator,
}
impl Validate for Token1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct Traceability8 {
#[yaserde(rename = "RlayId")]
#[cfg_attr(feature = "serde", serde(rename = "RlayId"))]
pub rlay_id: GenericIdentification177,
#[yaserde(rename = "PrtcolNm")]
#[cfg_attr(feature = "serde", serde(rename = "PrtcolNm"))]
pub prtcol_nm: Max35Text,
#[yaserde(rename = "PrtcolVrsn")]
#[cfg_attr(feature = "serde", serde(rename = "PrtcolVrsn"))]
pub prtcol_vrsn: Max6Text,
#[yaserde(rename = "TracDtTmIn")]
#[cfg_attr(feature = "serde", serde(rename = "TracDtTmIn"))]
pub trac_dt_tm_in: IsodateTime,
#[yaserde(rename = "TracDtTmOut")]
#[cfg_attr(feature = "serde", serde(rename = "TracDtTmOut"))]
pub trac_dt_tm_out: IsodateTime,
}
impl Validate for Traceability8 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct TrackData2 {
#[yaserde(rename = "TrckNb")]
#[cfg_attr(feature = "serde", serde(rename = "TrckNb"))]
pub trck_nb: Number,
#[yaserde(rename = "TrckFrmt")]
#[cfg_attr(feature = "serde", serde(rename = "TrckFrmt"))]
pub trck_frmt: TrackFormat1Code,
#[yaserde(rename = "TrckVal")]
#[cfg_attr(feature = "serde", serde(rename = "TrckVal"))]
pub trck_val: Max140Text,
}
impl Validate for TrackData2 {}
#[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:caaa.009.001.14")]
pub enum TrackFormat1Code {
#[yaserde(rename = "AAMV")]
#[cfg_attr(feature = "serde", serde(rename = "AAMV"))]
Aamv,
#[yaserde(rename = "CMC7")]
#[cfg_attr(feature = "serde", serde(rename = "CMC7"))]
Cmc7,
E13B,
#[yaserde(rename = "ISOF")]
#[cfg_attr(feature = "serde", serde(rename = "ISOF"))]
Isof,
#[yaserde(rename = "JIS1")]
#[cfg_attr(feature = "serde", serde(rename = "JIS1"))]
Jis1,
#[yaserde(rename = "JIS2")]
#[cfg_attr(feature = "serde", serde(rename = "JIS2"))]
Jis2,
__Unknown__(String),
}
impl Default for TrackFormat1Code {
fn default() -> TrackFormat1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for TrackFormat1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
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:caaa.009.001.14")]
pub struct TransactionReconciliation5 {
#[yaserde(rename = "ClsPrd")]
#[cfg_attr(feature = "serde", serde(rename = "ClsPrd"))]
pub cls_prd: TrueFalseIndicator,
#[yaserde(rename = "RcncltnTxId")]
#[cfg_attr(feature = "serde", serde(rename = "RcncltnTxId"))]
pub rcncltn_tx_id: TransactionIdentifier1,
#[yaserde(rename = "RcncltnId")]
#[cfg_attr(feature = "serde", serde(rename = "RcncltnId"))]
pub rcncltn_id: Max35Text,
#[yaserde(rename = "TxTtls")]
#[cfg_attr(feature = "serde", serde(rename = "TxTtls"))]
pub tx_ttls: Vec<TransactionTotals12>,
#[yaserde(rename = "AddtlTxData")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlTxData"))]
pub addtl_tx_data: Max70Text,
}
impl Validate for TransactionReconciliation5 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct TransactionTotals12 {
#[yaserde(rename = "POIGrpId")]
#[cfg_attr(feature = "serde", serde(rename = "POIGrpId"))]
pub poi_grp_id: Max35Text,
#[yaserde(rename = "CardBrnd")]
#[cfg_attr(feature = "serde", serde(rename = "CardBrnd"))]
pub card_brnd: Max35Text,
#[yaserde(rename = "CardPdctPrfl")]
#[cfg_attr(feature = "serde", serde(rename = "CardPdctPrfl"))]
pub card_pdct_prfl: Max35Text,
#[yaserde(rename = "Ccy")]
#[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
pub ccy: ActiveCurrencyCode,
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: TypeTransactionTotals2Code,
#[yaserde(rename = "TtlNb")]
#[cfg_attr(feature = "serde", serde(rename = "TtlNb"))]
pub ttl_nb: Number,
#[yaserde(rename = "CmltvAmt")]
#[cfg_attr(feature = "serde", serde(rename = "CmltvAmt"))]
pub cmltv_amt: ImpliedCurrencyAndAmount,
}
impl Validate for TransactionTotals12 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct TransactionVerificationResult4 {
#[yaserde(rename = "Mtd")]
#[cfg_attr(feature = "serde", serde(rename = "Mtd"))]
pub mtd: AuthenticationMethod6Code,
#[yaserde(rename = "VrfctnNtty")]
#[cfg_attr(feature = "serde", serde(rename = "VrfctnNtty"))]
pub vrfctn_ntty: AuthenticationEntity2Code,
#[yaserde(rename = "Rslt")]
#[cfg_attr(feature = "serde", serde(rename = "Rslt"))]
pub rslt: Verification1Code,
#[yaserde(rename = "AddtlRslt")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlRslt"))]
pub addtl_rslt: Max500Text,
}
impl Validate for TransactionVerificationResult4 {}
#[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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub enum TypeTransactionTotals2Code {
#[yaserde(rename = "CRDT")]
#[cfg_attr(feature = "serde", serde(rename = "CRDT"))]
Crdt,
#[yaserde(rename = "CRDR")]
#[cfg_attr(feature = "serde", serde(rename = "CRDR"))]
Crdr,
#[yaserde(rename = "DEBT")]
#[cfg_attr(feature = "serde", serde(rename = "DEBT"))]
Debt,
#[yaserde(rename = "DBTR")]
#[cfg_attr(feature = "serde", serde(rename = "DBTR"))]
Dbtr,
#[yaserde(rename = "DECL")]
#[cfg_attr(feature = "serde", serde(rename = "DECL"))]
Decl,
#[yaserde(rename = "FAIL")]
#[cfg_attr(feature = "serde", serde(rename = "FAIL"))]
Fail,
__Unknown__(String),
}
impl Default for TypeTransactionTotals2Code {
fn default() -> TypeTransactionTotals2Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for TypeTransactionTotals2Code {}
#[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:caaa.009.001.14")]
pub enum UserInterface9Code {
#[yaserde(rename = "CDSP")]
#[cfg_attr(feature = "serde", serde(rename = "CDSP"))]
Cdsp,
#[yaserde(rename = "CRCP")]
#[cfg_attr(feature = "serde", serde(rename = "CRCP"))]
Crcp,
#[yaserde(rename = "MDSP")]
#[cfg_attr(feature = "serde", serde(rename = "MDSP"))]
Mdsp,
#[yaserde(rename = "MRCP")]
#[cfg_attr(feature = "serde", serde(rename = "MRCP"))]
Mrcp,
#[yaserde(rename = "CRDO")]
#[cfg_attr(feature = "serde", serde(rename = "CRDO"))]
Crdo,
#[yaserde(rename = "CSTM")]
#[cfg_attr(feature = "serde", serde(rename = "CSTM"))]
Cstm,
__Unknown__(String),
}
impl Default for UserInterface9Code {
fn default() -> UserInterface9Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for UserInterface9Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct Vehicle1 {
#[yaserde(rename = "VhclNb")]
#[cfg_attr(feature = "serde", serde(rename = "VhclNb"))]
pub vhcl_nb: Max35NumericText,
#[yaserde(rename = "TrlrNb")]
#[cfg_attr(feature = "serde", serde(rename = "TrlrNb"))]
pub trlr_nb: Max35NumericText,
#[yaserde(rename = "VhclTag")]
#[cfg_attr(feature = "serde", serde(rename = "VhclTag"))]
pub vhcl_tag: Max35Text,
#[yaserde(rename = "VhclTagNtryMd")]
#[cfg_attr(feature = "serde", serde(rename = "VhclTagNtryMd"))]
pub vhcl_tag_ntry_md: CardDataReading5Code,
#[yaserde(rename = "UnitNb")]
#[cfg_attr(feature = "serde", serde(rename = "UnitNb"))]
pub unit_nb: Max35NumericText,
#[yaserde(rename = "RplcmntCar")]
#[cfg_attr(feature = "serde", serde(rename = "RplcmntCar"))]
pub rplcmnt_car: TrueFalseIndicator,
#[yaserde(rename = "Odmtr")]
#[cfg_attr(feature = "serde", serde(rename = "Odmtr"))]
pub odmtr: DecimalNumber,
#[yaserde(rename = "Hbmtr")]
#[cfg_attr(feature = "serde", serde(rename = "Hbmtr"))]
pub hbmtr: DecimalNumber,
#[yaserde(rename = "TrlrHrs")]
#[cfg_attr(feature = "serde", serde(rename = "TrlrHrs"))]
pub trlr_hrs: Max35Text,
#[yaserde(rename = "RefrHrs")]
#[cfg_attr(feature = "serde", serde(rename = "RefrHrs"))]
pub refr_hrs: Max35Text,
#[yaserde(rename = "MntncId")]
#[cfg_attr(feature = "serde", serde(rename = "MntncId"))]
pub mntnc_id: Max35Text,
#[yaserde(rename = "DrvrOrVhclCard")]
#[cfg_attr(feature = "serde", serde(rename = "DrvrOrVhclCard"))]
pub drvr_or_vhcl_card: PlainCardData17,
#[yaserde(rename = "AddtlVhclData")]
#[cfg_attr(feature = "serde", serde(rename = "AddtlVhclData"))]
pub addtl_vhcl_data: Vec<Vehicle2>,
}
impl Validate for Vehicle1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14")]
pub struct Vehicle2 {
#[yaserde(rename = "Tp")]
#[cfg_attr(feature = "serde", serde(rename = "Tp"))]
pub tp: Max35Text,
#[yaserde(rename = "NtryMd")]
#[cfg_attr(feature = "serde", serde(rename = "NtryMd"))]
pub ntry_md: CardDataReading5Code,
#[yaserde(rename = "Data")]
#[cfg_attr(feature = "serde", serde(rename = "Data"))]
pub data: Max35Text,
}
impl Validate for Vehicle2 {}
#[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:caaa.009.001.14")]
pub enum Verification1Code {
#[yaserde(rename = "FAIL")]
#[cfg_attr(feature = "serde", serde(rename = "FAIL"))]
Fail,
#[yaserde(rename = "MISS")]
#[cfg_attr(feature = "serde", serde(rename = "MISS"))]
Miss,
#[yaserde(rename = "NOVF")]
#[cfg_attr(feature = "serde", serde(rename = "NOVF"))]
Novf,
#[yaserde(rename = "PART")]
#[cfg_attr(feature = "serde", serde(rename = "PART"))]
Part,
#[yaserde(rename = "SUCC")]
#[cfg_attr(feature = "serde", serde(rename = "SUCC"))]
Succ,
#[yaserde(rename = "ERRR")]
#[cfg_attr(feature = "serde", serde(rename = "ERRR"))]
Errr,
__Unknown__(String),
}
impl Default for Verification1Code {
fn default() -> Verification1Code {
Self::__Unknown__("No valid variants".into())
}
}
impl Validate for Verification1Code {}
impl crate::MxMessage for Document {
const BUSINESS_AREA: crate::BusinessArea = crate::BusinessArea::caaa;
const FUNCTIONALITY: &'static str = "009";
const VARIANT: &'static str = "001";
const VERSION: &'static str = "14";
const MESSAGE_NAME: &'static str = "caaa.009.001.14";
const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:caaa.009.001.14";
}