rust_iso20022 0.1.1

// @generated by src/bin/codegen.rs from the ISO 20022 XSD schema. Do not edit.
#![allow(clippy::all)]
#![allow(non_snake_case, non_camel_case_types, dead_code, unused_imports)]
// yaserde_derive 0.7 emits trait impls inside nested choice submodules, which
// trips the `non_local_definitions` lint on recent rustc. The generated code is
// correct; silence the lint here.
#![allow(non_local_definitions)]
use std::str::FromStr;
use crate::validate::Validate;
use yaserde_derive::{YaDeserialize, YaSerialize};

// pub type Document = 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.025.001.01")]
pub struct AcceptorTransactionLogReportResponseV01 {
    #[yaserde(rename = "Hdr")]
    #[cfg_attr(feature = "serde", serde(rename = "Hdr"))]
    pub hdr: Header59,

    #[yaserde(rename = "RptRspn")]
    #[cfg_attr(feature = "serde", serde(rename = "RptRspn"))]
    pub rpt_rspn: ReportResponse4,

    #[yaserde(rename = "SctyTrlr")]
    #[cfg_attr(feature = "serde", serde(rename = "SctyTrlr"))]
    pub scty_trlr: ContentInformationType27,
}

impl Validate for AcceptorTransactionLogReportResponseV01 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.025.001.01")]
pub struct Action11 {
    #[yaserde(rename = "ActnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ActnTp"))]
    pub actn_tp: ActionType9Code,

    #[yaserde(rename = "MsgToPres")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgToPres"))]
    pub msg_to_pres: ActionMessage8,
}

impl Validate for Action11 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct ActionMessage8 {
    #[yaserde(rename = "MsgDstn")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgDstn"))]
    pub msg_dstn: UserInterface4Code,

    #[yaserde(rename = "InfQlfr")]
    #[cfg_attr(feature = "serde", serde(rename = "InfQlfr"))]
    pub inf_qlfr: InformationQualify1Code,

    #[yaserde(rename = "Frmt")]
    #[cfg_attr(feature = "serde", serde(rename = "Frmt"))]
    pub frmt: OutputFormat3Code,

    #[yaserde(rename = "MsgCntt")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgCntt"))]
    pub msg_cntt: Max20000Text,

    #[yaserde(rename = "MsgCnttSgntr")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgCnttSgntr"))]
    pub msg_cntt_sgntr: ContentInformationType25,

    #[yaserde(rename = "OutptBrcd")]
    #[cfg_attr(feature = "serde", serde(rename = "OutptBrcd"))]
    pub outpt_brcd: OutputBarcode1,

    #[yaserde(rename = "RspnReqrdFlg")]
    #[cfg_attr(feature = "serde", serde(rename = "RspnReqrdFlg"))]
    pub rspn_reqrd_flg: TrueFalseIndicator,

    #[yaserde(rename = "MinDispTm")]
    #[cfg_attr(feature = "serde", serde(rename = "MinDispTm"))]
    pub min_disp_tm: Number,
}

impl Validate for ActionMessage8 {}


#[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.025.001.01")]

pub enum ActionType9Code {
    #[yaserde(rename = "BUSY")]
    #[cfg_attr(feature = "serde", serde(rename = "BUSY"))]
    Busy,
    #[yaserde(rename = "CPTR")]
    #[cfg_attr(feature = "serde", serde(rename = "CPTR"))]
    Cptr,
    #[yaserde(rename = "DISP")]
    #[cfg_attr(feature = "serde", serde(rename = "DISP"))]
    Disp,
    #[yaserde(rename = "NOVR")]
    #[cfg_attr(feature = "serde", serde(rename = "NOVR"))]
    Novr,
    #[yaserde(rename = "RQID")]
    #[cfg_attr(feature = "serde", serde(rename = "RQID"))]
    Rqid,
    #[yaserde(rename = "PINL")]
    #[cfg_attr(feature = "serde", serde(rename = "PINL"))]
    Pinl,
    #[yaserde(rename = "PINR")]
    #[cfg_attr(feature = "serde", serde(rename = "PINR"))]
    Pinr,
    #[yaserde(rename = "PRNT")]
    #[cfg_attr(feature = "serde", serde(rename = "PRNT"))]
    Prnt,
    #[yaserde(rename = "RFRL")]
    #[cfg_attr(feature = "serde", serde(rename = "RFRL"))]
    Rfrl,
    #[yaserde(rename = "RQDT")]
    #[cfg_attr(feature = "serde", serde(rename = "RQDT"))]
    Rqdt,
    #[yaserde(rename = "DCCQ")]
    #[cfg_attr(feature = "serde", serde(rename = "DCCQ"))]
    Dccq,
    #[yaserde(rename = "FLFW")]
    #[cfg_attr(feature = "serde", serde(rename = "FLFW"))]
    Flfw,
    #[yaserde(rename = "PINQ")]
    #[cfg_attr(feature = "serde", serde(rename = "PINQ"))]
    Pinq,
    #[yaserde(rename = "CDCV")]
    #[cfg_attr(feature = "serde", serde(rename = "CDCV"))]
    Cdcv,
    #[yaserde(rename = "CHDA")]
    #[cfg_attr(feature = "serde", serde(rename = "CHDA"))]
    Chda,
    __Unknown__(String),
}

impl Default for ActionType9Code {
    fn default() -> ActionType9Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for ActionType9Code {}



#[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.025.001.01")]

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.025.001.01")]
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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.025.001.01")]
pub struct AggregationTransaction3 {
    #[yaserde(rename = "FrstPmtDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "FrstPmtDtTm"))]
    pub frst_pmt_dt_tm: IsodateTime,

    #[yaserde(rename = "LastPmtDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "LastPmtDtTm"))]
    pub last_pmt_dt_tm: IsodateTime,

    #[yaserde(rename = "NbOfPmts")]
    #[cfg_attr(feature = "serde", serde(rename = "NbOfPmts"))]
    pub nb_of_pmts: Number,

    #[yaserde(rename = "IndvPmt")]
    #[cfg_attr(feature = "serde", serde(rename = "IndvPmt"))]
    pub indv_pmt: Vec<DetailedAmount21>,
}

impl Validate for AggregationTransaction3 {}


#[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.025.001.01")]

pub enum Algorithm11Code {
    #[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,
    __Unknown__(String),
}

impl Default for Algorithm11Code {
    fn default() -> Algorithm11Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for Algorithm11Code {}



#[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.025.001.01")]

pub enum Algorithm16Code {
    #[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,
    __Unknown__(String),
}

impl Default for Algorithm16Code {
    fn default() -> Algorithm16Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for Algorithm16Code {}



#[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.025.001.01")]

pub enum Algorithm17Code {
    #[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,
    __Unknown__(String),
}

impl Default for Algorithm17Code {
    fn default() -> Algorithm17Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for Algorithm17Code {}



#[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.025.001.01")]

pub enum Algorithm24Code {
    #[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,
    __Unknown__(String),
}

impl Default for Algorithm24Code {
    fn default() -> Algorithm24Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for Algorithm24Code {}



#[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.025.001.01")]

pub enum Algorithm25Code {
    #[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,
    __Unknown__(String),
}

impl Default for Algorithm25Code {
    fn default() -> Algorithm25Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for Algorithm25Code {}



#[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.025.001.01")]

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.025.001.01")]

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.025.001.01")]
pub struct AlgorithmIdentification12 {
    #[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: Parameter5,
}

impl Validate for AlgorithmIdentification12 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct AlgorithmIdentification18 {
    #[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: Parameter9,
}

impl Validate for AlgorithmIdentification18 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct AlgorithmIdentification19 {
    #[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: Parameter10,
}

impl Validate for AlgorithmIdentification19 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct AlgorithmIdentification21 {
    #[yaserde(rename = "Algo")]
    #[cfg_attr(feature = "serde", serde(rename = "Algo"))]
    pub algo: Algorithm16Code,
}

impl Validate for AlgorithmIdentification21 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct AlgorithmIdentification22 {
    #[yaserde(rename = "Algo")]
    #[cfg_attr(feature = "serde", serde(rename = "Algo"))]
    pub algo: Algorithm17Code,

    #[yaserde(rename = "Param")]
    #[cfg_attr(feature = "serde", serde(rename = "Param"))]
    pub param: Parameter7,
}

impl Validate for AlgorithmIdentification22 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct AlgorithmIdentification29 {
    #[yaserde(rename = "Algo")]
    #[cfg_attr(feature = "serde", serde(rename = "Algo"))]
    pub algo: Algorithm24Code,

    #[yaserde(rename = "Param")]
    #[cfg_attr(feature = "serde", serde(rename = "Param"))]
    pub param: Parameter12,
}

impl Validate for AlgorithmIdentification29 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct AlgorithmIdentification30 {
    #[yaserde(rename = "Algo")]
    #[cfg_attr(feature = "serde", serde(rename = "Algo"))]
    pub algo: Algorithm25Code,

    #[yaserde(rename = "Param")]
    #[cfg_attr(feature = "serde", serde(rename = "Param"))]
    pub param: Parameter15,
}

impl Validate for AlgorithmIdentification30 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct AmountAndDirection93 {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "Ccy")]
    #[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
    pub ccy: ActiveCurrencyCode,

    #[yaserde(rename = "Sgn")]
    #[cfg_attr(feature = "serde", serde(rename = "Sgn"))]
    pub sgn: PlusOrMinusIndicator,
}

impl Validate for AmountAndDirection93 {}


#[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.025.001.01")]

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(Default, Clone, PartialEq, Debug)]
pub struct AnyBICDec2014Identifier (pub String);
crate::simple_type!(AnyBICDec2014Identifier);

impl Validate for AnyBICDec2014Identifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.025.001.01")]

pub enum AttendanceContext1Code {
    #[yaserde(rename = "ATTD")]
    #[cfg_attr(feature = "serde", serde(rename = "ATTD"))]
    Attd,
    #[yaserde(rename = "SATT")]
    #[cfg_attr(feature = "serde", serde(rename = "SATT"))]
    Satt,
    #[yaserde(rename = "UATT")]
    #[cfg_attr(feature = "serde", serde(rename = "UATT"))]
    Uatt,
    __Unknown__(String),
}

impl Default for AttendanceContext1Code {
    fn default() -> AttendanceContext1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for AttendanceContext1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.025.001.01")]

pub enum AttendanceContext2Code {
    #[yaserde(rename = "ATTL")]
    #[cfg_attr(feature = "serde", serde(rename = "ATTL"))]
    Attl,
    #[yaserde(rename = "CARR")]
    #[cfg_attr(feature = "serde", serde(rename = "CARR"))]
    Carr,
    #[yaserde(rename = "CUST")]
    #[cfg_attr(feature = "serde", serde(rename = "CUST"))]
    Cust,
    #[yaserde(rename = "FULL")]
    #[cfg_attr(feature = "serde", serde(rename = "FULL"))]
    Full,
    #[yaserde(rename = "SELF")]
    #[cfg_attr(feature = "serde", serde(rename = "SELF"))]
    _Self,
    __Unknown__(String),
}

impl Default for AttendanceContext2Code {
    fn default() -> AttendanceContext2Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for AttendanceContext2Code {}



#[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.025.001.01")]

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.025.001.01")]
pub struct AuthenticatedData7 {
    #[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<Recipient10Choice>,

    #[yaserde(rename = "MACAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "MACAlgo"))]
    pub mac_algo: AlgorithmIdentification22,

    #[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 AuthenticatedData7 {}


#[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.025.001.01")]

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.025.001.01")]

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.025.001.01")]

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.025.001.01")]

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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.025.001.01")]
pub struct AuthorisationResult14 {
    #[yaserde(rename = "AuthstnNtty")]
    #[cfg_attr(feature = "serde", serde(rename = "AuthstnNtty"))]
    pub authstn_ntty: GenericIdentification90,

    #[yaserde(rename = "RspnToAuthstn")]
    #[cfg_attr(feature = "serde", serde(rename = "RspnToAuthstn"))]
    pub rspn_to_authstn: ResponseType10,

    #[yaserde(rename = "AuthstnCd")]
    #[cfg_attr(feature = "serde", serde(rename = "AuthstnCd"))]
    pub authstn_cd: Min6Max8Text,

    #[yaserde(rename = "CmpltnReqrd")]
    #[cfg_attr(feature = "serde", serde(rename = "CmpltnReqrd"))]
    pub cmpltn_reqrd: TrueFalseIndicator,

    #[yaserde(rename = "TMSTrggr")]
    #[cfg_attr(feature = "serde", serde(rename = "TMSTrggr"))]
    pub tms_trggr: Tmstrigger1,
}

impl Validate for AuthorisationResult14 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Bbanidentifier (pub String);
crate::simple_type!(Bbanidentifier);

impl Validate for Bbanidentifier {}
#[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.025.001.01")]

pub enum BarcodeType1Code {
    #[yaserde(rename = "COQR")]
    #[cfg_attr(feature = "serde", serde(rename = "COQR"))]
    Coqr,
    C128,
    C025,
    C039,
    #[yaserde(rename = "EA13")]
    #[cfg_attr(feature = "serde", serde(rename = "EA13"))]
    Ea13,
    #[yaserde(rename = "EAN8")]
    #[cfg_attr(feature = "serde", serde(rename = "EAN8"))]
    Ean8,
    P417,
    #[yaserde(rename = "UPCA")]
    #[cfg_attr(feature = "serde", serde(rename = "UPCA"))]
    Upca,
    __Unknown__(String),
}

impl Default for BarcodeType1Code {
    fn default() -> BarcodeType1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for BarcodeType1Code {}



#[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.025.001.01")]

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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.025.001.01")]
pub struct CapturedSignature1 {
    #[yaserde(rename = "ImgFrmt")]
    #[cfg_attr(feature = "serde", serde(rename = "ImgFrmt"))]
    pub img_frmt: Max35Text,

    #[yaserde(rename = "ImgData")]
    #[cfg_attr(feature = "serde", serde(rename = "ImgData"))]
    pub img_data: Max2MBBinary,

    #[yaserde(rename = "ImgRef")]
    #[cfg_attr(feature = "serde", serde(rename = "ImgRef"))]
    pub img_ref: Max500Text,

    #[yaserde(rename = "AddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
    pub addtl_inf: Max140Text,
}

impl Validate for CapturedSignature1 {}


#[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.025.001.01")]

pub enum CardAccountType3Code {
    #[yaserde(rename = "CTDP")]
    #[cfg_attr(feature = "serde", serde(rename = "CTDP"))]
    Ctdp,
    #[yaserde(rename = "CHCK")]
    #[cfg_attr(feature = "serde", serde(rename = "CHCK"))]
    Chck,
    #[yaserde(rename = "CRDT")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDT"))]
    Crdt,
    #[yaserde(rename = "CURR")]
    #[cfg_attr(feature = "serde", serde(rename = "CURR"))]
    Curr,
    #[yaserde(rename = "CDBT")]
    #[cfg_attr(feature = "serde", serde(rename = "CDBT"))]
    Cdbt,
    #[yaserde(rename = "DFLT")]
    #[cfg_attr(feature = "serde", serde(rename = "DFLT"))]
    Dflt,
    #[yaserde(rename = "EPRS")]
    #[cfg_attr(feature = "serde", serde(rename = "EPRS"))]
    Eprs,
    #[yaserde(rename = "HEQL")]
    #[cfg_attr(feature = "serde", serde(rename = "HEQL"))]
    Heql,
    #[yaserde(rename = "ISTL")]
    #[cfg_attr(feature = "serde", serde(rename = "ISTL"))]
    Istl,
    #[yaserde(rename = "INVS")]
    #[cfg_attr(feature = "serde", serde(rename = "INVS"))]
    Invs,
    #[yaserde(rename = "LCDT")]
    #[cfg_attr(feature = "serde", serde(rename = "LCDT"))]
    Lcdt,
    #[yaserde(rename = "MBNW")]
    #[cfg_attr(feature = "serde", serde(rename = "MBNW"))]
    Mbnw,
    #[yaserde(rename = "MNMK")]
    #[cfg_attr(feature = "serde", serde(rename = "MNMK"))]
    Mnmk,
    #[yaserde(rename = "MNMC")]
    #[cfg_attr(feature = "serde", serde(rename = "MNMC"))]
    Mnmc,
    #[yaserde(rename = "MTGL")]
    #[cfg_attr(feature = "serde", serde(rename = "MTGL"))]
    Mtgl,
    #[yaserde(rename = "RTRM")]
    #[cfg_attr(feature = "serde", serde(rename = "RTRM"))]
    Rtrm,
    #[yaserde(rename = "RVLV")]
    #[cfg_attr(feature = "serde", serde(rename = "RVLV"))]
    Rvlv,
    #[yaserde(rename = "SVNG")]
    #[cfg_attr(feature = "serde", serde(rename = "SVNG"))]
    Svng,
    #[yaserde(rename = "STBD")]
    #[cfg_attr(feature = "serde", serde(rename = "STBD"))]
    Stbd,
    #[yaserde(rename = "UVRL")]
    #[cfg_attr(feature = "serde", serde(rename = "UVRL"))]
    Uvrl,
    #[yaserde(rename = "PRPD")]
    #[cfg_attr(feature = "serde", serde(rename = "PRPD"))]
    Prpd,
    #[yaserde(rename = "FLTC")]
    #[cfg_attr(feature = "serde", serde(rename = "FLTC"))]
    Fltc,
    __Unknown__(String),
}

impl Default for CardAccountType3Code {
    fn default() -> CardAccountType3Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for CardAccountType3Code {}



#[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.025.001.01")]

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.025.001.01")]

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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.025.001.01")]
pub struct CardDirectDebit2 {
    #[yaserde(rename = "DbtrId")]
    #[cfg_attr(feature = "serde", serde(rename = "DbtrId"))]
    pub dbtr_id: Debtor4,

    #[yaserde(rename = "CdtrId")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtrId"))]
    pub cdtr_id: Creditor4,

    #[yaserde(rename = "MndtRltdInf")]
    #[cfg_attr(feature = "serde", serde(rename = "MndtRltdInf"))]
    pub mndt_rltd_inf: MandateRelatedInformation13,
}

impl Validate for CardDirectDebit2 {}


#[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.025.001.01")]

pub enum CardFallback1Code {
    #[yaserde(rename = "FFLB")]
    #[cfg_attr(feature = "serde", serde(rename = "FFLB"))]
    Fflb,
    #[yaserde(rename = "SFLB")]
    #[cfg_attr(feature = "serde", serde(rename = "SFLB"))]
    Sflb,
    #[yaserde(rename = "NFLB")]
    #[cfg_attr(feature = "serde", serde(rename = "NFLB"))]
    Nflb,
    __Unknown__(String),
}

impl Default for CardFallback1Code {
    fn default() -> CardFallback1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for CardFallback1Code {}



#[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.025.001.01")]

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.025.001.01")]
pub struct CardPaymentContext28 {
    #[yaserde(rename = "PmtCntxt")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtCntxt"))]
    pub pmt_cntxt: PaymentContext27,

    #[yaserde(rename = "SaleCntxt")]
    #[cfg_attr(feature = "serde", serde(rename = "SaleCntxt"))]
    pub sale_cntxt: SaleContext4,

    #[yaserde(rename = "DrctDbtCntxt")]
    #[cfg_attr(feature = "serde", serde(rename = "DrctDbtCntxt"))]
    pub drct_dbt_cntxt: CardDirectDebit2,
}

impl Validate for CardPaymentContext28 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct CardPaymentEnvironment77 {
    #[yaserde(rename = "Acqrr")]
    #[cfg_attr(feature = "serde", serde(rename = "Acqrr"))]
    pub acqrr: Acquirer10,

    #[yaserde(rename = "Mrchnt")]
    #[cfg_attr(feature = "serde", serde(rename = "Mrchnt"))]
    pub mrchnt: Organisation41,

    #[yaserde(rename = "POI")]
    #[cfg_attr(feature = "serde", serde(rename = "POI"))]
    pub poi: PointOfInteraction11,

    #[yaserde(rename = "Card")]
    #[cfg_attr(feature = "serde", serde(rename = "Card"))]
    pub card: PaymentCard31,

    #[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<LoyaltyAccount2>,

    #[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: MerchantToken1,

    #[yaserde(rename = "Crdhldr")]
    #[cfg_attr(feature = "serde", serde(rename = "Crdhldr"))]
    pub crdhldr: Cardholder17,

    #[yaserde(rename = "PrtctdCrdhldrData")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtctdCrdhldrData"))]
    pub prtctd_crdhldr_data: ContentInformationType28,

    #[yaserde(rename = "SaleEnvt")]
    #[cfg_attr(feature = "serde", serde(rename = "SaleEnvt"))]
    pub sale_envt: RetailerSaleEnvironment2,
}

impl Validate for CardPaymentEnvironment77 {}


#[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.025.001.01")]

pub enum CardPaymentServiceType12Code {
    #[yaserde(rename = "BALC")]
    #[cfg_attr(feature = "serde", serde(rename = "BALC"))]
    Balc,
    #[yaserde(rename = "CACT")]
    #[cfg_attr(feature = "serde", serde(rename = "CACT"))]
    Cact,
    #[yaserde(rename = "CRDP")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDP"))]
    Crdp,
    #[yaserde(rename = "CAFH")]
    #[cfg_attr(feature = "serde", serde(rename = "CAFH"))]
    Cafh,
    #[yaserde(rename = "CAVR")]
    #[cfg_attr(feature = "serde", serde(rename = "CAVR"))]
    Cavr,
    #[yaserde(rename = "CSHW")]
    #[cfg_attr(feature = "serde", serde(rename = "CSHW"))]
    Cshw,
    #[yaserde(rename = "CSHD")]
    #[cfg_attr(feature = "serde", serde(rename = "CSHD"))]
    Cshd,
    #[yaserde(rename = "DEFR")]
    #[cfg_attr(feature = "serde", serde(rename = "DEFR"))]
    Defr,
    #[yaserde(rename = "LOAD")]
    #[cfg_attr(feature = "serde", serde(rename = "LOAD"))]
    Load,
    #[yaserde(rename = "ORCR")]
    #[cfg_attr(feature = "serde", serde(rename = "ORCR"))]
    Orcr,
    #[yaserde(rename = "PINC")]
    #[cfg_attr(feature = "serde", serde(rename = "PINC"))]
    Pinc,
    #[yaserde(rename = "QUCH")]
    #[cfg_attr(feature = "serde", serde(rename = "QUCH"))]
    Quch,
    #[yaserde(rename = "RFND")]
    #[cfg_attr(feature = "serde", serde(rename = "RFND"))]
    Rfnd,
    #[yaserde(rename = "RESA")]
    #[cfg_attr(feature = "serde", serde(rename = "RESA"))]
    Resa,
    #[yaserde(rename = "VALC")]
    #[cfg_attr(feature = "serde", serde(rename = "VALC"))]
    Valc,
    #[yaserde(rename = "UNLD")]
    #[cfg_attr(feature = "serde", serde(rename = "UNLD"))]
    Unld,
    #[yaserde(rename = "CAFT")]
    #[cfg_attr(feature = "serde", serde(rename = "CAFT"))]
    Caft,
    #[yaserde(rename = "CAFL")]
    #[cfg_attr(feature = "serde", serde(rename = "CAFL"))]
    Cafl,
    #[yaserde(rename = "CIDD")]
    #[cfg_attr(feature = "serde", serde(rename = "CIDD"))]
    Cidd,
    __Unknown__(String),
}

impl Default for CardPaymentServiceType12Code {
    fn default() -> CardPaymentServiceType12Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for CardPaymentServiceType12Code {}



#[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.025.001.01")]

pub enum CardPaymentServiceType3Code {
    #[yaserde(rename = "IRES")]
    #[cfg_attr(feature = "serde", serde(rename = "IRES"))]
    Ires,
    #[yaserde(rename = "URES")]
    #[cfg_attr(feature = "serde", serde(rename = "URES"))]
    Ures,
    #[yaserde(rename = "PRES")]
    #[cfg_attr(feature = "serde", serde(rename = "PRES"))]
    Pres,
    #[yaserde(rename = "ARES")]
    #[cfg_attr(feature = "serde", serde(rename = "ARES"))]
    Ares,
    #[yaserde(rename = "FREC")]
    #[cfg_attr(feature = "serde", serde(rename = "FREC"))]
    Frec,
    #[yaserde(rename = "RREC")]
    #[cfg_attr(feature = "serde", serde(rename = "RREC"))]
    Rrec,
    __Unknown__(String),
}

impl Default for CardPaymentServiceType3Code {
    fn default() -> CardPaymentServiceType3Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for CardPaymentServiceType3Code {}



#[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.025.001.01")]

pub enum CardPaymentServiceType5Code {
    #[yaserde(rename = "BALC")]
    #[cfg_attr(feature = "serde", serde(rename = "BALC"))]
    Balc,
    #[yaserde(rename = "CACT")]
    #[cfg_attr(feature = "serde", serde(rename = "CACT"))]
    Cact,
    #[yaserde(rename = "CRDP")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDP"))]
    Crdp,
    #[yaserde(rename = "CAFH")]
    #[cfg_attr(feature = "serde", serde(rename = "CAFH"))]
    Cafh,
    #[yaserde(rename = "CAVR")]
    #[cfg_attr(feature = "serde", serde(rename = "CAVR"))]
    Cavr,
    #[yaserde(rename = "CSHW")]
    #[cfg_attr(feature = "serde", serde(rename = "CSHW"))]
    Cshw,
    #[yaserde(rename = "CSHD")]
    #[cfg_attr(feature = "serde", serde(rename = "CSHD"))]
    Cshd,
    #[yaserde(rename = "DEFR")]
    #[cfg_attr(feature = "serde", serde(rename = "DEFR"))]
    Defr,
    #[yaserde(rename = "LOAD")]
    #[cfg_attr(feature = "serde", serde(rename = "LOAD"))]
    Load,
    #[yaserde(rename = "ORCR")]
    #[cfg_attr(feature = "serde", serde(rename = "ORCR"))]
    Orcr,
    #[yaserde(rename = "PINC")]
    #[cfg_attr(feature = "serde", serde(rename = "PINC"))]
    Pinc,
    #[yaserde(rename = "QUCH")]
    #[cfg_attr(feature = "serde", serde(rename = "QUCH"))]
    Quch,
    #[yaserde(rename = "RFND")]
    #[cfg_attr(feature = "serde", serde(rename = "RFND"))]
    Rfnd,
    #[yaserde(rename = "RESA")]
    #[cfg_attr(feature = "serde", serde(rename = "RESA"))]
    Resa,
    #[yaserde(rename = "VALC")]
    #[cfg_attr(feature = "serde", serde(rename = "VALC"))]
    Valc,
    #[yaserde(rename = "UNLD")]
    #[cfg_attr(feature = "serde", serde(rename = "UNLD"))]
    Unld,
    #[yaserde(rename = "CAFT")]
    #[cfg_attr(feature = "serde", serde(rename = "CAFT"))]
    Caft,
    #[yaserde(rename = "CAFL")]
    #[cfg_attr(feature = "serde", serde(rename = "CAFL"))]
    Cafl,
    __Unknown__(String),
}

impl Default for CardPaymentServiceType5Code {
    fn default() -> CardPaymentServiceType5Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for CardPaymentServiceType5Code {}



#[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.025.001.01")]

pub enum CardPaymentServiceType9Code {
    #[yaserde(rename = "AGGR")]
    #[cfg_attr(feature = "serde", serde(rename = "AGGR"))]
    Aggr,
    #[yaserde(rename = "DCCV")]
    #[cfg_attr(feature = "serde", serde(rename = "DCCV"))]
    Dccv,
    #[yaserde(rename = "GRTT")]
    #[cfg_attr(feature = "serde", serde(rename = "GRTT"))]
    Grtt,
    #[yaserde(rename = "LOYT")]
    #[cfg_attr(feature = "serde", serde(rename = "LOYT"))]
    Loyt,
    #[yaserde(rename = "NRES")]
    #[cfg_attr(feature = "serde", serde(rename = "NRES"))]
    Nres,
    #[yaserde(rename = "PUCO")]
    #[cfg_attr(feature = "serde", serde(rename = "PUCO"))]
    Puco,
    #[yaserde(rename = "RECP")]
    #[cfg_attr(feature = "serde", serde(rename = "RECP"))]
    Recp,
    #[yaserde(rename = "SOAF")]
    #[cfg_attr(feature = "serde", serde(rename = "SOAF"))]
    Soaf,
    #[yaserde(rename = "VCAU")]
    #[cfg_attr(feature = "serde", serde(rename = "VCAU"))]
    Vcau,
    #[yaserde(rename = "INSI")]
    #[cfg_attr(feature = "serde", serde(rename = "INSI"))]
    Insi,
    #[yaserde(rename = "INSA")]
    #[cfg_attr(feature = "serde", serde(rename = "INSA"))]
    Insa,
    #[yaserde(rename = "CSHB")]
    #[cfg_attr(feature = "serde", serde(rename = "CSHB"))]
    Cshb,
    #[yaserde(rename = "INST")]
    #[cfg_attr(feature = "serde", serde(rename = "INST"))]
    Inst,
    #[yaserde(rename = "NRFD")]
    #[cfg_attr(feature = "serde", serde(rename = "NRFD"))]
    Nrfd,
    __Unknown__(String),
}

impl Default for CardPaymentServiceType9Code {
    fn default() -> CardPaymentServiceType9Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for CardPaymentServiceType9Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct CardPaymentToken5 {
    #[yaserde(rename = "Tkn")]
    #[cfg_attr(feature = "serde", serde(rename = "Tkn"))]
    pub tkn: Min8Max28NumericText,

    #[yaserde(rename = "CardSeqNb")]
    #[cfg_attr(feature = "serde", serde(rename = "CardSeqNb"))]
    pub card_seq_nb: Min2Max3NumericText,

    #[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 CardPaymentToken5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct CardPaymentTransaction109 {
    #[yaserde(rename = "AuthstnRslt")]
    #[cfg_attr(feature = "serde", serde(rename = "AuthstnRslt"))]
    pub authstn_rslt: AuthorisationResult14,

    #[yaserde(rename = "TxVrfctnRslt")]
    #[cfg_attr(feature = "serde", serde(rename = "TxVrfctnRslt"))]
    pub tx_vrfctn_rslt: Vec<TransactionVerificationResult4>,

    #[yaserde(rename = "AllwdPdctCd")]
    #[cfg_attr(feature = "serde", serde(rename = "AllwdPdctCd"))]
    pub allwd_pdct_cd: Vec<Product4>,

    #[yaserde(rename = "NotAllwdPdctCd")]
    #[cfg_attr(feature = "serde", serde(rename = "NotAllwdPdctCd"))]
    pub not_allwd_pdct_cd: Vec<Product4>,

    #[yaserde(rename = "AddtlAvlblPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlAvlblPdct"))]
    pub addtl_avlbl_pdct: Vec<Product5>,

    #[yaserde(rename = "Bal")]
    #[cfg_attr(feature = "serde", serde(rename = "Bal"))]
    pub bal: AmountAndDirection93,

    #[yaserde(rename = "PrtctdBal")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtctdBal"))]
    pub prtctd_bal: ContentInformationType28,

    #[yaserde(rename = "Actn")]
    #[cfg_attr(feature = "serde", serde(rename = "Actn"))]
    pub actn: Vec<Action11>,

    #[yaserde(rename = "CcyConvsElgblty")]
    #[cfg_attr(feature = "serde", serde(rename = "CcyConvsElgblty"))]
    pub ccy_convs_elgblty: CurrencyConversion20,
}

impl Validate for CardPaymentTransaction109 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct CardPaymentTransaction110 {
    #[yaserde(rename = "TxCaptr")]
    #[cfg_attr(feature = "serde", serde(rename = "TxCaptr"))]
    pub tx_captr: TrueFalseIndicator,

    #[yaserde(rename = "TxTp")]
    #[cfg_attr(feature = "serde", serde(rename = "TxTp"))]
    pub tx_tp: CardPaymentServiceType5Code,

    #[yaserde(rename = "AddtlSvc")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlSvc"))]
    pub addtl_svc: Vec<CardPaymentServiceType9Code>,

    #[yaserde(rename = "SvcAttr")]
    #[cfg_attr(feature = "serde", serde(rename = "SvcAttr"))]
    pub svc_attr: CardPaymentServiceType3Code,

    #[yaserde(rename = "LastTxFlg")]
    #[cfg_attr(feature = "serde", serde(rename = "LastTxFlg"))]
    pub last_tx_flg: TrueFalseIndicator,

    #[yaserde(rename = "MrchntCtgyCd")]
    #[cfg_attr(feature = "serde", serde(rename = "MrchntCtgyCd"))]
    pub mrchnt_ctgy_cd: Min3Max4Text,

    #[yaserde(rename = "SaleRefId")]
    #[cfg_attr(feature = "serde", serde(rename = "SaleRefId"))]
    pub sale_ref_id: Max35Text,

    #[yaserde(rename = "TxId")]
    #[cfg_attr(feature = "serde", serde(rename = "TxId"))]
    pub tx_id: TransactionIdentifier1,

    #[yaserde(rename = "OrgnlTx")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlTx"))]
    pub orgnl_tx: CardPaymentTransaction112,

    #[yaserde(rename = "RcncltnId")]
    #[cfg_attr(feature = "serde", serde(rename = "RcncltnId"))]
    pub rcncltn_id: Max35Text,

    #[yaserde(rename = "IssrRefData")]
    #[cfg_attr(feature = "serde", serde(rename = "IssrRefData"))]
    pub issr_ref_data: Max140Text,

    #[yaserde(rename = "TxDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "TxDtls"))]
    pub tx_dtls: CardPaymentTransactionDetails49,

    #[yaserde(rename = "MrchntRefData")]
    #[cfg_attr(feature = "serde", serde(rename = "MrchntRefData"))]
    pub mrchnt_ref_data: Max70Text,

    #[yaserde(rename = "CstmrOrdr")]
    #[cfg_attr(feature = "serde", serde(rename = "CstmrOrdr"))]
    pub cstmr_ordr: CustomerOrder1,

    #[yaserde(rename = "CstmrTkn")]
    #[cfg_attr(feature = "serde", serde(rename = "CstmrTkn"))]
    pub cstmr_tkn: CardPaymentToken5,

    #[yaserde(rename = "CstmrCnsnt")]
    #[cfg_attr(feature = "serde", serde(rename = "CstmrCnsnt"))]
    pub cstmr_cnsnt: TrueFalseIndicator,

    #[yaserde(rename = "CardPrgrmmPropsd")]
    #[cfg_attr(feature = "serde", serde(rename = "CardPrgrmmPropsd"))]
    pub card_prgrmm_propsd: Vec<Max35Text>,

    #[yaserde(rename = "CardPrgrmmApld")]
    #[cfg_attr(feature = "serde", serde(rename = "CardPrgrmmApld"))]
    pub card_prgrmm_apld: Max35Text,

    #[yaserde(rename = "SaleToPOIData")]
    #[cfg_attr(feature = "serde", serde(rename = "SaleToPOIData"))]
    pub sale_to_poi_data: Max70Text,

    #[yaserde(rename = "SaleToAcqrrData")]
    #[cfg_attr(feature = "serde", serde(rename = "SaleToAcqrrData"))]
    pub sale_to_acqrr_data: Max70Text,

    #[yaserde(rename = "SaleToIssrData")]
    #[cfg_attr(feature = "serde", serde(rename = "SaleToIssrData"))]
    pub sale_to_issr_data: Max70Text,

    #[yaserde(rename = "AddtlTxData")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlTxData"))]
    pub addtl_tx_data: Vec<Max70Text>,
}

impl Validate for CardPaymentTransaction110 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct CardPaymentTransaction112 {
    #[yaserde(rename = "SaleRefId")]
    #[cfg_attr(feature = "serde", serde(rename = "SaleRefId"))]
    pub sale_ref_id: Max35Text,

    #[yaserde(rename = "TxId")]
    #[cfg_attr(feature = "serde", serde(rename = "TxId"))]
    pub tx_id: TransactionIdentifier1,

    #[yaserde(rename = "POIId")]
    #[cfg_attr(feature = "serde", serde(rename = "POIId"))]
    pub poi_id: GenericIdentification32,

    #[yaserde(rename = "CcyConvs")]
    #[cfg_attr(feature = "serde", serde(rename = "CcyConvs"))]
    pub ccy_convs: CurrencyConversion22,
}

impl Validate for CardPaymentTransaction112 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct CardPaymentTransactionDetails49 {
    #[yaserde(rename = "Ccy")]
    #[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
    pub ccy: ActiveCurrencyCode,

    #[yaserde(rename = "TtlAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlAmt"))]
    pub ttl_amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "CmltvAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "CmltvAmt"))]
    pub cmltv_amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "AmtQlfr")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtQlfr"))]
    pub amt_qlfr: TypeOfAmount8Code,

    #[yaserde(rename = "DtldAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "DtldAmt"))]
    pub dtld_amt: DetailedAmount15,

    #[yaserde(rename = "ReqdAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "ReqdAmt"))]
    pub reqd_amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "AuthrsdAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "AuthrsdAmt"))]
    pub authrsd_amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "InvcAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "InvcAmt"))]
    pub invc_amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "VldtyDt")]
    #[cfg_attr(feature = "serde", serde(rename = "VldtyDt"))]
    pub vldty_dt: Isodate,

    #[yaserde(rename = "OnLineRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "OnLineRsn"))]
    pub on_line_rsn: Vec<OnLineReason1Code>,

    #[yaserde(rename = "UattnddLvlCtgy")]
    #[cfg_attr(feature = "serde", serde(rename = "UattnddLvlCtgy"))]
    pub uattndd_lvl_ctgy: Max35NumericText,

    #[yaserde(rename = "AcctTp")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctTp"))]
    pub acct_tp: CardAccountType3Code,

    #[yaserde(rename = "CcyConvsRslt")]
    #[cfg_attr(feature = "serde", serde(rename = "CcyConvsRslt"))]
    pub ccy_convs_rslt: CurrencyConversion21,

    #[yaserde(rename = "Instlmt")]
    #[cfg_attr(feature = "serde", serde(rename = "Instlmt"))]
    pub instlmt: RecurringTransaction2,

    #[yaserde(rename = "AggtnTx")]
    #[cfg_attr(feature = "serde", serde(rename = "AggtnTx"))]
    pub aggtn_tx: AggregationTransaction3,

    #[yaserde(rename = "PdctCdSetId")]
    #[cfg_attr(feature = "serde", serde(rename = "PdctCdSetId"))]
    pub pdct_cd_set_id: Max10Text,

    #[yaserde(rename = "SaleItm")]
    #[cfg_attr(feature = "serde", serde(rename = "SaleItm"))]
    pub sale_itm: Vec<Product6>,

    #[yaserde(rename = "DlvryLctn")]
    #[cfg_attr(feature = "serde", serde(rename = "DlvryLctn"))]
    pub dlvry_lctn: Max35Text,

    #[yaserde(rename = "AddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
    pub addtl_inf: Vec<ExternallyDefinedData2>,

    #[yaserde(rename = "ICCRltdData")]
    #[cfg_attr(feature = "serde", serde(rename = "ICCRltdData"))]
    pub icc_rltd_data: Max10000Binary,
}

impl Validate for CardPaymentTransactionDetails49 {}


#[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.025.001.01")]

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.025.001.01")]
pub struct Cardholder17 {
    #[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<CardholderAuthentication14>,

    #[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<MobileData3>,
}

impl Validate for Cardholder17 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct CardholderAuthentication14 {
    #[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: ContentInformationType28,

    #[yaserde(rename = "CrdhldrOnLinePIN")]
    #[cfg_attr(feature = "serde", serde(rename = "CrdhldrOnLinePIN"))]
    pub crdhldr_on_line_pin: OnLinePIN8,

    #[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: ExternallyDefinedData2,
}

impl Validate for CardholderAuthentication14 {}


#[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.025.001.01")]

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.025.001.01")]
pub struct CashAccountIdentification7Choice {
    #[yaserde(rename = "IBAN")]
    #[cfg_attr(feature = "serde", serde(rename = "IBAN"))]
    pub iban: Option<Iban2007Identifier>,
    #[yaserde(rename = "BBAN")]
    #[cfg_attr(feature = "serde", serde(rename = "BBAN"))]
    pub bban: Option<Bbanidentifier>,
    #[yaserde(rename = "UPIC")]
    #[cfg_attr(feature = "serde", serde(rename = "UPIC"))]
    pub upic: Option<Upicidentifier>,
    #[yaserde(rename = "DmstAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "DmstAcct"))]
    pub dmst_acct: Option<SimpleIdentificationInformation4>,
}

impl Validate for CashAccountIdentification7Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
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.025.001.01")]
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.025.001.01")]

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.025.001.01")]
pub struct Commission18 {
    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: PercentageRate,

    #[yaserde(rename = "AddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
    pub addtl_inf: Max350Text,
}

impl Validate for Commission18 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct Commission19 {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "AddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
    pub addtl_inf: Max350Text,
}

impl Validate for Commission19 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
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.025.001.01")]
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.025.001.01")]
pub struct ContentInformationType25 {
    #[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: AuthenticatedData7,

    #[yaserde(rename = "SgndData")]
    #[cfg_attr(feature = "serde", serde(rename = "SgndData"))]
    pub sgnd_data: SignedData6,
}

impl Validate for ContentInformationType25 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct ContentInformationType26 {
    #[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: EnvelopedData8,

    #[yaserde(rename = "AuthntcdData")]
    #[cfg_attr(feature = "serde", serde(rename = "AuthntcdData"))]
    pub authntcd_data: AuthenticatedData7,

    #[yaserde(rename = "SgndData")]
    #[cfg_attr(feature = "serde", serde(rename = "SgndData"))]
    pub sgnd_data: SignedData6,

    #[yaserde(rename = "DgstdData")]
    #[cfg_attr(feature = "serde", serde(rename = "DgstdData"))]
    pub dgstd_data: DigestedData5,
}

impl Validate for ContentInformationType26 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct ContentInformationType27 {
    #[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: AuthenticatedData7,
}

impl Validate for ContentInformationType27 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct ContentInformationType28 {
    #[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: EnvelopedData8,
}

impl Validate for ContentInformationType28 {}


#[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.025.001.01")]

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.025.001.01")]
pub struct Creditor4 {
    #[yaserde(rename = "Cdtr")]
    #[cfg_attr(feature = "serde", serde(rename = "Cdtr"))]
    pub cdtr: PartyIdentification178Choice,

    #[yaserde(rename = "RegnId")]
    #[cfg_attr(feature = "serde", serde(rename = "RegnId"))]
    pub regn_id: Max35Text,
}

impl Validate for Creditor4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct CryptographicKey15 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub 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 = "Vrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Vrsn"))]
    pub vrsn: Max256Text,

    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: CryptographicKeyType3Code,

    #[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: ContentInformationType26,

    #[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>,
}

impl Validate for CryptographicKey15 {}


#[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.025.001.01")]

pub enum CryptographicKeyType3Code {
    #[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,
    __Unknown__(String),
}

impl Default for CryptographicKeyType3Code {
    fn default() -> CryptographicKeyType3Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for CryptographicKeyType3Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct CurrencyAndAmountSimpleType (pub String);
crate::simple_type!(CurrencyAndAmountSimpleType);

impl Validate for CurrencyAndAmountSimpleType {
    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.025.001.01")]
pub struct CurrencyAndAmount {
    #[yaserde(text)]
    pub value: String,
    #[yaserde(attribute, rename = "Ccy")]
    #[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
    pub ccy: CurrencyCode,
}

impl Validate for CurrencyAndAmount {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct CurrencyCode (pub String);
crate::simple_type!(CurrencyCode);

impl Validate for CurrencyCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct CurrencyConversion20 {
    #[yaserde(rename = "CcyConvsId")]
    #[cfg_attr(feature = "serde", serde(rename = "CcyConvsId"))]
    pub ccy_convs_id: Max35Text,

    #[yaserde(rename = "TrgtCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "TrgtCcy"))]
    pub trgt_ccy: CurrencyDetails3,

    #[yaserde(rename = "RsltgAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "RsltgAmt"))]
    pub rsltg_amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "XchgRate")]
    #[cfg_attr(feature = "serde", serde(rename = "XchgRate"))]
    pub xchg_rate: PercentageRate,

    #[yaserde(rename = "NvrtdXchgRate")]
    #[cfg_attr(feature = "serde", serde(rename = "NvrtdXchgRate"))]
    pub nvrtd_xchg_rate: PercentageRate,

    #[yaserde(rename = "QtnDt")]
    #[cfg_attr(feature = "serde", serde(rename = "QtnDt"))]
    pub qtn_dt: IsodateTime,

    #[yaserde(rename = "VldUntil")]
    #[cfg_attr(feature = "serde", serde(rename = "VldUntil"))]
    pub vld_until: IsodateTime,

    #[yaserde(rename = "SrcCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "SrcCcy"))]
    pub src_ccy: CurrencyDetails2,

    #[yaserde(rename = "OrgnlAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlAmt"))]
    pub orgnl_amt: OriginalAmountDetails1,

    #[yaserde(rename = "ComssnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "ComssnDtls"))]
    pub comssn_dtls: Vec<Commission19>,

    #[yaserde(rename = "MrkUpDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "MrkUpDtls"))]
    pub mrk_up_dtls: Vec<Commission18>,

    #[yaserde(rename = "DclrtnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "DclrtnDtls"))]
    pub dclrtn_dtls: Vec<ActionMessage8>,
}

impl Validate for CurrencyConversion20 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct CurrencyConversion21 {
    #[yaserde(rename = "AccptdByCrdhldr")]
    #[cfg_attr(feature = "serde", serde(rename = "AccptdByCrdhldr"))]
    pub accptd_by_crdhldr: TrueFalseIndicator,

    #[yaserde(rename = "Convs")]
    #[cfg_attr(feature = "serde", serde(rename = "Convs"))]
    pub convs: CurrencyConversion20,
}

impl Validate for CurrencyConversion21 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct CurrencyConversion22 {
    #[yaserde(rename = "Rslt")]
    #[cfg_attr(feature = "serde", serde(rename = "Rslt"))]
    pub rslt: CurrencyConversionResponse3Code,

    #[yaserde(rename = "RsltRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "RsltRsn"))]
    pub rslt_rsn: Max35Text,

    #[yaserde(rename = "ConvsDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "ConvsDtls"))]
    pub convs_dtls: Vec<CurrencyConversion20>,
}

impl Validate for CurrencyConversion22 {}


#[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.025.001.01")]

pub enum CurrencyConversionResponse3Code {
    #[yaserde(rename = "ODCC")]
    #[cfg_attr(feature = "serde", serde(rename = "ODCC"))]
    Odcc,
    #[yaserde(rename = "DCCA")]
    #[cfg_attr(feature = "serde", serde(rename = "DCCA"))]
    Dcca,
    #[yaserde(rename = "ICRD")]
    #[cfg_attr(feature = "serde", serde(rename = "ICRD"))]
    Icrd,
    #[yaserde(rename = "IMER")]
    #[cfg_attr(feature = "serde", serde(rename = "IMER"))]
    Imer,
    #[yaserde(rename = "IPRD")]
    #[cfg_attr(feature = "serde", serde(rename = "IPRD"))]
    Iprd,
    #[yaserde(rename = "IRAT")]
    #[cfg_attr(feature = "serde", serde(rename = "IRAT"))]
    Irat,
    #[yaserde(rename = "NDCC")]
    #[cfg_attr(feature = "serde", serde(rename = "NDCC"))]
    Ndcc,
    #[yaserde(rename = "REST")]
    #[cfg_attr(feature = "serde", serde(rename = "REST"))]
    Rest,
    #[yaserde(rename = "CATG")]
    #[cfg_attr(feature = "serde", serde(rename = "CATG"))]
    Catg,
    __Unknown__(String),
}

impl Default for CurrencyConversionResponse3Code {
    fn default() -> CurrencyConversionResponse3Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for CurrencyConversionResponse3Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct CurrencyDetails2 {
    #[yaserde(rename = "AlphaCd")]
    #[cfg_attr(feature = "serde", serde(rename = "AlphaCd"))]
    pub alpha_cd: ActiveCurrencyCode,

    #[yaserde(rename = "NmrcCd")]
    #[cfg_attr(feature = "serde", serde(rename = "NmrcCd"))]
    pub nmrc_cd: Exact3NumericText,

    #[yaserde(rename = "Dcml")]
    #[cfg_attr(feature = "serde", serde(rename = "Dcml"))]
    pub dcml: Number,

    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max35Text,
}

impl Validate for CurrencyDetails2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct CurrencyDetails3 {
    #[yaserde(rename = "AlphaCd")]
    #[cfg_attr(feature = "serde", serde(rename = "AlphaCd"))]
    pub alpha_cd: ActiveCurrencyCode,

    #[yaserde(rename = "NmrcCd")]
    #[cfg_attr(feature = "serde", serde(rename = "NmrcCd"))]
    pub nmrc_cd: Exact3NumericText,

    #[yaserde(rename = "Dcml")]
    #[cfg_attr(feature = "serde", serde(rename = "Dcml"))]
    pub dcml: Number,

    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max35Text,
}

impl Validate for CurrencyDetails3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
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.025.001.01")]
pub struct CustomerOrder1 {
    #[yaserde(rename = "CstmrOrdrId")]
    #[cfg_attr(feature = "serde", serde(rename = "CstmrOrdrId"))]
    pub cstmr_ordr_id: Max35Text,

    #[yaserde(rename = "SaleRefId")]
    #[cfg_attr(feature = "serde", serde(rename = "SaleRefId"))]
    pub sale_ref_id: Max35Text,

    #[yaserde(rename = "OpnOrdrStat")]
    #[cfg_attr(feature = "serde", serde(rename = "OpnOrdrStat"))]
    pub opn_ordr_stat: TrueFalseIndicator,

    #[yaserde(rename = "StartDt")]
    #[cfg_attr(feature = "serde", serde(rename = "StartDt"))]
    pub start_dt: IsodateTime,

    #[yaserde(rename = "EndDt")]
    #[cfg_attr(feature = "serde", serde(rename = "EndDt"))]
    pub end_dt: IsodateTime,

    #[yaserde(rename = "Unit")]
    #[cfg_attr(feature = "serde", serde(rename = "Unit"))]
    pub unit: AmountUnit1Code,

    #[yaserde(rename = "FrcstdAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "FrcstdAmt"))]
    pub frcstd_amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "CurAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "CurAmt"))]
    pub cur_amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "Ccy")]
    #[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
    pub ccy: ActiveCurrencyCode,

    #[yaserde(rename = "AccsdBy")]
    #[cfg_attr(feature = "serde", serde(rename = "AccsdBy"))]
    pub accsd_by: Max35Text,

    #[yaserde(rename = "AddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
    pub addtl_inf: Max1025Text,
}

impl Validate for CustomerOrder1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct DateAndPlaceOfBirth1 {
    #[yaserde(rename = "BirthDt")]
    #[cfg_attr(feature = "serde", serde(rename = "BirthDt"))]
    pub birth_dt: Isodate,

    #[yaserde(rename = "PrvcOfBirth")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvcOfBirth"))]
    pub prvc_of_birth: Max35Text,

    #[yaserde(rename = "CityOfBirth")]
    #[cfg_attr(feature = "serde", serde(rename = "CityOfBirth"))]
    pub city_of_birth: Max35Text,

    #[yaserde(rename = "CtryOfBirth")]
    #[cfg_attr(feature = "serde", serde(rename = "CtryOfBirth"))]
    pub ctry_of_birth: CountryCode,
}

impl Validate for DateAndPlaceOfBirth1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.025.001.01")]
pub struct Debtor4 {
    #[yaserde(rename = "Dbtr")]
    #[cfg_attr(feature = "serde", serde(rename = "Dbtr"))]
    pub dbtr: PartyIdentification178Choice,

    #[yaserde(rename = "AcctId")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctId"))]
    pub acct_id: CashAccountIdentification7Choice,
}

impl Validate for Debtor4 {}


#[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.025.001.01")]
pub struct DetailedAmount15 {
    #[yaserde(rename = "AmtGoodsAndSvcs")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtGoodsAndSvcs"))]
    pub amt_goods_and_svcs: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "CshBck")]
    #[cfg_attr(feature = "serde", serde(rename = "CshBck"))]
    pub csh_bck: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "Grtty")]
    #[cfg_attr(feature = "serde", serde(rename = "Grtty"))]
    pub grtty: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "Fees")]
    #[cfg_attr(feature = "serde", serde(rename = "Fees"))]
    pub fees: Vec<DetailedAmount4>,

    #[yaserde(rename = "Rbt")]
    #[cfg_attr(feature = "serde", serde(rename = "Rbt"))]
    pub rbt: Vec<DetailedAmount4>,

    #[yaserde(rename = "ValAddedTax")]
    #[cfg_attr(feature = "serde", serde(rename = "ValAddedTax"))]
    pub val_added_tax: Vec<DetailedAmount4>,

    #[yaserde(rename = "Srchrg")]
    #[cfg_attr(feature = "serde", serde(rename = "Srchrg"))]
    pub srchrg: Vec<DetailedAmount4>,
}

impl Validate for DetailedAmount15 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct DetailedAmount21 {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "DtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "DtTm"))]
    pub dt_tm: IsodateTime,

    #[yaserde(rename = "CardDataNtryMd")]
    #[cfg_attr(feature = "serde", serde(rename = "CardDataNtryMd"))]
    pub card_data_ntry_md: CardDataReading8Code,

    #[yaserde(rename = "ICCRltdData")]
    #[cfg_attr(feature = "serde", serde(rename = "ICCRltdData"))]
    pub icc_rltd_data: Max10000Binary,

    #[yaserde(rename = "Labl")]
    #[cfg_attr(feature = "serde", serde(rename = "Labl"))]
    pub labl: Max140Text,
}

impl Validate for DetailedAmount21 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct DetailedAmount4 {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "Labl")]
    #[cfg_attr(feature = "serde", serde(rename = "Labl"))]
    pub labl: Max140Text,
}

impl Validate for DetailedAmount4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct DigestedData5 {
    #[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: AlgorithmIdentification21,

    #[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 DigestedData5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct DisplayCapabilities4 {
    #[yaserde(rename = "Dstn")]
    #[cfg_attr(feature = "serde", serde(rename = "Dstn"))]
    pub dstn: Vec<UserInterface4Code>,

    #[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 DisplayCapabilities4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct Document {
    #[yaserde(rename = "AccptrTxLgRptRspn")]
    #[cfg_attr(feature = "serde", serde(rename = "AccptrTxLgRptRspn"))]
    pub accptr_tx_lg_rpt_rspn: AcceptorTransactionLogReportResponseV01,
}

impl Validate for Document {}


#[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.025.001.01")]

pub enum DocumentType7Code {
    #[yaserde(rename = "JNRL")]
    #[cfg_attr(feature = "serde", serde(rename = "JNRL"))]
    Jnrl,
    #[yaserde(rename = "CRCP")]
    #[cfg_attr(feature = "serde", serde(rename = "CRCP"))]
    Crcp,
    #[yaserde(rename = "HRCP")]
    #[cfg_attr(feature = "serde", serde(rename = "HRCP"))]
    Hrcp,
    #[yaserde(rename = "SRCP")]
    #[cfg_attr(feature = "serde", serde(rename = "SRCP"))]
    Srcp,
    #[yaserde(rename = "RPIN")]
    #[cfg_attr(feature = "serde", serde(rename = "RPIN"))]
    Rpin,
    #[yaserde(rename = "VCHR")]
    #[cfg_attr(feature = "serde", serde(rename = "VCHR"))]
    Vchr,
    __Unknown__(String),
}

impl Default for DocumentType7Code {
    fn default() -> DocumentType7Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for DocumentType7Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
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.025.001.01")]
pub struct EncryptedContent6 {
    #[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: AlgorithmIdentification29,

    #[yaserde(rename = "NcrptdData")]
    #[cfg_attr(feature = "serde", serde(rename = "NcrptdData"))]
    pub ncrptd_data: Max100KBinary,
}

impl Validate for EncryptedContent6 {}


#[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.025.001.01")]

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.025.001.01")]
pub struct EnvelopedData8 {
    #[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<Recipient10Choice>,

    #[yaserde(rename = "NcrptdCntt")]
    #[cfg_attr(feature = "serde", serde(rename = "NcrptdCntt"))]
    pub ncrptd_cntt: EncryptedContent6,
}

impl Validate for EnvelopedData8 {}


#[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.025.001.01")]

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.025.001.01")]
pub struct ExternallyDefinedData2 {
    #[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: ContentInformationType26,

    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: Max1025Text,
}

impl Validate for ExternallyDefinedData2 {}


#[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.025.001.01")]

pub enum Frequency3Code {
    #[yaserde(rename = "YEAR")]
    #[cfg_attr(feature = "serde", serde(rename = "YEAR"))]
    Year,
    #[yaserde(rename = "MNTH")]
    #[cfg_attr(feature = "serde", serde(rename = "MNTH"))]
    Mnth,
    #[yaserde(rename = "QURT")]
    #[cfg_attr(feature = "serde", serde(rename = "QURT"))]
    Qurt,
    #[yaserde(rename = "MIAN")]
    #[cfg_attr(feature = "serde", serde(rename = "MIAN"))]
    Mian,
    #[yaserde(rename = "WEEK")]
    #[cfg_attr(feature = "serde", serde(rename = "WEEK"))]
    Week,
    #[yaserde(rename = "DAIL")]
    #[cfg_attr(feature = "serde", serde(rename = "DAIL"))]
    Dail,
    #[yaserde(rename = "TEND")]
    #[cfg_attr(feature = "serde", serde(rename = "TEND"))]
    Tend,
    __Unknown__(String),
}

impl Default for Frequency3Code {
    fn default() -> Frequency3Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for Frequency3Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
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.025.001.01")]
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.025.001.01")]
pub struct GenericIdentification32 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: PartyType3Code,

    #[yaserde(rename = "Issr")]
    #[cfg_attr(feature = "serde", serde(rename = "Issr"))]
    pub issr: PartyType4Code,

    #[yaserde(rename = "ShrtNm")]
    #[cfg_attr(feature = "serde", serde(rename = "ShrtNm"))]
    pub shrt_nm: Max35Text,
}

impl Validate for GenericIdentification32 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.025.001.01")]
pub struct GenericIdentification36 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

    #[yaserde(rename = "Issr")]
    #[cfg_attr(feature = "serde", serde(rename = "Issr"))]
    pub issr: Max35Text,

    #[yaserde(rename = "SchmeNm")]
    #[cfg_attr(feature = "serde", serde(rename = "SchmeNm"))]
    pub schme_nm: Max35Text,
}

impl Validate for GenericIdentification36 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.025.001.01")]
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.025.001.01")]
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.025.001.01")]
pub struct GenericIdentification90 {
    #[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: PartyType14Code,

    #[yaserde(rename = "Issr")]
    #[cfg_attr(feature = "serde", serde(rename = "Issr"))]
    pub issr: PartyType4Code,

    #[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 GenericIdentification90 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
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.025.001.01")]
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.025.001.01")]
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.025.001.01")]
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.025.001.01")]
pub struct Header59 {
    #[yaserde(rename = "MsgFctn")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgFctn"))]
    pub msg_fctn: MessageFunction42Code,

    #[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 Header59 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Iban2007Identifier (pub String);
crate::simple_type!(Iban2007Identifier);

impl Validate for Iban2007Identifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Iso3NumericCountryCode (pub String);
crate::simple_type!(Iso3NumericCountryCode);

impl Validate for Iso3NumericCountryCode {}
#[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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.025.001.01")]

pub enum InformationQualify1Code {
    #[yaserde(rename = "CUSA")]
    #[cfg_attr(feature = "serde", serde(rename = "CUSA"))]
    Cusa,
    #[yaserde(rename = "DISP")]
    #[cfg_attr(feature = "serde", serde(rename = "DISP"))]
    Disp,
    #[yaserde(rename = "DOCT")]
    #[cfg_attr(feature = "serde", serde(rename = "DOCT"))]
    Doct,
    #[yaserde(rename = "ERRO")]
    #[cfg_attr(feature = "serde", serde(rename = "ERRO"))]
    Erro,
    #[yaserde(rename = "INPT")]
    #[cfg_attr(feature = "serde", serde(rename = "INPT"))]
    Inpt,
    #[yaserde(rename = "POIR")]
    #[cfg_attr(feature = "serde", serde(rename = "POIR"))]
    Poir,
    #[yaserde(rename = "RCPT")]
    #[cfg_attr(feature = "serde", serde(rename = "RCPT"))]
    Rcpt,
    #[yaserde(rename = "SOND")]
    #[cfg_attr(feature = "serde", serde(rename = "SOND"))]
    Sond,
    #[yaserde(rename = "STAT")]
    #[cfg_attr(feature = "serde", serde(rename = "STAT"))]
    Stat,
    #[yaserde(rename = "VCHR")]
    #[cfg_attr(feature = "serde", serde(rename = "VCHR"))]
    Vchr,
    __Unknown__(String),
}

impl Default for InformationQualify1Code {
    fn default() -> InformationQualify1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for InformationQualify1Code {}



#[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.025.001.01")]

pub enum InstalmentPlan1Code {
    #[yaserde(rename = "EQPM")]
    #[cfg_attr(feature = "serde", serde(rename = "EQPM"))]
    Eqpm,
    #[yaserde(rename = "NQPM")]
    #[cfg_attr(feature = "serde", serde(rename = "NQPM"))]
    Nqpm,
    #[yaserde(rename = "DFRI")]
    #[cfg_attr(feature = "serde", serde(rename = "DFRI"))]
    Dfri,
    __Unknown__(String),
}

impl Default for InstalmentPlan1Code {
    fn default() -> InstalmentPlan1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for InstalmentPlan1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
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.025.001.01")]
pub struct Kek7 {
    #[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: Kekidentifier2,

    #[yaserde(rename = "KeyNcrptnAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyNcrptnAlgo"))]
    pub key_ncrptn_algo: AlgorithmIdentification29,

    #[yaserde(rename = "NcrptdKey")]
    #[cfg_attr(feature = "serde", serde(rename = "NcrptdKey"))]
    pub ncrptd_key: Max500Binary,
}

impl Validate for Kek7 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct Kekidentifier2 {
    #[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: Min5Max16Binary,
}

impl Validate for Kekidentifier2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct KeyTransport7 {
    #[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: Recipient9Choice,

    #[yaserde(rename = "KeyNcrptnAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyNcrptnAlgo"))]
    pub key_ncrptn_algo: AlgorithmIdentification19,

    #[yaserde(rename = "NcrptdKey")]
    #[cfg_attr(feature = "serde", serde(rename = "NcrptdKey"))]
    pub ncrptd_key: Max5000Binary,
}

impl Validate for KeyTransport7 {}


#[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.025.001.01")]

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.025.001.01")]

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.025.001.01")]

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.025.001.01")]
pub struct LoyaltyAccount2 {
    #[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 LoyaltyAccount2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct LoyaltyAmount1 {
    #[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 = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: ImpliedCurrencyAndAmount,
}

impl Validate for LoyaltyAmount1 {}


#[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.025.001.01")]

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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.025.001.01")]
pub struct LoyaltyRebates1 {
    #[yaserde(rename = "TtlRbt")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlRbt"))]
    pub ttl_rbt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "RbtLabl")]
    #[cfg_attr(feature = "serde", serde(rename = "RbtLabl"))]
    pub rbt_labl: Max35Text,

    #[yaserde(rename = "SaleItmRbt")]
    #[cfg_attr(feature = "serde", serde(rename = "SaleItmRbt"))]
    pub sale_itm_rbt: Vec<SaleItemRebate1>,
}

impl Validate for LoyaltyRebates1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct LoyaltyResult2 {
    #[yaserde(rename = "Acct")]
    #[cfg_attr(feature = "serde", serde(rename = "Acct"))]
    pub acct: LoyaltyAccount2,

    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: LoyaltyAmount1,

    #[yaserde(rename = "SvrData")]
    #[cfg_attr(feature = "serde", serde(rename = "SvrData"))]
    pub svr_data: LoyaltyServerData1,

    #[yaserde(rename = "Rbts")]
    #[cfg_attr(feature = "serde", serde(rename = "Rbts"))]
    pub rbts: LoyaltyRebates1,
}

impl Validate for LoyaltyResult2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct LoyaltyServerData1 {
    #[yaserde(rename = "LltySvrId")]
    #[cfg_attr(feature = "serde", serde(rename = "LltySvrId"))]
    pub llty_svr_id: Max35Text,

    #[yaserde(rename = "ApprvlCd")]
    #[cfg_attr(feature = "serde", serde(rename = "ApprvlCd"))]
    pub apprvl_cd: Min6Max8Text,

    #[yaserde(rename = "LltyTxId")]
    #[cfg_attr(feature = "serde", serde(rename = "LltyTxId"))]
    pub llty_tx_id: TransactionIdentifier1,

    #[yaserde(rename = "HstRcncltnId")]
    #[cfg_attr(feature = "serde", serde(rename = "HstRcncltnId"))]
    pub hst_rcncltn_id: Max35Text,
}

impl Validate for LoyaltyServerData1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct LoyaltyTransactionTotals1 {
    #[yaserde(rename = "POIGrpId")]
    #[cfg_attr(feature = "serde", serde(rename = "POIGrpId"))]
    pub poi_grp_id: Max35Text,

    #[yaserde(rename = "LltyUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "LltyUnit"))]
    pub llty_unit: AmountUnit1Code,

    #[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 = "TxTp")]
    #[cfg_attr(feature = "serde", serde(rename = "TxTp"))]
    pub tx_tp: LoyaltyTypeTransactionTotals1Code,

    #[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,

    #[yaserde(rename = "DtldAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "DtldAmt"))]
    pub dtld_amt: DetailedAmount15,
}

impl Validate for LoyaltyTransactionTotals1 {}


#[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.025.001.01")]

pub enum LoyaltyTypeTransactionTotals1Code {
    #[yaserde(rename = "AWRD")]
    #[cfg_attr(feature = "serde", serde(rename = "AWRD"))]
    Awrd,
    #[yaserde(rename = "REBA")]
    #[cfg_attr(feature = "serde", serde(rename = "REBA"))]
    Reba,
    #[yaserde(rename = "REDE")]
    #[cfg_attr(feature = "serde", serde(rename = "REDE"))]
    Rede,
    #[yaserde(rename = "AWRR")]
    #[cfg_attr(feature = "serde", serde(rename = "AWRR"))]
    Awrr,
    #[yaserde(rename = "REBR")]
    #[cfg_attr(feature = "serde", serde(rename = "REBR"))]
    Rebr,
    #[yaserde(rename = "REDR")]
    #[cfg_attr(feature = "serde", serde(rename = "REDR"))]
    Redr,
    __Unknown__(String),
}

impl Default for LoyaltyTypeTransactionTotals1Code {
    fn default() -> LoyaltyTypeTransactionTotals1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for LoyaltyTypeTransactionTotals1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct MandateRelatedInformation13 {
    #[yaserde(rename = "MndtId")]
    #[cfg_attr(feature = "serde", serde(rename = "MndtId"))]
    pub mndt_id: Max35Text,

    #[yaserde(rename = "DtOfSgntr")]
    #[cfg_attr(feature = "serde", serde(rename = "DtOfSgntr"))]
    pub dt_of_sgntr: Isodate,

    #[yaserde(rename = "MndtImg")]
    #[cfg_attr(feature = "serde", serde(rename = "MndtImg"))]
    pub mndt_img: Max2MBBinary,
}

impl Validate for MandateRelatedInformation13 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max10000Binary (pub String);
crate::simple_type!(Max10000Binary);

impl Validate for Max10000Binary {
    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() > 10000 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 10000 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[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 Max20000Text (pub String);
crate::simple_type!(Max20000Text);

impl Validate for Max20000Text {
    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() > 20000 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 20000 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max256Text (pub String);
crate::simple_type!(Max256Text);

impl Validate for Max256Text {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 256 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 256 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct 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 Max2MBBinary (pub String);
crate::simple_type!(Max2MBBinary);

impl Validate for Max2MBBinary {
    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() > 2097152 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 2097152 \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)]
pub struct Max8000Text (pub String);
crate::simple_type!(Max8000Text);

impl Validate for Max8000Text {
    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() > 8000 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 8000 \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.025.001.01")]
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.025.001.01")]

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.025.001.01")]
pub struct MerchantToken1 {
    #[yaserde(rename = "Tkn")]
    #[cfg_attr(feature = "serde", serde(rename = "Tkn"))]
    pub tkn: Min8Max28NumericText,

    #[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 MerchantToken1 {}


#[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.025.001.01")]

pub enum MessageFunction42Code {
    #[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,
    __Unknown__(String),
}

impl Default for MessageFunction42Code {
    fn default() -> MessageFunction42Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for MessageFunction42Code {}



#[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 Min3Max4Text (pub String);
crate::simple_type!(Min3Max4Text);

impl Validate for Min3Max4Text {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 3 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 3 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 4 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 4 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Min5Max16Binary (pub String);
crate::simple_type!(Min5Max16Binary);

impl Validate for Min5Max16Binary {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 5 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 5 \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 Min6Max8Text (pub String);
crate::simple_type!(Min6Max8Text);

impl Validate for Min6Max8Text {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 6 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 6 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 8 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 8 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[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.025.001.01")]
pub struct MobileData3 {
    #[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: ContentInformationType28,
}

impl Validate for MobileData3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct NameAndAddress6 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max70Text,

    #[yaserde(rename = "Adr")]
    #[cfg_attr(feature = "serde", serde(rename = "Adr"))]
    pub adr: PostalAddress2,
}

impl Validate for NameAndAddress6 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
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.025.001.01")]
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.025.001.01")]

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.025.001.01")]

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.025.001.01")]
pub struct OnLinePIN8 {
    #[yaserde(rename = "NcrptdPINBlck")]
    #[cfg_attr(feature = "serde", serde(rename = "NcrptdPINBlck"))]
    pub ncrptd_pin_blck: ContentInformationType28,

    #[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 OnLinePIN8 {}


#[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.025.001.01")]

pub enum OnLineReason1Code {
    #[yaserde(rename = "RNDM")]
    #[cfg_attr(feature = "serde", serde(rename = "RNDM"))]
    Rndm,
    #[yaserde(rename = "ICCF")]
    #[cfg_attr(feature = "serde", serde(rename = "ICCF"))]
    Iccf,
    #[yaserde(rename = "MERF")]
    #[cfg_attr(feature = "serde", serde(rename = "MERF"))]
    Merf,
    #[yaserde(rename = "TRMF")]
    #[cfg_attr(feature = "serde", serde(rename = "TRMF"))]
    Trmf,
    #[yaserde(rename = "ISSF")]
    #[cfg_attr(feature = "serde", serde(rename = "ISSF"))]
    Issf,
    #[yaserde(rename = "FRLT")]
    #[cfg_attr(feature = "serde", serde(rename = "FRLT"))]
    Frlt,
    #[yaserde(rename = "EXFL")]
    #[cfg_attr(feature = "serde", serde(rename = "EXFL"))]
    Exfl,
    #[yaserde(rename = "TAMT")]
    #[cfg_attr(feature = "serde", serde(rename = "TAMT"))]
    Tamt,
    #[yaserde(rename = "CBIN")]
    #[cfg_attr(feature = "serde", serde(rename = "CBIN"))]
    Cbin,
    #[yaserde(rename = "UBIN")]
    #[cfg_attr(feature = "serde", serde(rename = "UBIN"))]
    Ubin,
    #[yaserde(rename = "CPAN")]
    #[cfg_attr(feature = "serde", serde(rename = "CPAN"))]
    Cpan,
    #[yaserde(rename = "FLOW")]
    #[cfg_attr(feature = "serde", serde(rename = "FLOW"))]
    Flow,
    #[yaserde(rename = "CRCY")]
    #[cfg_attr(feature = "serde", serde(rename = "CRCY"))]
    Crcy,
    __Unknown__(String),
}

impl Default for OnLineReason1Code {
    fn default() -> OnLineReason1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for OnLineReason1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct Organisation26 {
    #[yaserde(rename = "CmonNm")]
    #[cfg_attr(feature = "serde", serde(rename = "CmonNm"))]
    pub cmon_nm: Max70Text,

    #[yaserde(rename = "Adr")]
    #[cfg_attr(feature = "serde", serde(rename = "Adr"))]
    pub adr: Max140Text,

    #[yaserde(rename = "CtryCd")]
    #[cfg_attr(feature = "serde", serde(rename = "CtryCd"))]
    pub ctry_cd: Iso3NumericCountryCode,

    #[yaserde(rename = "MrchntCtgyCd")]
    #[cfg_attr(feature = "serde", serde(rename = "MrchntCtgyCd"))]
    pub mrchnt_ctgy_cd: Min3Max4Text,

    #[yaserde(rename = "RegdIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "RegdIdr"))]
    pub regd_idr: Max35Text,
}

impl Validate for Organisation26 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct Organisation41 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: GenericIdentification32,

    #[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 Organisation41 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct OriginalAmountDetails1 {
    #[yaserde(rename = "ActlAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "ActlAmt"))]
    pub actl_amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "MinAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "MinAmt"))]
    pub min_amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "MaxAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "MaxAmt"))]
    pub max_amt: ImpliedCurrencyAndAmount,
}

impl Validate for OriginalAmountDetails1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.025.001.01")]
pub struct OutputBarcode1 {
    #[yaserde(rename = "BrcdTp")]
    #[cfg_attr(feature = "serde", serde(rename = "BrcdTp"))]
    pub brcd_tp: BarcodeType1Code,

    #[yaserde(rename = "BrcdVal")]
    #[cfg_attr(feature = "serde", serde(rename = "BrcdVal"))]
    pub brcd_val: Max8000Text,

    #[yaserde(rename = "QRCdBinryVal")]
    #[cfg_attr(feature = "serde", serde(rename = "QRCdBinryVal"))]
    pub qr_cd_binry_val: Max3000Binary,

    #[yaserde(rename = "QRCdVrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "QRCdVrsn"))]
    pub qr_cd_vrsn: Max16Text,

    #[yaserde(rename = "QRCdNcodgMd")]
    #[cfg_attr(feature = "serde", serde(rename = "QRCdNcodgMd"))]
    pub qr_cd_ncodg_md: QrcodeEncodingMode1Code,

    #[yaserde(rename = "QRCdErrCrrctn")]
    #[cfg_attr(feature = "serde", serde(rename = "QRCdErrCrrctn"))]
    pub qr_cd_err_crrctn: QrcodeErrorCorrection1Code,
}

impl Validate for OutputBarcode1 {}


#[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.025.001.01")]

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.025.001.01")]

pub enum OutputFormat3Code {
    #[yaserde(rename = "BARC")]
    #[cfg_attr(feature = "serde", serde(rename = "BARC"))]
    Barc,
    #[yaserde(rename = "MENT")]
    #[cfg_attr(feature = "serde", serde(rename = "MENT"))]
    Ment,
    #[yaserde(rename = "MREF")]
    #[cfg_attr(feature = "serde", serde(rename = "MREF"))]
    Mref,
    #[yaserde(rename = "SREF")]
    #[cfg_attr(feature = "serde", serde(rename = "SREF"))]
    Sref,
    #[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 OutputFormat3Code {
    fn default() -> OutputFormat3Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for OutputFormat3Code {}



#[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.025.001.01")]

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.025.001.01")]

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.025.001.01")]

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.025.001.01")]

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.025.001.01")]

pub enum PoicomponentType6Code {
    #[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,
    __Unknown__(String),
}

impl Default for PoicomponentType6Code {
    fn default() -> PoicomponentType6Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for PoicomponentType6Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct PackageType2 {
    #[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<ExternallyDefinedData2>,
}

impl Validate for PackageType2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct Parameter10 {
    #[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: Algorithm16Code,

    #[yaserde(rename = "MskGnrtrAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "MskGnrtrAlgo"))]
    pub msk_gnrtr_algo: AlgorithmIdentification18,
}

impl Validate for Parameter10 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
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.025.001.01")]
pub struct Parameter15 {
    #[yaserde(rename = "DgstAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "DgstAlgo"))]
    pub dgst_algo: Algorithm16Code,

    #[yaserde(rename = "MskGnrtrAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "MskGnrtrAlgo"))]
    pub msk_gnrtr_algo: AlgorithmIdentification12,

    #[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 Parameter15 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct Parameter5 {
    #[yaserde(rename = "DgstAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "DgstAlgo"))]
    pub dgst_algo: Algorithm11Code,
}

impl Validate for Parameter5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.025.001.01")]
pub struct Parameter9 {
    #[yaserde(rename = "DgstAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "DgstAlgo"))]
    pub dgst_algo: Algorithm16Code,
}

impl Validate for Parameter9 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct PartyIdentification178Choice {
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_b_i_c: Option<AnyBICDec2014Identifier>,
    #[yaserde(rename = "PrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
    pub prtry_id: Option<GenericIdentification36>,
    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: Option<NameAndAddress6>,
}

impl Validate for PartyIdentification178Choice {}




#[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.025.001.01")]

pub enum PartyType14Code {
    #[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 = "ICCA")]
    #[cfg_attr(feature = "serde", serde(rename = "ICCA"))]
    Icca,
    __Unknown__(String),
}

impl Default for PartyType14Code {
    fn default() -> PartyType14Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for PartyType14Code {}



#[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.025.001.01")]

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.025.001.01")]

pub enum PartyType3Code {
    #[yaserde(rename = "OPOI")]
    #[cfg_attr(feature = "serde", serde(rename = "OPOI"))]
    Opoi,
    #[yaserde(rename = "MERC")]
    #[cfg_attr(feature = "serde", serde(rename = "MERC"))]
    Merc,
    #[yaserde(rename = "ACCP")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCP"))]
    Accp,
    #[yaserde(rename = "ITAG")]
    #[cfg_attr(feature = "serde", serde(rename = "ITAG"))]
    Itag,
    #[yaserde(rename = "ACQR")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
    Acqr,
    #[yaserde(rename = "CISS")]
    #[cfg_attr(feature = "serde", serde(rename = "CISS"))]
    Ciss,
    #[yaserde(rename = "DLIS")]
    #[cfg_attr(feature = "serde", serde(rename = "DLIS"))]
    Dlis,
    __Unknown__(String),
}

impl Default for PartyType3Code {
    fn default() -> PartyType3Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for PartyType3Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.025.001.01")]

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.025.001.01")]

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.025.001.01")]
pub struct PaymentCard31 {
    #[yaserde(rename = "PrtctdCardData")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtctdCardData"))]
    pub prtctd_card_data: ContentInformationType28,

    #[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: PlainCardData15,

    #[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 PaymentCard31 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct PaymentContext27 {
    #[yaserde(rename = "CardPres")]
    #[cfg_attr(feature = "serde", serde(rename = "CardPres"))]
    pub card_pres: TrueFalseIndicator,

    #[yaserde(rename = "CrdhldrPres")]
    #[cfg_attr(feature = "serde", serde(rename = "CrdhldrPres"))]
    pub crdhldr_pres: TrueFalseIndicator,

    #[yaserde(rename = "OnLineCntxt")]
    #[cfg_attr(feature = "serde", serde(rename = "OnLineCntxt"))]
    pub on_line_cntxt: TrueFalseIndicator,

    #[yaserde(rename = "AttndncCntxt")]
    #[cfg_attr(feature = "serde", serde(rename = "AttndncCntxt"))]
    pub attndnc_cntxt: AttendanceContext1Code,

    #[yaserde(rename = "TxEnvt")]
    #[cfg_attr(feature = "serde", serde(rename = "TxEnvt"))]
    pub tx_envt: TransactionEnvironment1Code,

    #[yaserde(rename = "TxChanl")]
    #[cfg_attr(feature = "serde", serde(rename = "TxChanl"))]
    pub tx_chanl: TransactionChannel5Code,

    #[yaserde(rename = "AttndntMsgCpbl")]
    #[cfg_attr(feature = "serde", serde(rename = "AttndntMsgCpbl"))]
    pub attndnt_msg_cpbl: TrueFalseIndicator,

    #[yaserde(rename = "AttndntLang")]
    #[cfg_attr(feature = "serde", serde(rename = "AttndntLang"))]
    pub attndnt_lang: LanguageCode,

    #[yaserde(rename = "CardDataNtryMd")]
    #[cfg_attr(feature = "serde", serde(rename = "CardDataNtryMd"))]
    pub card_data_ntry_md: CardDataReading8Code,

    #[yaserde(rename = "FllbckInd")]
    #[cfg_attr(feature = "serde", serde(rename = "FllbckInd"))]
    pub fllbck_ind: CardFallback1Code,

    #[yaserde(rename = "SpprtdOptn")]
    #[cfg_attr(feature = "serde", serde(rename = "SpprtdOptn"))]
    pub spprtd_optn: Vec<SupportedPaymentOption1Code>,
}

impl Validate for PaymentContext27 {}


#[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.025.001.01")]

pub enum PaymentInstrumentType1Code {
    #[yaserde(rename = "CARD")]
    #[cfg_attr(feature = "serde", serde(rename = "CARD"))]
    Card,
    #[yaserde(rename = "CASH")]
    #[cfg_attr(feature = "serde", serde(rename = "CASH"))]
    Cash,
    #[yaserde(rename = "CHCK")]
    #[cfg_attr(feature = "serde", serde(rename = "CHCK"))]
    Chck,
    #[yaserde(rename = "LOYT")]
    #[cfg_attr(feature = "serde", serde(rename = "LOYT"))]
    Loyt,
    #[yaserde(rename = "SVAC")]
    #[cfg_attr(feature = "serde", serde(rename = "SVAC"))]
    Svac,
    __Unknown__(String),
}

impl Default for PaymentInstrumentType1Code {
    fn default() -> PaymentInstrumentType1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for PaymentInstrumentType1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct PaymentReceipt3 {
    #[yaserde(rename = "DocQlfr")]
    #[cfg_attr(feature = "serde", serde(rename = "DocQlfr"))]
    pub doc_qlfr: DocumentType7Code,

    #[yaserde(rename = "IntgrtdPrtFlg")]
    #[cfg_attr(feature = "serde", serde(rename = "IntgrtdPrtFlg"))]
    pub intgrtd_prt_flg: TrueFalseIndicator,

    #[yaserde(rename = "ReqrdSgntrFlg")]
    #[cfg_attr(feature = "serde", serde(rename = "ReqrdSgntrFlg"))]
    pub reqrd_sgntr_flg: TrueFalseIndicator,

    #[yaserde(rename = "OutptCntt")]
    #[cfg_attr(feature = "serde", serde(rename = "OutptCntt"))]
    pub outpt_cntt: ActionMessage8,
}

impl Validate for PaymentReceipt3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct PaymentResponse3 {
    #[yaserde(rename = "SaleTxId")]
    #[cfg_attr(feature = "serde", serde(rename = "SaleTxId"))]
    pub sale_tx_id: TransactionIdentifier1,

    #[yaserde(rename = "SaleRefId")]
    #[cfg_attr(feature = "serde", serde(rename = "SaleRefId"))]
    pub sale_ref_id: Max35Text,

    #[yaserde(rename = "POITxId")]
    #[cfg_attr(feature = "serde", serde(rename = "POITxId"))]
    pub poi_tx_id: TransactionIdentifier1,

    #[yaserde(rename = "POIRcncltnId")]
    #[cfg_attr(feature = "serde", serde(rename = "POIRcncltnId"))]
    pub poi_rcncltn_id: Max35Text,

    #[yaserde(rename = "IssrRefData")]
    #[cfg_attr(feature = "serde", serde(rename = "IssrRefData"))]
    pub issr_ref_data: Max140Text,

    #[yaserde(rename = "RtlrPmtRslt")]
    #[cfg_attr(feature = "serde", serde(rename = "RtlrPmtRslt"))]
    pub rtlr_pmt_rslt: RetailerPaymentResult3,

    #[yaserde(rename = "PmtRct")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtRct"))]
    pub pmt_rct: Vec<PaymentReceipt3>,

    #[yaserde(rename = "LltyRslt")]
    #[cfg_attr(feature = "serde", serde(rename = "LltyRslt"))]
    pub llty_rslt: Vec<LoyaltyResult2>,

    #[yaserde(rename = "CstmrOrdr")]
    #[cfg_attr(feature = "serde", serde(rename = "CstmrOrdr"))]
    pub cstmr_ordr: Vec<CustomerOrder1>,
}

impl Validate for PaymentResponse3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
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)]
pub struct PercentageRate (pub String);
crate::simple_type!(PercentageRate);

impl Validate for PercentageRate {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.025.001.01")]
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.025.001.01")]
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.025.001.01")]
pub struct PlainCardData15 {
    #[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 PlainCardData15 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
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)]
pub struct PlusOrMinusIndicator (pub bool);
crate::simple_type!(PlusOrMinusIndicator);

impl Validate for PlusOrMinusIndicator {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct PointOfInteraction11 {
    #[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: PointOfInteractionCapabilities9,

    #[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<PointOfInteractionComponent11>,
}

impl Validate for PointOfInteraction11 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct PointOfInteractionCapabilities9 {
    #[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<DisplayCapabilities4>,
}

impl Validate for PointOfInteractionCapabilities9 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct PointOfInteractionComponent11 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: PoicomponentType6Code,

    #[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: PointOfInteractionComponentCharacteristics7,

    #[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<PackageType2>,
}

impl Validate for PointOfInteractionComponent11 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
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.025.001.01")]
pub struct PointOfInteractionComponentCharacteristics7 {
    #[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<CryptographicKey15>,
}

impl Validate for PointOfInteractionComponentCharacteristics7 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
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.025.001.01")]
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.025.001.01")]
pub struct PointOfInteractionTransactionReport3 {
    #[yaserde(rename = "Rspn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rspn"))]
    pub rspn: ResponseType11,

    #[yaserde(rename = "PmtRspn")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtRspn"))]
    pub pmt_rspn: PaymentResponse3,
}

impl Validate for PointOfInteractionTransactionReport3 {}


#[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.025.001.01")]
pub struct PostalAddress2 {
    #[yaserde(rename = "StrtNm")]
    #[cfg_attr(feature = "serde", serde(rename = "StrtNm"))]
    pub strt_nm: Max70Text,

    #[yaserde(rename = "PstCdId")]
    #[cfg_attr(feature = "serde", serde(rename = "PstCdId"))]
    pub pst_cd_id: Max16Text,

    #[yaserde(rename = "TwnNm")]
    #[cfg_attr(feature = "serde", serde(rename = "TwnNm"))]
    pub twn_nm: Max35Text,

    #[yaserde(rename = "CtrySubDvsn")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrySubDvsn"))]
    pub ctry_sub_dvsn: Max35Text,

    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: CountryCode,
}

impl Validate for PostalAddress2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
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.025.001.01")]
pub struct Product4 {
    #[yaserde(rename = "PdctCd")]
    #[cfg_attr(feature = "serde", serde(rename = "PdctCd"))]
    pub pdct_cd: Max70Text,

    #[yaserde(rename = "AddtlPdctCd")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlPdctCd"))]
    pub addtl_pdct_cd: Max70Text,
}

impl Validate for Product4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct Product5 {
    #[yaserde(rename = "PdctCd")]
    #[cfg_attr(feature = "serde", serde(rename = "PdctCd"))]
    pub pdct_cd: Max70Text,

    #[yaserde(rename = "AddtlPdctCd")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlPdctCd"))]
    pub addtl_pdct_cd: Max70Text,

    #[yaserde(rename = "AmtLmt")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtLmt"))]
    pub amt_lmt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "QtyLmt")]
    #[cfg_attr(feature = "serde", serde(rename = "QtyLmt"))]
    pub qty_lmt: DecimalNumber,

    #[yaserde(rename = "UnitOfMeasr")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitOfMeasr"))]
    pub unit_of_measr: UnitOfMeasure6Code,
}

impl Validate for Product5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct Product6 {
    #[yaserde(rename = "ItmId")]
    #[cfg_attr(feature = "serde", serde(rename = "ItmId"))]
    pub itm_id: Max35Text,

    #[yaserde(rename = "PdctCd")]
    #[cfg_attr(feature = "serde", serde(rename = "PdctCd"))]
    pub pdct_cd: Max70Text,

    #[yaserde(rename = "AddtlPdctCd")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlPdctCd"))]
    pub addtl_pdct_cd: Max70Text,

    #[yaserde(rename = "UnitOfMeasr")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitOfMeasr"))]
    pub unit_of_measr: UnitOfMeasure6Code,

    #[yaserde(rename = "PdctQty")]
    #[cfg_attr(feature = "serde", serde(rename = "PdctQty"))]
    pub pdct_qty: DecimalNumber,

    #[yaserde(rename = "UnitPric")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitPric"))]
    pub unit_pric: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "UnitPricSgn")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitPricSgn"))]
    pub unit_pric_sgn: PlusOrMinusIndicator,

    #[yaserde(rename = "PdctAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "PdctAmt"))]
    pub pdct_amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "PdctAmtSgn")]
    #[cfg_attr(feature = "serde", serde(rename = "PdctAmtSgn"))]
    pub pdct_amt_sgn: PlusOrMinusIndicator,

    #[yaserde(rename = "ValAddedTax")]
    #[cfg_attr(feature = "serde", serde(rename = "ValAddedTax"))]
    pub val_added_tax: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "TaxTp")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxTp"))]
    pub tax_tp: Max35Text,

    #[yaserde(rename = "PdctDesc")]
    #[cfg_attr(feature = "serde", serde(rename = "PdctDesc"))]
    pub pdct_desc: Max140Text,

    #[yaserde(rename = "DlvryLctn")]
    #[cfg_attr(feature = "serde", serde(rename = "DlvryLctn"))]
    pub dlvry_lctn: Max10Text,

    #[yaserde(rename = "DlvrySvc")]
    #[cfg_attr(feature = "serde", serde(rename = "DlvrySvc"))]
    pub dlvry_svc: AttendanceContext2Code,

    #[yaserde(rename = "SaleChanl")]
    #[cfg_attr(feature = "serde", serde(rename = "SaleChanl"))]
    pub sale_chanl: Max70Text,

    #[yaserde(rename = "AddtlPdctDesc")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlPdctDesc"))]
    pub addtl_pdct_desc: Max256Text,
}

impl Validate for Product6 {}


#[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.025.001.01")]

pub enum QrcodeEncodingMode1Code {
    #[yaserde(rename = "ALFA")]
    #[cfg_attr(feature = "serde", serde(rename = "ALFA"))]
    Alfa,
    #[yaserde(rename = "BINA")]
    #[cfg_attr(feature = "serde", serde(rename = "BINA"))]
    Bina,
    #[yaserde(rename = "KANJ")]
    #[cfg_attr(feature = "serde", serde(rename = "KANJ"))]
    Kanj,
    #[yaserde(rename = "NUME")]
    #[cfg_attr(feature = "serde", serde(rename = "NUME"))]
    Nume,
    __Unknown__(String),
}

impl Default for QrcodeEncodingMode1Code {
    fn default() -> QrcodeEncodingMode1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for QrcodeEncodingMode1Code {}



#[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.025.001.01")]

pub enum QrcodeErrorCorrection1Code {
    M015,
    Q025,
    H030,
    L007,
    __Unknown__(String),
}

impl Default for QrcodeErrorCorrection1Code {
    fn default() -> QrcodeErrorCorrection1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for QrcodeErrorCorrection1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct Recipient10Choice {
    #[yaserde(rename = "KeyTrnsprt")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyTrnsprt"))]
    pub key_trnsprt: Option<KeyTransport7>,
    #[yaserde(rename = "KEK")]
    #[cfg_attr(feature = "serde", serde(rename = "KEK"))]
    pub kek: Option<Kek7>,
    #[yaserde(rename = "KeyIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyIdr"))]
    pub key_idr: Option<Kekidentifier2>,
}

impl Validate for Recipient10Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct Recipient9Choice {
    #[yaserde(rename = "IssrAndSrlNb")]
    #[cfg_attr(feature = "serde", serde(rename = "IssrAndSrlNb"))]
    pub issr_and_srl_nb: Option<IssuerAndSerialNumber2>,
    #[yaserde(rename = "KeyIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyIdr"))]
    pub key_idr: Option<Kekidentifier2>,
}

impl Validate for Recipient9Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct RecurringTransaction2 {
    #[yaserde(rename = "InstlmtPlan")]
    #[cfg_attr(feature = "serde", serde(rename = "InstlmtPlan"))]
    pub instlmt_plan: Vec<InstalmentPlan1Code>,

    #[yaserde(rename = "PlanId")]
    #[cfg_attr(feature = "serde", serde(rename = "PlanId"))]
    pub plan_id: Max35Text,

    #[yaserde(rename = "SeqNb")]
    #[cfg_attr(feature = "serde", serde(rename = "SeqNb"))]
    pub seq_nb: Number,

    #[yaserde(rename = "PrdUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "PrdUnit"))]
    pub prd_unit: Frequency3Code,

    #[yaserde(rename = "InstlmtPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "InstlmtPrd"))]
    pub instlmt_prd: Number,

    #[yaserde(rename = "TtlNbOfPmts")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlNbOfPmts"))]
    pub ttl_nb_of_pmts: Number,

    #[yaserde(rename = "FrstPmtDt")]
    #[cfg_attr(feature = "serde", serde(rename = "FrstPmtDt"))]
    pub frst_pmt_dt: Isodate,

    #[yaserde(rename = "TtlAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlAmt"))]
    pub ttl_amt: CurrencyAndAmount,

    #[yaserde(rename = "FrstAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "FrstAmt"))]
    pub frst_amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "Chrgs")]
    #[cfg_attr(feature = "serde", serde(rename = "Chrgs"))]
    pub chrgs: ImpliedCurrencyAndAmount,
}

impl Validate for RecurringTransaction2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
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.025.001.01")]
pub struct ReportGetTotalsResponse1 {
    #[yaserde(rename = "POIRcncltnId")]
    #[cfg_attr(feature = "serde", serde(rename = "POIRcncltnId"))]
    pub poi_rcncltn_id: Max35Text,

    #[yaserde(rename = "TxTtlsSet")]
    #[cfg_attr(feature = "serde", serde(rename = "TxTtlsSet"))]
    pub tx_ttls_set: Vec<TransactionTotalsSet1>,
}

impl Validate for ReportGetTotalsResponse1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct ReportResponse4 {
    #[yaserde(rename = "Envt")]
    #[cfg_attr(feature = "serde", serde(rename = "Envt"))]
    pub envt: CardPaymentEnvironment77,

    #[yaserde(rename = "Cntxt")]
    #[cfg_attr(feature = "serde", serde(rename = "Cntxt"))]
    pub cntxt: CardPaymentContext28,

    #[yaserde(rename = "SvcCntt")]
    #[cfg_attr(feature = "serde", serde(rename = "SvcCntt"))]
    pub svc_cntt: RetailerService7Code,

    #[yaserde(rename = "RptTxRspn")]
    #[cfg_attr(feature = "serde", serde(rename = "RptTxRspn"))]
    pub rpt_tx_rspn: ReportTransactionResponse3,

    #[yaserde(rename = "RptGetTtlsRspn")]
    #[cfg_attr(feature = "serde", serde(rename = "RptGetTtlsRspn"))]
    pub rpt_get_ttls_rspn: ReportGetTotalsResponse1,

    #[yaserde(rename = "Rspn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rspn"))]
    pub rspn: ResponseType11,

    #[yaserde(rename = "SplmtryData")]
    #[cfg_attr(feature = "serde", serde(rename = "SplmtryData"))]
    pub splmtry_data: Vec<SupplementaryData1>,
}

impl Validate for ReportResponse4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct ReportTransactionResponse3 {
    #[yaserde(rename = "RptFullSz")]
    #[cfg_attr(feature = "serde", serde(rename = "RptFullSz"))]
    pub rpt_full_sz: PositiveNumber,

    #[yaserde(rename = "BlckStart")]
    #[cfg_attr(feature = "serde", serde(rename = "BlckStart"))]
    pub blck_start: PositiveNumber,

    #[yaserde(rename = "BlckStop")]
    #[cfg_attr(feature = "serde", serde(rename = "BlckStop"))]
    pub blck_stop: PositiveNumber,

    #[yaserde(rename = "TxRpt")]
    #[cfg_attr(feature = "serde", serde(rename = "TxRpt"))]
    pub tx_rpt: Vec<PointOfInteractionTransactionReport3>,
}

impl Validate for ReportTransactionResponse3 {}


#[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.025.001.01")]

pub enum Response11Code {
    #[yaserde(rename = "WARN")]
    #[cfg_attr(feature = "serde", serde(rename = "WARN"))]
    Warn,
    #[yaserde(rename = "FAIL")]
    #[cfg_attr(feature = "serde", serde(rename = "FAIL"))]
    Fail,
    #[yaserde(rename = "SUCC")]
    #[cfg_attr(feature = "serde", serde(rename = "SUCC"))]
    Succ,
    __Unknown__(String),
}

impl Default for Response11Code {
    fn default() -> Response11Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for Response11Code {}



#[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.025.001.01")]

pub enum Response9Code {
    #[yaserde(rename = "APPR")]
    #[cfg_attr(feature = "serde", serde(rename = "APPR"))]
    Appr,
    #[yaserde(rename = "DECL")]
    #[cfg_attr(feature = "serde", serde(rename = "DECL"))]
    Decl,
    #[yaserde(rename = "PART")]
    #[cfg_attr(feature = "serde", serde(rename = "PART"))]
    Part,
    #[yaserde(rename = "SUSP")]
    #[cfg_attr(feature = "serde", serde(rename = "SUSP"))]
    Susp,
    #[yaserde(rename = "TECH")]
    #[cfg_attr(feature = "serde", serde(rename = "TECH"))]
    Tech,
    __Unknown__(String),
}

impl Default for Response9Code {
    fn default() -> Response9Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for Response9Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct ResponseType10 {
    #[yaserde(rename = "Rspn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rspn"))]
    pub rspn: Response9Code,

    #[yaserde(rename = "RspnRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "RspnRsn"))]
    pub rspn_rsn: Max35Text,

    #[yaserde(rename = "AddtlRspnInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlRspnInf"))]
    pub addtl_rspn_inf: Max140Text,
}

impl Validate for ResponseType10 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct ResponseType11 {
    #[yaserde(rename = "Rspn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rspn"))]
    pub rspn: Response11Code,

    #[yaserde(rename = "RspnRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "RspnRsn"))]
    pub rspn_rsn: RetailerResultDetail1Code,

    #[yaserde(rename = "AddtlRspnInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlRspnInf"))]
    pub addtl_rspn_inf: Max140Text,
}

impl Validate for ResponseType11 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct RetailerPaymentResult3 {
    #[yaserde(rename = "TxTp")]
    #[cfg_attr(feature = "serde", serde(rename = "TxTp"))]
    pub tx_tp: CardPaymentServiceType12Code,

    #[yaserde(rename = "AddtlSvc")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlSvc"))]
    pub addtl_svc: Vec<CardPaymentServiceType9Code>,

    #[yaserde(rename = "SvcAttr")]
    #[cfg_attr(feature = "serde", serde(rename = "SvcAttr"))]
    pub svc_attr: CardPaymentServiceType3Code,

    #[yaserde(rename = "ReqdTx")]
    #[cfg_attr(feature = "serde", serde(rename = "ReqdTx"))]
    pub reqd_tx: CardPaymentTransaction110,

    #[yaserde(rename = "TxRspn")]
    #[cfg_attr(feature = "serde", serde(rename = "TxRspn"))]
    pub tx_rspn: CardPaymentTransaction109,

    #[yaserde(rename = "CstmrOrdr")]
    #[cfg_attr(feature = "serde", serde(rename = "CstmrOrdr"))]
    pub cstmr_ordr: Vec<CustomerOrder1>,

    #[yaserde(rename = "ImgCaptrdSgntr")]
    #[cfg_attr(feature = "serde", serde(rename = "ImgCaptrdSgntr"))]
    pub img_captrd_sgntr: CapturedSignature1,

    #[yaserde(rename = "PrtctdCaptrdSgntr")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtctdCaptrdSgntr"))]
    pub prtctd_captrd_sgntr: ContentInformationType28,

    #[yaserde(rename = "MrchntOvrrdFlg")]
    #[cfg_attr(feature = "serde", serde(rename = "MrchntOvrrdFlg"))]
    pub mrchnt_ovrrd_flg: TrueFalseIndicator,

    #[yaserde(rename = "CstmrLang")]
    #[cfg_attr(feature = "serde", serde(rename = "CstmrLang"))]
    pub cstmr_lang: LanguageCode,

    #[yaserde(rename = "OnlnFlg")]
    #[cfg_attr(feature = "serde", serde(rename = "OnlnFlg"))]
    pub onln_flg: TrueFalseIndicator,
}

impl Validate for RetailerPaymentResult3 {}


#[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.025.001.01")]

pub enum RetailerResultDetail1Code {
    #[yaserde(rename = "ABRT")]
    #[cfg_attr(feature = "serde", serde(rename = "ABRT"))]
    Abrt,
    #[yaserde(rename = "BUSY")]
    #[cfg_attr(feature = "serde", serde(rename = "BUSY"))]
    Busy,
    #[yaserde(rename = "CANC")]
    #[cfg_attr(feature = "serde", serde(rename = "CANC"))]
    Canc,
    #[yaserde(rename = "DEVO")]
    #[cfg_attr(feature = "serde", serde(rename = "DEVO"))]
    Devo,
    #[yaserde(rename = "WPIN")]
    #[cfg_attr(feature = "serde", serde(rename = "WPIN"))]
    Wpin,
    #[yaserde(rename = "NHOS")]
    #[cfg_attr(feature = "serde", serde(rename = "NHOS"))]
    Nhos,
    #[yaserde(rename = "UNVS")]
    #[cfg_attr(feature = "serde", serde(rename = "UNVS"))]
    Unvs,
    #[yaserde(rename = "UNVD")]
    #[cfg_attr(feature = "serde", serde(rename = "UNVD"))]
    Unvd,
    #[yaserde(rename = "REFU")]
    #[cfg_attr(feature = "serde", serde(rename = "REFU"))]
    Refu,
    #[yaserde(rename = "PAYR")]
    #[cfg_attr(feature = "serde", serde(rename = "PAYR"))]
    Payr,
    #[yaserde(rename = "TNFD")]
    #[cfg_attr(feature = "serde", serde(rename = "TNFD"))]
    Tnfd,
    #[yaserde(rename = "NALW")]
    #[cfg_attr(feature = "serde", serde(rename = "NALW"))]
    Nalw,
    #[yaserde(rename = "LOUT")]
    #[cfg_attr(feature = "serde", serde(rename = "LOUT"))]
    Lout,
    #[yaserde(rename = "IVCA")]
    #[cfg_attr(feature = "serde", serde(rename = "IVCA"))]
    Ivca,
    #[yaserde(rename = "ICAR")]
    #[cfg_attr(feature = "serde", serde(rename = "ICAR"))]
    Icar,
    #[yaserde(rename = "WIPG")]
    #[cfg_attr(feature = "serde", serde(rename = "WIPG"))]
    Wipg,
    __Unknown__(String),
}

impl Default for RetailerResultDetail1Code {
    fn default() -> RetailerResultDetail1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for RetailerResultDetail1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
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.025.001.01")]

pub enum RetailerService7Code {
    #[yaserde(rename = "RPTP")]
    #[cfg_attr(feature = "serde", serde(rename = "RPTP"))]
    Rptp,
    #[yaserde(rename = "RPAP")]
    #[cfg_attr(feature = "serde", serde(rename = "RPAP"))]
    Rpap,
    __Unknown__(String),
}

impl Default for RetailerService7Code {
    fn default() -> RetailerService7Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for RetailerService7Code {}



#[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.025.001.01")]

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.025.001.01")]
pub struct SaleContext4 {
    #[yaserde(rename = "SaleId")]
    #[cfg_attr(feature = "serde", serde(rename = "SaleId"))]
    pub sale_id: Max35Text,

    #[yaserde(rename = "SaleRefNb")]
    #[cfg_attr(feature = "serde", serde(rename = "SaleRefNb"))]
    pub sale_ref_nb: Max35Text,

    #[yaserde(rename = "SaleRcncltnId")]
    #[cfg_attr(feature = "serde", serde(rename = "SaleRcncltnId"))]
    pub sale_rcncltn_id: Max35Text,

    #[yaserde(rename = "CshrId")]
    #[cfg_attr(feature = "serde", serde(rename = "CshrId"))]
    pub cshr_id: Max35Text,

    #[yaserde(rename = "CshrLang")]
    #[cfg_attr(feature = "serde", serde(rename = "CshrLang"))]
    pub cshr_lang: Vec<LanguageCode>,

    #[yaserde(rename = "ShftNb")]
    #[cfg_attr(feature = "serde", serde(rename = "ShftNb"))]
    pub shft_nb: Max2NumericText,

    #[yaserde(rename = "CstmrOrdrReqFlg")]
    #[cfg_attr(feature = "serde", serde(rename = "CstmrOrdrReqFlg"))]
    pub cstmr_ordr_req_flg: TrueFalseIndicator,

    #[yaserde(rename = "PurchsOrdrNb")]
    #[cfg_attr(feature = "serde", serde(rename = "PurchsOrdrNb"))]
    pub purchs_ordr_nb: Max35Text,

    #[yaserde(rename = "InvcNb")]
    #[cfg_attr(feature = "serde", serde(rename = "InvcNb"))]
    pub invc_nb: Max35Text,

    #[yaserde(rename = "DlvryNoteNb")]
    #[cfg_attr(feature = "serde", serde(rename = "DlvryNoteNb"))]
    pub dlvry_note_nb: Max35Text,

    #[yaserde(rename = "SpnsrdMrchnt")]
    #[cfg_attr(feature = "serde", serde(rename = "SpnsrdMrchnt"))]
    pub spnsrd_mrchnt: Vec<Organisation26>,

    #[yaserde(rename = "SpltPmt")]
    #[cfg_attr(feature = "serde", serde(rename = "SpltPmt"))]
    pub splt_pmt: TrueFalseIndicator,

    #[yaserde(rename = "RmngAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "RmngAmt"))]
    pub rmng_amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "ForceOnlnFlg")]
    #[cfg_attr(feature = "serde", serde(rename = "ForceOnlnFlg"))]
    pub force_onln_flg: TrueFalseIndicator,

    #[yaserde(rename = "ReuseCardDataFlg")]
    #[cfg_attr(feature = "serde", serde(rename = "ReuseCardDataFlg"))]
    pub reuse_card_data_flg: TrueFalseIndicator,

    #[yaserde(rename = "AllwdNtryMd")]
    #[cfg_attr(feature = "serde", serde(rename = "AllwdNtryMd"))]
    pub allwd_ntry_md: Vec<CardDataReading8Code>,

    #[yaserde(rename = "SaleTknScp")]
    #[cfg_attr(feature = "serde", serde(rename = "SaleTknScp"))]
    pub sale_tkn_scp: SaleTokenScope1Code,

    #[yaserde(rename = "AddtlSaleData")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlSaleData"))]
    pub addtl_sale_data: Max70Text,
}

impl Validate for SaleContext4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct SaleItemRebate1 {
    #[yaserde(rename = "SaleItm")]
    #[cfg_attr(feature = "serde", serde(rename = "SaleItm"))]
    pub sale_itm: Product6,

    #[yaserde(rename = "RbtLabl")]
    #[cfg_attr(feature = "serde", serde(rename = "RbtLabl"))]
    pub rbt_labl: Max35Text,
}

impl Validate for SaleItemRebate1 {}


#[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.025.001.01")]

pub enum SaleTokenScope1Code {
    #[yaserde(rename = "MULT")]
    #[cfg_attr(feature = "serde", serde(rename = "MULT"))]
    Mult,
    #[yaserde(rename = "SNGL")]
    #[cfg_attr(feature = "serde", serde(rename = "SNGL"))]
    Sngl,
    __Unknown__(String),
}

impl Default for SaleTokenScope1Code {
    fn default() -> SaleTokenScope1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for SaleTokenScope1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
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.025.001.01")]
pub struct SignedData6 {
    #[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<AlgorithmIdentification21>,

    #[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<Signer5>,
}

impl Validate for SignedData6 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct Signer5 {
    #[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: Recipient9Choice,

    #[yaserde(rename = "DgstAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "DgstAlgo"))]
    pub dgst_algo: AlgorithmIdentification21,

    #[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: AlgorithmIdentification30,

    #[yaserde(rename = "Sgntr")]
    #[cfg_attr(feature = "serde", serde(rename = "Sgntr"))]
    pub sgntr: Max3000Binary,
}

impl Validate for Signer5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct SimpleIdentificationInformation4 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,
}

impl Validate for SimpleIdentificationInformation4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
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.025.001.01")]

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.025.001.01")]
pub struct SupplementaryData1 {
    #[yaserde(rename = "PlcAndNm")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcAndNm"))]
    pub plc_and_nm: Max350Text,

    #[yaserde(rename = "Envlp")]
    #[cfg_attr(feature = "serde", serde(rename = "Envlp"))]
    pub envlp: SupplementaryDataEnvelope1,
}

impl Validate for SupplementaryData1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.025.001.01")]
pub struct SupplementaryDataEnvelope1 {}

impl Validate for SupplementaryDataEnvelope1 {}


#[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.025.001.01")]

pub enum SupportedPaymentOption1Code {
    #[yaserde(rename = "PART")]
    #[cfg_attr(feature = "serde", serde(rename = "PART"))]
    Part,
    #[yaserde(rename = "MSRV")]
    #[cfg_attr(feature = "serde", serde(rename = "MSRV"))]
    Msrv,
    __Unknown__(String),
}

impl Default for SupportedPaymentOption1Code {
    fn default() -> SupportedPaymentOption1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for SupportedPaymentOption1Code {}



#[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.025.001.01")]

pub enum TmscontactLevel1Code {
    #[yaserde(rename = "CRIT")]
    #[cfg_attr(feature = "serde", serde(rename = "CRIT"))]
    Crit,
    #[yaserde(rename = "ASAP")]
    #[cfg_attr(feature = "serde", serde(rename = "ASAP"))]
    Asap,
    #[yaserde(rename = "DTIM")]
    #[cfg_attr(feature = "serde", serde(rename = "DTIM"))]
    Dtim,
    __Unknown__(String),
}

impl Default for TmscontactLevel1Code {
    fn default() -> TmscontactLevel1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for TmscontactLevel1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct Tmstrigger1 {
    #[yaserde(rename = "TMSCtctLvl")]
    #[cfg_attr(feature = "serde", serde(rename = "TMSCtctLvl"))]
    pub tms_ctct_lvl: TmscontactLevel1Code,

    #[yaserde(rename = "TMSId")]
    #[cfg_attr(feature = "serde", serde(rename = "TMSId"))]
    pub tms_id: Max35Text,

    #[yaserde(rename = "TMSCtctDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "TMSCtctDtTm"))]
    pub tms_ctct_dt_tm: IsodateTime,
}

impl Validate for Tmstrigger1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
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.025.001.01")]
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.025.001.01")]
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.025.001.01")]

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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.025.001.01")]

pub enum TransactionChannel5Code {
    #[yaserde(rename = "MAIL")]
    #[cfg_attr(feature = "serde", serde(rename = "MAIL"))]
    Mail,
    #[yaserde(rename = "TLPH")]
    #[cfg_attr(feature = "serde", serde(rename = "TLPH"))]
    Tlph,
    #[yaserde(rename = "ECOM")]
    #[cfg_attr(feature = "serde", serde(rename = "ECOM"))]
    Ecom,
    #[yaserde(rename = "TVPY")]
    #[cfg_attr(feature = "serde", serde(rename = "TVPY"))]
    Tvpy,
    #[yaserde(rename = "SECM")]
    #[cfg_attr(feature = "serde", serde(rename = "SECM"))]
    Secm,
    #[yaserde(rename = "MOBL")]
    #[cfg_attr(feature = "serde", serde(rename = "MOBL"))]
    Mobl,
    #[yaserde(rename = "MPOS")]
    #[cfg_attr(feature = "serde", serde(rename = "MPOS"))]
    Mpos,
    __Unknown__(String),
}

impl Default for TransactionChannel5Code {
    fn default() -> TransactionChannel5Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for TransactionChannel5Code {}



#[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.025.001.01")]

pub enum TransactionEnvironment1Code {
    #[yaserde(rename = "MERC")]
    #[cfg_attr(feature = "serde", serde(rename = "MERC"))]
    Merc,
    #[yaserde(rename = "PRIV")]
    #[cfg_attr(feature = "serde", serde(rename = "PRIV"))]
    Priv,
    #[yaserde(rename = "PUBL")]
    #[cfg_attr(feature = "serde", serde(rename = "PUBL"))]
    Publ,
    __Unknown__(String),
}

impl Default for TransactionEnvironment1Code {
    fn default() -> TransactionEnvironment1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for TransactionEnvironment1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.025.001.01")]
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.025.001.01")]
pub struct TransactionTotals8 {
    #[yaserde(rename = "POIGrpId")]
    #[cfg_attr(feature = "serde", serde(rename = "POIGrpId"))]
    pub poi_grp_id: 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: TypeTransactionTotals3Code,

    #[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,

    #[yaserde(rename = "DtldAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "DtldAmt"))]
    pub dtld_amt: DetailedAmount15,
}

impl Validate for TransactionTotals8 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
pub struct TransactionTotalsSet1 {
    #[yaserde(rename = "PmtInstrmTp")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtInstrmTp"))]
    pub pmt_instrm_tp: PaymentInstrumentType1Code,

    #[yaserde(rename = "AcqrrId")]
    #[cfg_attr(feature = "serde", serde(rename = "AcqrrId"))]
    pub acqrr_id: Max35Text,

    #[yaserde(rename = "RcncltnId")]
    #[cfg_attr(feature = "serde", serde(rename = "RcncltnId"))]
    pub rcncltn_id: Max35Text,

    #[yaserde(rename = "SaleRcncltnId")]
    #[cfg_attr(feature = "serde", serde(rename = "SaleRcncltnId"))]
    pub sale_rcncltn_id: Max35Text,

    #[yaserde(rename = "Brnd")]
    #[cfg_attr(feature = "serde", serde(rename = "Brnd"))]
    pub brnd: Max35Text,

    #[yaserde(rename = "POIId")]
    #[cfg_attr(feature = "serde", serde(rename = "POIId"))]
    pub poi_id: Max35Text,

    #[yaserde(rename = "SaleId")]
    #[cfg_attr(feature = "serde", serde(rename = "SaleId"))]
    pub sale_id: Max35Text,

    #[yaserde(rename = "CshrId")]
    #[cfg_attr(feature = "serde", serde(rename = "CshrId"))]
    pub cshr_id: Max35Text,

    #[yaserde(rename = "ShftNb")]
    #[cfg_attr(feature = "serde", serde(rename = "ShftNb"))]
    pub shft_nb: Max2NumericText,

    #[yaserde(rename = "SpnsrdMrchnt")]
    #[cfg_attr(feature = "serde", serde(rename = "SpnsrdMrchnt"))]
    pub spnsrd_mrchnt: Vec<Organisation26>,

    #[yaserde(rename = "TxTtl")]
    #[cfg_attr(feature = "serde", serde(rename = "TxTtl"))]
    pub tx_ttl: TransactionTotals8,

    #[yaserde(rename = "LltyTxTtl")]
    #[cfg_attr(feature = "serde", serde(rename = "LltyTxTtl"))]
    pub llty_tx_ttl: Vec<LoyaltyTransactionTotals1>,
}

impl Validate for TransactionTotalsSet1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
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.025.001.01")]

pub enum TypeOfAmount8Code {
    #[yaserde(rename = "ACTL")]
    #[cfg_attr(feature = "serde", serde(rename = "ACTL"))]
    Actl,
    #[yaserde(rename = "ESTM")]
    #[cfg_attr(feature = "serde", serde(rename = "ESTM"))]
    Estm,
    #[yaserde(rename = "MAXI")]
    #[cfg_attr(feature = "serde", serde(rename = "MAXI"))]
    Maxi,
    #[yaserde(rename = "DFLT")]
    #[cfg_attr(feature = "serde", serde(rename = "DFLT"))]
    Dflt,
    #[yaserde(rename = "RPLT")]
    #[cfg_attr(feature = "serde", serde(rename = "RPLT"))]
    Rplt,
    #[yaserde(rename = "INCR")]
    #[cfg_attr(feature = "serde", serde(rename = "INCR"))]
    Incr,
    #[yaserde(rename = "DECR")]
    #[cfg_attr(feature = "serde", serde(rename = "DECR"))]
    Decr,
    #[yaserde(rename = "RESD")]
    #[cfg_attr(feature = "serde", serde(rename = "RESD"))]
    Resd,
    __Unknown__(String),
}

impl Default for TypeOfAmount8Code {
    fn default() -> TypeOfAmount8Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for TypeOfAmount8Code {}



#[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.025.001.01")]

pub enum TypeTransactionTotals3Code {
    #[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,
    #[yaserde(rename = "RESV")]
    #[cfg_attr(feature = "serde", serde(rename = "RESV"))]
    Resv,
    __Unknown__(String),
}

impl Default for TypeTransactionTotals3Code {
    fn default() -> TypeTransactionTotals3Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for TypeTransactionTotals3Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Upicidentifier (pub String);
crate::simple_type!(Upicidentifier);

impl Validate for Upicidentifier {}
#[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.025.001.01")]

pub enum UnitOfMeasure6Code {
    #[yaserde(rename = "PIEC")]
    #[cfg_attr(feature = "serde", serde(rename = "PIEC"))]
    Piec,
    #[yaserde(rename = "TONS")]
    #[cfg_attr(feature = "serde", serde(rename = "TONS"))]
    Tons,
    #[yaserde(rename = "FOOT")]
    #[cfg_attr(feature = "serde", serde(rename = "FOOT"))]
    Foot,
    #[yaserde(rename = "GBGA")]
    #[cfg_attr(feature = "serde", serde(rename = "GBGA"))]
    Gbga,
    #[yaserde(rename = "USGA")]
    #[cfg_attr(feature = "serde", serde(rename = "USGA"))]
    Usga,
    #[yaserde(rename = "GRAM")]
    #[cfg_attr(feature = "serde", serde(rename = "GRAM"))]
    Gram,
    #[yaserde(rename = "INCH")]
    #[cfg_attr(feature = "serde", serde(rename = "INCH"))]
    Inch,
    #[yaserde(rename = "KILO")]
    #[cfg_attr(feature = "serde", serde(rename = "KILO"))]
    Kilo,
    #[yaserde(rename = "PUND")]
    #[cfg_attr(feature = "serde", serde(rename = "PUND"))]
    Pund,
    #[yaserde(rename = "METR")]
    #[cfg_attr(feature = "serde", serde(rename = "METR"))]
    Metr,
    #[yaserde(rename = "CMET")]
    #[cfg_attr(feature = "serde", serde(rename = "CMET"))]
    Cmet,
    #[yaserde(rename = "MMET")]
    #[cfg_attr(feature = "serde", serde(rename = "MMET"))]
    Mmet,
    #[yaserde(rename = "LITR")]
    #[cfg_attr(feature = "serde", serde(rename = "LITR"))]
    Litr,
    #[yaserde(rename = "CELI")]
    #[cfg_attr(feature = "serde", serde(rename = "CELI"))]
    Celi,
    #[yaserde(rename = "MILI")]
    #[cfg_attr(feature = "serde", serde(rename = "MILI"))]
    Mili,
    #[yaserde(rename = "GBOU")]
    #[cfg_attr(feature = "serde", serde(rename = "GBOU"))]
    Gbou,
    #[yaserde(rename = "USOU")]
    #[cfg_attr(feature = "serde", serde(rename = "USOU"))]
    Usou,
    #[yaserde(rename = "GBQA")]
    #[cfg_attr(feature = "serde", serde(rename = "GBQA"))]
    Gbqa,
    #[yaserde(rename = "USQA")]
    #[cfg_attr(feature = "serde", serde(rename = "USQA"))]
    Usqa,
    #[yaserde(rename = "GBPI")]
    #[cfg_attr(feature = "serde", serde(rename = "GBPI"))]
    Gbpi,
    #[yaserde(rename = "USPI")]
    #[cfg_attr(feature = "serde", serde(rename = "USPI"))]
    Uspi,
    #[yaserde(rename = "MILE")]
    #[cfg_attr(feature = "serde", serde(rename = "MILE"))]
    Mile,
    #[yaserde(rename = "KMET")]
    #[cfg_attr(feature = "serde", serde(rename = "KMET"))]
    Kmet,
    #[yaserde(rename = "YARD")]
    #[cfg_attr(feature = "serde", serde(rename = "YARD"))]
    Yard,
    #[yaserde(rename = "SQKI")]
    #[cfg_attr(feature = "serde", serde(rename = "SQKI"))]
    Sqki,
    #[yaserde(rename = "HECT")]
    #[cfg_attr(feature = "serde", serde(rename = "HECT"))]
    Hect,
    #[yaserde(rename = "ARES")]
    #[cfg_attr(feature = "serde", serde(rename = "ARES"))]
    Ares,
    #[yaserde(rename = "SMET")]
    #[cfg_attr(feature = "serde", serde(rename = "SMET"))]
    Smet,
    #[yaserde(rename = "SCMT")]
    #[cfg_attr(feature = "serde", serde(rename = "SCMT"))]
    Scmt,
    #[yaserde(rename = "SMIL")]
    #[cfg_attr(feature = "serde", serde(rename = "SMIL"))]
    Smil,
    #[yaserde(rename = "SQMI")]
    #[cfg_attr(feature = "serde", serde(rename = "SQMI"))]
    Sqmi,
    #[yaserde(rename = "SQYA")]
    #[cfg_attr(feature = "serde", serde(rename = "SQYA"))]
    Sqya,
    #[yaserde(rename = "SQFO")]
    #[cfg_attr(feature = "serde", serde(rename = "SQFO"))]
    Sqfo,
    #[yaserde(rename = "SQIN")]
    #[cfg_attr(feature = "serde", serde(rename = "SQIN"))]
    Sqin,
    #[yaserde(rename = "ACRE")]
    #[cfg_attr(feature = "serde", serde(rename = "ACRE"))]
    Acre,
    #[yaserde(rename = "KWHO")]
    #[cfg_attr(feature = "serde", serde(rename = "KWHO"))]
    Kwho,
    #[yaserde(rename = "DGEU")]
    #[cfg_attr(feature = "serde", serde(rename = "DGEU"))]
    Dgeu,
    #[yaserde(rename = "GGEU")]
    #[cfg_attr(feature = "serde", serde(rename = "GGEU"))]
    Ggeu,
    __Unknown__(String),
}

impl Default for UnitOfMeasure6Code {
    fn default() -> UnitOfMeasure6Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for UnitOfMeasure6Code {}



#[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.025.001.01")]

pub enum UserInterface4Code {
    #[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,
    __Unknown__(String),
}

impl Default for UserInterface4Code {
    fn default() -> UserInterface4Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for UserInterface4Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.025.001.01")]
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.025.001.01")]
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.025.001.01")]

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 = "025";
    const VARIANT: &'static str = "001";
    const VERSION: &'static str = "01";
    const MESSAGE_NAME: &'static str = "caaa.025.001.01";
    const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:caaa.025.001.01";
}