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.001.001.15")]
pub struct AcceptorAuthorisationRequest15 {
    #[yaserde(rename = "Envt")]
    #[cfg_attr(feature = "serde", serde(rename = "Envt"))]
    pub envt: CardPaymentEnvironment82,

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

    #[yaserde(rename = "Tx")]
    #[cfg_attr(feature = "serde", serde(rename = "Tx"))]
    pub tx: CardPaymentTransaction146,

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

impl Validate for AcceptorAuthorisationRequest15 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.001.001.15")]
pub struct AcceptorAuthorisationRequestV15 {
    #[yaserde(rename = "Hdr")]
    #[cfg_attr(feature = "serde", serde(rename = "Hdr"))]
    pub hdr: Header70,

    #[yaserde(rename = "AuthstnReq")]
    #[cfg_attr(feature = "serde", serde(rename = "AuthstnReq"))]
    pub authstn_req: AcceptorAuthorisationRequest15,

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

impl Validate for AcceptorAuthorisationRequestV15 {}


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

pub enum AccountChoiceMethod1Code {
    #[yaserde(rename = "ACSL")]
    #[cfg_attr(feature = "serde", serde(rename = "ACSL"))]
    Acsl,
    #[yaserde(rename = "ENTR")]
    #[cfg_attr(feature = "serde", serde(rename = "ENTR"))]
    Entr,
    #[yaserde(rename = "IMAC")]
    #[cfg_attr(feature = "serde", serde(rename = "IMAC"))]
    Imac,
    #[yaserde(rename = "IMPL")]
    #[cfg_attr(feature = "serde", serde(rename = "IMPL"))]
    Impl,
    #[yaserde(rename = "NOSL")]
    #[cfg_attr(feature = "serde", serde(rename = "NOSL"))]
    Nosl,
    #[yaserde(rename = "TPSL")]
    #[cfg_attr(feature = "serde", serde(rename = "TPSL"))]
    Tpsl,
    __Unknown__(String),
}

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

impl Validate for AccountChoiceMethod1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.001.001.15")]
pub struct AccountIdentification4Choice {
    #[yaserde(rename = "IBAN")]
    #[cfg_attr(feature = "serde", serde(rename = "IBAN"))]
    pub iban: Option<Iban2007Identifier>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<GenericAccountIdentification1>,
}

impl Validate for AccountIdentification4Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.001.001.15")]
pub struct AccountIdentification54Choice {
    #[yaserde(rename = "Card")]
    #[cfg_attr(feature = "serde", serde(rename = "Card"))]
    pub card: Option<Min8Max28NumericText>,
    #[yaserde(rename = "MSISDN")]
    #[cfg_attr(feature = "serde", serde(rename = "MSISDN"))]
    pub msisdn: Option<Max16Text>,
    #[yaserde(rename = "EMail")]
    #[cfg_attr(feature = "serde", serde(rename = "EMail"))]
    pub email: Option<Max256Text>,
    #[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 = "Dmst")]
    #[cfg_attr(feature = "serde", serde(rename = "Dmst"))]
    pub dmst: Option<Max35Text>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<Max35Text>,
}

impl Validate for AccountIdentification54Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.001.001.15")]
pub struct AccountSchemeName1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ExternalAccountIdentification1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max35Text>,
}

impl Validate for AccountSchemeName1Choice {}




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

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

    #[yaserde(rename = "RmotAccs")]
    #[cfg_attr(feature = "serde", serde(rename = "RmotAccs"))]
    pub rmot_accs: NetworkParameters7,

    #[yaserde(rename = "Rtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Rtry"))]
    pub rtry: ProcessRetry3,

    #[yaserde(rename = "TmCond")]
    #[cfg_attr(feature = "serde", serde(rename = "TmCond"))]
    pub tm_cond: ProcessTiming6,
}

impl Validate for Action18 {}


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

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

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

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


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

pub enum ActionType15Code {
    #[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,
    #[yaserde(rename = "STAR")]
    #[cfg_attr(feature = "serde", serde(rename = "STAR"))]
    Star,
    #[yaserde(rename = "STOR")]
    #[cfg_attr(feature = "serde", serde(rename = "STOR"))]
    Stor,
    #[yaserde(rename = "ACUP")]
    #[cfg_attr(feature = "serde", serde(rename = "ACUP"))]
    Acup,
    #[yaserde(rename = "TALT")]
    #[cfg_attr(feature = "serde", serde(rename = "TALT"))]
    Talt,
    #[yaserde(rename = "DNTA")]
    #[cfg_attr(feature = "serde", serde(rename = "DNTA"))]
    Dnta,
    #[yaserde(rename = "NCOF")]
    #[cfg_attr(feature = "serde", serde(rename = "NCOF"))]
    Ncof,
    __Unknown__(String),
}

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

impl Validate for ActionType15Code {}



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

impl Validate for ActiveCurrencyAndAmountSimpleType {
    fn validate(&self) -> Result<(), String> { 
        if self.0 < "0".parse::<String>().unwrap() {
            return Err(format!("MinInclusive validation error: invalid value of 0! \nExpected: 0 >= 0.\nActual: 0 == {}", self.0));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.001.001.15")]
pub struct ActiveCurrencyAndAmount {
    #[yaserde(text)]
    pub value: String,
    #[yaserde(attribute, rename = "Ccy")]
    #[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
    pub ccy: ActiveCurrencyCode,
}

impl Validate for ActiveCurrencyAndAmount {}


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

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

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

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.001.001.15")]
pub struct AddressType3Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<AddressType2Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification30>,
}

impl Validate for AddressType3Choice {}




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

pub enum Algorithm26Code {
    #[yaserde(rename = "HS25")]
    #[cfg_attr(feature = "serde", serde(rename = "HS25"))]
    Hs25,
    #[yaserde(rename = "HS38")]
    #[cfg_attr(feature = "serde", serde(rename = "HS38"))]
    Hs38,
    #[yaserde(rename = "HS51")]
    #[cfg_attr(feature = "serde", serde(rename = "HS51"))]
    Hs51,
    #[yaserde(rename = "HS01")]
    #[cfg_attr(feature = "serde", serde(rename = "HS01"))]
    Hs01,
    #[yaserde(rename = "SH31")]
    #[cfg_attr(feature = "serde", serde(rename = "SH31"))]
    Sh31,
    #[yaserde(rename = "SH32")]
    #[cfg_attr(feature = "serde", serde(rename = "SH32"))]
    Sh32,
    #[yaserde(rename = "SH33")]
    #[cfg_attr(feature = "serde", serde(rename = "SH33"))]
    Sh33,
    #[yaserde(rename = "SH35")]
    #[cfg_attr(feature = "serde", serde(rename = "SH35"))]
    Sh35,
    #[yaserde(rename = "SHK1")]
    #[cfg_attr(feature = "serde", serde(rename = "SHK1"))]
    Shk1,
    #[yaserde(rename = "SHK2")]
    #[cfg_attr(feature = "serde", serde(rename = "SHK2"))]
    Shk2,
    #[yaserde(rename = "SMS3")]
    #[cfg_attr(feature = "serde", serde(rename = "SMS3"))]
    Sms3,
    __Unknown__(String),
}

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

impl Validate for Algorithm26Code {}



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

pub enum Algorithm27Code {
    #[yaserde(rename = "MACC")]
    #[cfg_attr(feature = "serde", serde(rename = "MACC"))]
    Macc,
    #[yaserde(rename = "MCCS")]
    #[cfg_attr(feature = "serde", serde(rename = "MCCS"))]
    Mccs,
    #[yaserde(rename = "CMA1")]
    #[cfg_attr(feature = "serde", serde(rename = "CMA1"))]
    Cma1,
    #[yaserde(rename = "MCC1")]
    #[cfg_attr(feature = "serde", serde(rename = "MCC1"))]
    Mcc1,
    #[yaserde(rename = "CMA9")]
    #[cfg_attr(feature = "serde", serde(rename = "CMA9"))]
    Cma9,
    #[yaserde(rename = "CMA5")]
    #[cfg_attr(feature = "serde", serde(rename = "CMA5"))]
    Cma5,
    #[yaserde(rename = "CMA2")]
    #[cfg_attr(feature = "serde", serde(rename = "CMA2"))]
    Cma2,
    #[yaserde(rename = "CM31")]
    #[cfg_attr(feature = "serde", serde(rename = "CM31"))]
    Cm31,
    #[yaserde(rename = "CM32")]
    #[cfg_attr(feature = "serde", serde(rename = "CM32"))]
    Cm32,
    #[yaserde(rename = "CM33")]
    #[cfg_attr(feature = "serde", serde(rename = "CM33"))]
    Cm33,
    #[yaserde(rename = "MCS3")]
    #[cfg_attr(feature = "serde", serde(rename = "MCS3"))]
    Mcs3,
    #[yaserde(rename = "CCA1")]
    #[cfg_attr(feature = "serde", serde(rename = "CCA1"))]
    Cca1,
    #[yaserde(rename = "CCA2")]
    #[cfg_attr(feature = "serde", serde(rename = "CCA2"))]
    Cca2,
    #[yaserde(rename = "CCA3")]
    #[cfg_attr(feature = "serde", serde(rename = "CCA3"))]
    Cca3,
    S34C,
    S34R,
    __Unknown__(String),
}

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

impl Validate for Algorithm27Code {}



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

pub enum Algorithm28Code {
    #[yaserde(rename = "EA2C")]
    #[cfg_attr(feature = "serde", serde(rename = "EA2C"))]
    Ea2C,
    #[yaserde(rename = "E3DC")]
    #[cfg_attr(feature = "serde", serde(rename = "E3DC"))]
    E3Dc,
    #[yaserde(rename = "DKP9")]
    #[cfg_attr(feature = "serde", serde(rename = "DKP9"))]
    Dkp9,
    #[yaserde(rename = "UKPT")]
    #[cfg_attr(feature = "serde", serde(rename = "UKPT"))]
    Ukpt,
    #[yaserde(rename = "UKA2")]
    #[cfg_attr(feature = "serde", serde(rename = "UKA2"))]
    Uka2,
    #[yaserde(rename = "EA9C")]
    #[cfg_attr(feature = "serde", serde(rename = "EA9C"))]
    Ea9C,
    #[yaserde(rename = "EA5C")]
    #[cfg_attr(feature = "serde", serde(rename = "EA5C"))]
    Ea5C,
    #[yaserde(rename = "DA12")]
    #[cfg_attr(feature = "serde", serde(rename = "DA12"))]
    Da12,
    #[yaserde(rename = "DA19")]
    #[cfg_attr(feature = "serde", serde(rename = "DA19"))]
    Da19,
    #[yaserde(rename = "DA25")]
    #[cfg_attr(feature = "serde", serde(rename = "DA25"))]
    Da25,
    N108,
    #[yaserde(rename = "EA5R")]
    #[cfg_attr(feature = "serde", serde(rename = "EA5R"))]
    Ea5R,
    #[yaserde(rename = "EA9R")]
    #[cfg_attr(feature = "serde", serde(rename = "EA9R"))]
    Ea9R,
    #[yaserde(rename = "EA2R")]
    #[cfg_attr(feature = "serde", serde(rename = "EA2R"))]
    Ea2R,
    #[yaserde(rename = "E3DR")]
    #[cfg_attr(feature = "serde", serde(rename = "E3DR"))]
    E3Dr,
    E36C,
    E36R,
    #[yaserde(rename = "SD5C")]
    #[cfg_attr(feature = "serde", serde(rename = "SD5C"))]
    Sd5C,
    #[yaserde(rename = "UKA1")]
    #[cfg_attr(feature = "serde", serde(rename = "UKA1"))]
    Uka1,
    #[yaserde(rename = "UKA3")]
    #[cfg_attr(feature = "serde", serde(rename = "UKA3"))]
    Uka3,
    #[yaserde(rename = "SM4C")]
    #[cfg_attr(feature = "serde", serde(rename = "SM4C"))]
    Sm4C,
    #[yaserde(rename = "SM4R")]
    #[cfg_attr(feature = "serde", serde(rename = "SM4R"))]
    Sm4R,
    __Unknown__(String),
}

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

impl Validate for Algorithm28Code {}



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

pub enum Algorithm29Code {
    #[yaserde(rename = "ERS2")]
    #[cfg_attr(feature = "serde", serde(rename = "ERS2"))]
    Ers2,
    #[yaserde(rename = "ERS1")]
    #[cfg_attr(feature = "serde", serde(rename = "ERS1"))]
    Ers1,
    #[yaserde(rename = "RPSS")]
    #[cfg_attr(feature = "serde", serde(rename = "RPSS"))]
    Rpss,
    #[yaserde(rename = "ERS3")]
    #[cfg_attr(feature = "serde", serde(rename = "ERS3"))]
    Ers3,
    #[yaserde(rename = "ED32")]
    #[cfg_attr(feature = "serde", serde(rename = "ED32"))]
    Ed32,
    #[yaserde(rename = "ED33")]
    #[cfg_attr(feature = "serde", serde(rename = "ED33"))]
    Ed33,
    #[yaserde(rename = "ED35")]
    #[cfg_attr(feature = "serde", serde(rename = "ED35"))]
    Ed35,
    #[yaserde(rename = "ED23")]
    #[cfg_attr(feature = "serde", serde(rename = "ED23"))]
    Ed23,
    #[yaserde(rename = "ED25")]
    #[cfg_attr(feature = "serde", serde(rename = "ED25"))]
    Ed25,
    #[yaserde(rename = "ES22")]
    #[cfg_attr(feature = "serde", serde(rename = "ES22"))]
    Es22,
    #[yaserde(rename = "ES32")]
    #[cfg_attr(feature = "serde", serde(rename = "ES32"))]
    Es32,
    #[yaserde(rename = "ES33")]
    #[cfg_attr(feature = "serde", serde(rename = "ES33"))]
    Es33,
    #[yaserde(rename = "ES35")]
    #[cfg_attr(feature = "serde", serde(rename = "ES35"))]
    Es35,
    #[yaserde(rename = "ES23")]
    #[cfg_attr(feature = "serde", serde(rename = "ES23"))]
    Es23,
    #[yaserde(rename = "ES25")]
    #[cfg_attr(feature = "serde", serde(rename = "ES25"))]
    Es25,
    #[yaserde(rename = "ED22")]
    #[cfg_attr(feature = "serde", serde(rename = "ED22"))]
    Ed22,
    #[yaserde(rename = "EF32")]
    #[cfg_attr(feature = "serde", serde(rename = "EF32"))]
    Ef32,
    #[yaserde(rename = "EF22")]
    #[cfg_attr(feature = "serde", serde(rename = "EF22"))]
    Ef22,
    #[yaserde(rename = "EF33")]
    #[cfg_attr(feature = "serde", serde(rename = "EF33"))]
    Ef33,
    #[yaserde(rename = "EF35")]
    #[cfg_attr(feature = "serde", serde(rename = "EF35"))]
    Ef35,
    #[yaserde(rename = "EF23")]
    #[cfg_attr(feature = "serde", serde(rename = "EF23"))]
    Ef23,
    #[yaserde(rename = "EO33")]
    #[cfg_attr(feature = "serde", serde(rename = "EO33"))]
    Eo33,
    #[yaserde(rename = "EF25")]
    #[cfg_attr(feature = "serde", serde(rename = "EF25"))]
    Ef25,
    #[yaserde(rename = "EO32")]
    #[cfg_attr(feature = "serde", serde(rename = "EO32"))]
    Eo32,
    #[yaserde(rename = "EO22")]
    #[cfg_attr(feature = "serde", serde(rename = "EO22"))]
    Eo22,
    #[yaserde(rename = "EO35")]
    #[cfg_attr(feature = "serde", serde(rename = "EO35"))]
    Eo35,
    #[yaserde(rename = "EO23")]
    #[cfg_attr(feature = "serde", serde(rename = "EO23"))]
    Eo23,
    #[yaserde(rename = "EO25")]
    #[cfg_attr(feature = "serde", serde(rename = "EO25"))]
    Eo25,
    #[yaserde(rename = "DD22")]
    #[cfg_attr(feature = "serde", serde(rename = "DD22"))]
    Dd22,
    #[yaserde(rename = "DD32")]
    #[cfg_attr(feature = "serde", serde(rename = "DD32"))]
    Dd32,
    #[yaserde(rename = "DD33")]
    #[cfg_attr(feature = "serde", serde(rename = "DD33"))]
    Dd33,
    #[yaserde(rename = "DD35")]
    #[cfg_attr(feature = "serde", serde(rename = "DD35"))]
    Dd35,
    #[yaserde(rename = "DD23")]
    #[cfg_attr(feature = "serde", serde(rename = "DD23"))]
    Dd23,
    #[yaserde(rename = "DD25")]
    #[cfg_attr(feature = "serde", serde(rename = "DD25"))]
    Dd25,
    #[yaserde(rename = "SM22")]
    #[cfg_attr(feature = "serde", serde(rename = "SM22"))]
    Sm22,
    #[yaserde(rename = "SM33")]
    #[cfg_attr(feature = "serde", serde(rename = "SM33"))]
    Sm33,
    #[yaserde(rename = "SM32")]
    #[cfg_attr(feature = "serde", serde(rename = "SM32"))]
    Sm32,
    #[yaserde(rename = "SM35")]
    #[cfg_attr(feature = "serde", serde(rename = "SM35"))]
    Sm35,
    #[yaserde(rename = "SM23")]
    #[cfg_attr(feature = "serde", serde(rename = "SM23"))]
    Sm23,
    #[yaserde(rename = "SM25")]
    #[cfg_attr(feature = "serde", serde(rename = "SM25"))]
    Sm25,
    S2S3,
    __Unknown__(String),
}

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

impl Validate for Algorithm29Code {}



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

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

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.001.001.15")]
pub struct AlgorithmIdentification31 {
    #[yaserde(rename = "Algo")]
    #[cfg_attr(feature = "serde", serde(rename = "Algo"))]
    pub algo: Algorithm27Code,

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

impl Validate for AlgorithmIdentification31 {}


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

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

impl Validate for AlgorithmIdentification32 {}


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

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

impl Validate for AlgorithmIdentification33 {}


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

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

impl Validate for AlgorithmIdentification34 {}


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

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

impl Validate for AlgorithmIdentification35 {}


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

impl Validate for AlgorithmIdentification36 {}


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

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

impl Validate for Amount5 {}


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

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

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

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

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.001.001.15")]
pub struct AuthenticatedData10 {
    #[yaserde(rename = "Vrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Vrsn"))]
    pub vrsn: Number,

    #[yaserde(rename = "Rcpt")]
    #[cfg_attr(feature = "serde", serde(rename = "Rcpt"))]
    pub rcpt: Vec<Recipient15Choice>,

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

    #[yaserde(rename = "NcpsltdCntt")]
    #[cfg_attr(feature = "serde", serde(rename = "NcpsltdCntt"))]
    pub ncpsltd_cntt: EncapsulatedContent3,

    #[yaserde(rename = "MAC")]
    #[cfg_attr(feature = "serde", serde(rename = "MAC"))]
    pub mac: Max140Binary,
}

impl Validate for AuthenticatedData10 {}


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

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

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

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

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

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

impl Validate for BaseOneRate {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.001.001.15")]
pub struct BinRange1 {
    #[yaserde(rename = "LwrBin")]
    #[cfg_attr(feature = "serde", serde(rename = "LwrBin"))]
    pub lwr_bin: Max15NumericText,

    #[yaserde(rename = "HghrBin")]
    #[cfg_attr(feature = "serde", serde(rename = "HghrBin"))]
    pub hghr_bin: Max15NumericText,
}

impl Validate for BinRange1 {}


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

pub enum BusinessArea2Code {
    #[yaserde(rename = "AIBD")]
    #[cfg_attr(feature = "serde", serde(rename = "AIBD"))]
    Aibd,
    #[yaserde(rename = "PPAY")]
    #[cfg_attr(feature = "serde", serde(rename = "PPAY"))]
    Ppay,
    #[yaserde(rename = "TKNF")]
    #[cfg_attr(feature = "serde", serde(rename = "TKNF"))]
    Tknf,
    #[yaserde(rename = "EOPT")]
    #[cfg_attr(feature = "serde", serde(rename = "EOPT"))]
    Eopt,
    #[yaserde(rename = "TOPT")]
    #[cfg_attr(feature = "serde", serde(rename = "TOPT"))]
    Topt,
    __Unknown__(String),
}

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

impl Validate for BusinessArea2Code {}



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

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.001.001.15")]
pub struct CardAccount16 {
    #[yaserde(rename = "SelctnMtd")]
    #[cfg_attr(feature = "serde", serde(rename = "SelctnMtd"))]
    pub selctn_mtd: AccountChoiceMethod1Code,

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

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

    #[yaserde(rename = "AcctOwnr")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctOwnr"))]
    pub acct_ownr: NameAndAddress3,

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

    #[yaserde(rename = "AcctIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctIdr"))]
    pub acct_idr: AccountIdentification54Choice,

    #[yaserde(rename = "Svcr")]
    #[cfg_attr(feature = "serde", serde(rename = "Svcr"))]
    pub svcr: PartyIdentification177Choice,
}

impl Validate for CardAccount16 {}


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

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

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

pub enum CardDataReading8Code {
    #[yaserde(rename = "TAGC")]
    #[cfg_attr(feature = "serde", serde(rename = "TAGC"))]
    Tagc,
    #[yaserde(rename = "PHYS")]
    #[cfg_attr(feature = "serde", serde(rename = "PHYS"))]
    Phys,
    #[yaserde(rename = "BRCD")]
    #[cfg_attr(feature = "serde", serde(rename = "BRCD"))]
    Brcd,
    #[yaserde(rename = "MGST")]
    #[cfg_attr(feature = "serde", serde(rename = "MGST"))]
    Mgst,
    #[yaserde(rename = "CICC")]
    #[cfg_attr(feature = "serde", serde(rename = "CICC"))]
    Cicc,
    #[yaserde(rename = "DFLE")]
    #[cfg_attr(feature = "serde", serde(rename = "DFLE"))]
    Dfle,
    #[yaserde(rename = "CTLS")]
    #[cfg_attr(feature = "serde", serde(rename = "CTLS"))]
    Ctls,
    #[yaserde(rename = "ECTL")]
    #[cfg_attr(feature = "serde", serde(rename = "ECTL"))]
    Ectl,
    #[yaserde(rename = "CDFL")]
    #[cfg_attr(feature = "serde", serde(rename = "CDFL"))]
    Cdfl,
    #[yaserde(rename = "SICC")]
    #[cfg_attr(feature = "serde", serde(rename = "SICC"))]
    Sicc,
    #[yaserde(rename = "UNKW")]
    #[cfg_attr(feature = "serde", serde(rename = "UNKW"))]
    Unkw,
    #[yaserde(rename = "QRCD")]
    #[cfg_attr(feature = "serde", serde(rename = "QRCD"))]
    Qrcd,
    #[yaserde(rename = "OPTC")]
    #[cfg_attr(feature = "serde", serde(rename = "OPTC"))]
    Optc,
    __Unknown__(String),
}

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

impl Validate for CardDataReading8Code {}



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

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

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

    #[yaserde(rename = "SvcPrvdr")]
    #[cfg_attr(feature = "serde", serde(rename = "SvcPrvdr"))]
    pub svc_prvdr: Acquirer10,

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

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

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

    #[yaserde(rename = "Chck")]
    #[cfg_attr(feature = "serde", serde(rename = "Chck"))]
    pub chck: Check1,

    #[yaserde(rename = "StordValAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "StordValAcct"))]
    pub stord_val_acct: Vec<StoredValueAccount2>,

    #[yaserde(rename = "LltyAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "LltyAcct"))]
    pub llty_acct: Vec<LoyaltyAccount3>,

    #[yaserde(rename = "CstmrDvc")]
    #[cfg_attr(feature = "serde", serde(rename = "CstmrDvc"))]
    pub cstmr_dvc: CustomerDevice3,

    #[yaserde(rename = "Wllt")]
    #[cfg_attr(feature = "serde", serde(rename = "Wllt"))]
    pub wllt: CustomerDevice3,

    #[yaserde(rename = "PmtTkn")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtTkn"))]
    pub pmt_tkn: Token1,

    #[yaserde(rename = "MrchntTkn")]
    #[cfg_attr(feature = "serde", serde(rename = "MrchntTkn"))]
    pub mrchnt_tkn: MerchantToken2,

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

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

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

impl Validate for CardPaymentEnvironment82 {}


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

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

pub enum CardPaymentServiceType15Code {
    #[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,
    #[yaserde(rename = "GOPT")]
    #[cfg_attr(feature = "serde", serde(rename = "GOPT"))]
    Gopt,
    #[yaserde(rename = "DFCL")]
    #[cfg_attr(feature = "serde", serde(rename = "DFCL"))]
    Dfcl,
    __Unknown__(String),
}

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

impl Validate for CardPaymentServiceType15Code {}



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

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.001.001.15")]
pub struct CardPaymentTransaction146 {
    #[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: 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: CardPaymentServiceType15Code,

    #[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 = "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 = "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: CardPaymentTransaction149,

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

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

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

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

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

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

    #[yaserde(rename = "AcctFr")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctFr"))]
    pub acct_fr: CardAccount16,

    #[yaserde(rename = "AcctTo")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctTo"))]
    pub acct_to: CardAccount16,

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

    #[yaserde(rename = "MsgFrMrchnt")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgFrMrchnt"))]
    pub msg_fr_mrchnt: Vec<Action18>,
}

impl Validate for CardPaymentTransaction146 {}


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

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

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

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

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

    #[yaserde(rename = "TxRslt")]
    #[cfg_attr(feature = "serde", serde(rename = "TxRslt"))]
    pub tx_rslt: CardPaymentTransactionResult4,
}

impl Validate for CardPaymentTransaction149 {}


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

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

    #[yaserde(rename = "Instlmt")]
    #[cfg_attr(feature = "serde", serde(rename = "Instlmt"))]
    pub instlmt: Vec<Instalment7>,

    #[yaserde(rename = "Rcrng")]
    #[cfg_attr(feature = "serde", serde(rename = "Rcrng"))]
    pub rcrng: RecurringTransaction7,

    #[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 = "ReSubmissnCntr")]
    #[cfg_attr(feature = "serde", serde(rename = "ReSubmissnCntr"))]
    pub re_submissn_cntr: PositiveNumber,

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

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

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

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

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

impl Validate for CardPaymentTransactionDetails54 {}


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

impl Validate for CardPaymentTransactionResult4 {}


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

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.001.001.15")]
pub struct Cardholder21 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: PersonIdentification15,

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

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

    #[yaserde(rename = "BllgAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "BllgAdr"))]
    pub bllg_adr: PostalAddress22,

    #[yaserde(rename = "ShppgAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "ShppgAdr"))]
    pub shppg_adr: PostalAddress22,

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

    #[yaserde(rename = "Vhcl")]
    #[cfg_attr(feature = "serde", serde(rename = "Vhcl"))]
    pub vhcl: Vehicle1,

    #[yaserde(rename = "Authntcn")]
    #[cfg_attr(feature = "serde", serde(rename = "Authntcn"))]
    pub authntcn: Vec<CardholderAuthentication17>,

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

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

    #[yaserde(rename = "MobData")]
    #[cfg_attr(feature = "serde", serde(rename = "MobData"))]
    pub mob_data: Vec<MobileData6>,
}

impl Validate for Cardholder21 {}


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

    #[yaserde(rename = "AuthntcnXmptn")]
    #[cfg_attr(feature = "serde", serde(rename = "AuthntcnXmptn"))]
    pub authntcn_xmptn: Exemption1Code,

    #[yaserde(rename = "AuthntcnVal")]
    #[cfg_attr(feature = "serde", serde(rename = "AuthntcnVal"))]
    pub authntcn_val: Max5000Binary,

    #[yaserde(rename = "PrtctdAuthntcnVal")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtctdAuthntcnVal"))]
    pub prtctd_authntcn_val: ContentInformationType40,

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

    #[yaserde(rename = "CrdhldrId")]
    #[cfg_attr(feature = "serde", serde(rename = "CrdhldrId"))]
    pub crdhldr_id: PersonIdentification15,

    #[yaserde(rename = "AdrVrfctn")]
    #[cfg_attr(feature = "serde", serde(rename = "AdrVrfctn"))]
    pub adr_vrfctn: AddressVerification1,

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

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

    #[yaserde(rename = "AuthntcnRslt")]
    #[cfg_attr(feature = "serde", serde(rename = "AuthntcnRslt"))]
    pub authntcn_rslt: AuthenticationResult1Code,

    #[yaserde(rename = "AuthntcnAddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AuthntcnAddtlInf"))]
    pub authntcn_addtl_inf: ExternallyDefinedData5,
}

impl Validate for CardholderAuthentication17 {}


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

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.001.001.15")]
pub struct CashAccount40 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: AccountIdentification4Choice,

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

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

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

    #[yaserde(rename = "Prxy")]
    #[cfg_attr(feature = "serde", serde(rename = "Prxy"))]
    pub prxy: ProxyAccountIdentification1,
}

impl Validate for CashAccount40 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.001.001.15")]
pub struct CashAccountType2Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ExternalCashAccountType1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max35Text>,
}

impl Validate for CashAccountType2Choice {}




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

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.001.001.15")]
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.001.001.15")]
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.001.001.15")]
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.001.001.15")]
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.001.001.15")]
pub struct Contact13 {
    #[yaserde(rename = "NmPrfx")]
    #[cfg_attr(feature = "serde", serde(rename = "NmPrfx"))]
    pub nm_prfx: NamePrefix2Code,

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

    #[yaserde(rename = "PhneNb")]
    #[cfg_attr(feature = "serde", serde(rename = "PhneNb"))]
    pub phne_nb: PhoneNumber,

    #[yaserde(rename = "MobNb")]
    #[cfg_attr(feature = "serde", serde(rename = "MobNb"))]
    pub mob_nb: PhoneNumber,

    #[yaserde(rename = "FaxNb")]
    #[cfg_attr(feature = "serde", serde(rename = "FaxNb"))]
    pub fax_nb: PhoneNumber,

    #[yaserde(rename = "URLAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "URLAdr"))]
    pub url_adr: Max2048Text,

    #[yaserde(rename = "EmailAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "EmailAdr"))]
    pub email_adr: Max256Text,

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

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

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

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

    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Vec<OtherContact1>,

    #[yaserde(rename = "PrefrdMtd")]
    #[cfg_attr(feature = "serde", serde(rename = "PrefrdMtd"))]
    pub prefrd_mtd: PreferredContactMethod2Code,
}

impl Validate for Contact13 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.001.001.15")]
pub struct ContentInformationType37 {
    #[yaserde(rename = "CnttTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CnttTp"))]
    pub cntt_tp: ContentType2Code,

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

impl Validate for ContentInformationType37 {}


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

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

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

impl Validate for ContentInformationType38 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.001.001.15")]
pub struct ContentInformationType39 {
    #[yaserde(rename = "CnttTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CnttTp"))]
    pub cntt_tp: ContentType2Code,

    #[yaserde(rename = "EnvlpdData")]
    #[cfg_attr(feature = "serde", serde(rename = "EnvlpdData"))]
    pub envlpd_data: EnvelopedData11,

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

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

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

impl Validate for ContentInformationType39 {}


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

    #[yaserde(rename = "EnvlpdData")]
    #[cfg_attr(feature = "serde", serde(rename = "EnvlpdData"))]
    pub envlpd_data: EnvelopedData11,
}

impl Validate for ContentInformationType40 {}


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

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.001.001.15")]
pub struct CreditTransferContext1 {
    #[yaserde(rename = "AutomtcNtfctnOfCshMvmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "AutomtcNtfctnOfCshMvmnt"))]
    pub automtc_ntfctn_of_csh_mvmnt: TrueFalseIndicator,

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

    #[yaserde(rename = "SysToNtfy")]
    #[cfg_attr(feature = "serde", serde(rename = "SysToNtfy"))]
    pub sys_to_ntfy: Max1025Text,

    #[yaserde(rename = "Dbtr")]
    #[cfg_attr(feature = "serde", serde(rename = "Dbtr"))]
    pub dbtr: PartyIdentification272,

    #[yaserde(rename = "DbtrAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "DbtrAcct"))]
    pub dbtr_acct: CashAccount40,

    #[yaserde(rename = "PrtctdDbtrAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtctdDbtrAcct"))]
    pub prtctd_dbtr_acct: ContentInformationType39,

    #[yaserde(rename = "Cdtr")]
    #[cfg_attr(feature = "serde", serde(rename = "Cdtr"))]
    pub cdtr: PartyIdentification272,

    #[yaserde(rename = "CdtrAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtrAcct"))]
    pub cdtr_acct: CashAccount40,

    #[yaserde(rename = "PrtctdCdtrAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtctdCdtrAcct"))]
    pub prtctd_cdtr_acct: ContentInformationType39,
}

impl Validate for CreditTransferContext1 {}


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

    #[yaserde(rename = "KeyId")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyId"))]
    pub key_id: Max350Text,

    #[yaserde(rename = "AddtlId")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlId"))]
    pub addtl_id: Max35Binary,

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

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

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

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

    #[yaserde(rename = "Vrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Vrsn"))]
    pub vrsn: Max256Text,

    #[yaserde(rename = "KeyVrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyVrsn"))]
    pub key_vrsn: Max256Text,

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

    #[yaserde(rename = "Fctn")]
    #[cfg_attr(feature = "serde", serde(rename = "Fctn"))]
    pub fctn: Vec<KeyUsage1Code>,

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

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

    #[yaserde(rename = "KeyVal")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyVal"))]
    pub key_val: ContentInformationType39,

    #[yaserde(rename = "CmpntWthAuthrsdAccs")]
    #[cfg_attr(feature = "serde", serde(rename = "CmpntWthAuthrsdAccs"))]
    pub cmpnt_wth_authrsd_accs: Vec<GenericIdentification186>,

    #[yaserde(rename = "PrtctdCmpntWthAuthrsdAccs")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtctdCmpntWthAuthrsdAccs"))]
    pub prtctd_cmpnt_wth_authrsd_accs: Vec<ContentInformationType39>,

    #[yaserde(rename = "KeyChckVal")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyChckVal"))]
    pub key_chck_val: Max35Binary,

    #[yaserde(rename = "AddtlMgmtInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlMgmtInf"))]
    pub addtl_mgmt_inf: Vec<GenericInformation1>,

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

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

impl Validate for CryptographicKey19 {}


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

pub enum CryptographicKeyType5Code {
    #[yaserde(rename = "AES2")]
    #[cfg_attr(feature = "serde", serde(rename = "AES2"))]
    Aes2,
    #[yaserde(rename = "EDE3")]
    #[cfg_attr(feature = "serde", serde(rename = "EDE3"))]
    Ede3,
    #[yaserde(rename = "DKP9")]
    #[cfg_attr(feature = "serde", serde(rename = "DKP9"))]
    Dkp9,
    #[yaserde(rename = "AES9")]
    #[cfg_attr(feature = "serde", serde(rename = "AES9"))]
    Aes9,
    #[yaserde(rename = "AES5")]
    #[cfg_attr(feature = "serde", serde(rename = "AES5"))]
    Aes5,
    #[yaserde(rename = "EDE4")]
    #[cfg_attr(feature = "serde", serde(rename = "EDE4"))]
    Ede4,
    #[yaserde(rename = "UKA2")]
    #[cfg_attr(feature = "serde", serde(rename = "UKA2"))]
    Uka2,
    #[yaserde(rename = "UKA6")]
    #[cfg_attr(feature = "serde", serde(rename = "UKA6"))]
    Uka6,
    #[yaserde(rename = "RSAC")]
    #[cfg_attr(feature = "serde", serde(rename = "RSAC"))]
    Rsac,
    #[yaserde(rename = "ECCC")]
    #[cfg_attr(feature = "serde", serde(rename = "ECCC"))]
    Eccc,
    #[yaserde(rename = "DKAE")]
    #[cfg_attr(feature = "serde", serde(rename = "DKAE"))]
    Dkae,
    #[yaserde(rename = "UKA8")]
    #[cfg_attr(feature = "serde", serde(rename = "UKA8"))]
    Uka8,
    __Unknown__(String),
}

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

impl Validate for CryptographicKeyType5Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.001.001.15")]
pub struct CurrencyConversion34 {
    #[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 = "VldFr")]
    #[cfg_attr(feature = "serde", serde(rename = "VldFr"))]
    pub vld_fr: 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 = "AplblBinRg")]
    #[cfg_attr(feature = "serde", serde(rename = "AplblBinRg"))]
    pub aplbl_bin_rg: Vec<BinRange1>,

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

impl Validate for CurrencyConversion34 {}


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

impl Validate for CurrencyConversion35 {}


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

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

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

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

impl Validate for DateAndPlaceOfBirth1 {}


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

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

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

    #[yaserde(rename = "NcpsltdCntt")]
    #[cfg_attr(feature = "serde", serde(rename = "NcpsltdCntt"))]
    pub ncpsltd_cntt: EncapsulatedContent3,

    #[yaserde(rename = "Dgst")]
    #[cfg_attr(feature = "serde", serde(rename = "Dgst"))]
    pub dgst: Max140Binary,
}

impl Validate for DigestedData6 {}


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

    #[yaserde(rename = "DbtrAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "DbtrAcct"))]
    pub dbtr_acct: CashAccount40,

    #[yaserde(rename = "PrtctdDbtrAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtctdDbtrAcct"))]
    pub prtctd_dbtr_acct: ContentInformationType39,

    #[yaserde(rename = "Cdtr")]
    #[cfg_attr(feature = "serde", serde(rename = "Cdtr"))]
    pub cdtr: PartyIdentification272,

    #[yaserde(rename = "CdtrAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtrAcct"))]
    pub cdtr_acct: CashAccount40,

    #[yaserde(rename = "PrtctdCdtrAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtctdCdtrAcct"))]
    pub prtctd_cdtr_acct: ContentInformationType39,

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

impl Validate for DirectDebitContext1 {}


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

    #[yaserde(rename = "AvlblFrmt")]
    #[cfg_attr(feature = "serde", serde(rename = "AvlblFrmt"))]
    pub avlbl_frmt: Vec<OutputFormat1Code>,

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

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

    #[yaserde(rename = "AvlblLang")]
    #[cfg_attr(feature = "serde", serde(rename = "AvlblLang"))]
    pub avlbl_lang: Vec<LanguageCode>,
}

impl Validate for DisplayCapabilities7 {}


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

impl Validate for Document {}


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

    #[yaserde(rename = "CnttNcrptnAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "CnttNcrptnAlgo"))]
    pub cntt_ncrptn_algo: AlgorithmIdentification32,

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

impl Validate for EncryptedContent7 {}


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

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.001.001.15")]
pub struct EnvelopedData11 {
    #[yaserde(rename = "Vrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Vrsn"))]
    pub vrsn: Number,

    #[yaserde(rename = "OrgtrInf")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgtrInf"))]
    pub orgtr_inf: OriginatorInformation1,

    #[yaserde(rename = "Rcpt")]
    #[cfg_attr(feature = "serde", serde(rename = "Rcpt"))]
    pub rcpt: Vec<Recipient15Choice>,

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

impl Validate for EnvelopedData11 {}


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

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

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

impl Validate for Exact4AlphaNumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct 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.001.001.15")]

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)]
pub struct ExternalAccountIdentification1Code (pub String);
crate::simple_type!(ExternalAccountIdentification1Code);

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

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

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

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

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

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

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

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

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

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

    #[yaserde(rename = "Val")]
    #[cfg_attr(feature = "serde", serde(rename = "Val"))]
    pub val: Max100KBinary,

    #[yaserde(rename = "PrtctdVal")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtctdVal"))]
    pub prtctd_val: ContentInformationType39,

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

impl Validate for ExternallyDefinedData5 {}


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

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.001.001.15")]
pub struct GenericAccountIdentification1 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max34Text,

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

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

impl Validate for GenericAccountIdentification1 {}


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

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

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

impl Validate for GenericIdentification1 {}


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

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

impl Validate for GenericIdentification186 {}


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

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

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

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

impl Validate for GenericIdentification192 {}


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

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

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

impl Validate for GenericIdentification30 {}


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

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

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

impl Validate for GenericOrganisationIdentification3 {}


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

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

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

impl Validate for GenericPersonIdentification2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.001.001.15")]
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.001.001.15")]
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.001.001.15")]
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.001.001.15")]
pub struct GracePeriod1 {
    #[yaserde(rename = "Tm")]
    #[cfg_attr(feature = "serde", serde(rename = "Tm"))]
    pub tm: Max3NumericText,

    #[yaserde(rename = "UnitTp")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitTp"))]
    pub unit_tp: GracePeriodUnitType1Code,

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

impl Validate for GracePeriod1 {}


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

pub enum GracePeriodUnitType1Code {
    #[yaserde(rename = "WEKS")]
    #[cfg_attr(feature = "serde", serde(rename = "WEKS"))]
    Weks,
    #[yaserde(rename = "PMTS")]
    #[cfg_attr(feature = "serde", serde(rename = "PMTS"))]
    Pmts,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "MNTH")]
    #[cfg_attr(feature = "serde", serde(rename = "MNTH"))]
    Mnth,
    #[yaserde(rename = "DAYS")]
    #[cfg_attr(feature = "serde", serde(rename = "DAYS"))]
    Days,
    __Unknown__(String),
}

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

impl Validate for GracePeriodUnitType1Code {}



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

    #[yaserde(rename = "PrtcolVrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtcolVrsn"))]
    pub prtcol_vrsn: Max6Text,

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

    #[yaserde(rename = "ReTrnsmssnCntr")]
    #[cfg_attr(feature = "serde", serde(rename = "ReTrnsmssnCntr"))]
    pub re_trnsmssn_cntr: Max3NumericText,

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

    #[yaserde(rename = "InitgPty")]
    #[cfg_attr(feature = "serde", serde(rename = "InitgPty"))]
    pub initg_pty: GenericIdentification176,

    #[yaserde(rename = "RcptPty")]
    #[cfg_attr(feature = "serde", serde(rename = "RcptPty"))]
    pub rcpt_pty: GenericIdentification177,

    #[yaserde(rename = "Tracblt")]
    #[cfg_attr(feature = "serde", serde(rename = "Tracblt"))]
    pub tracblt: Vec<Traceability8>,
}

impl Validate for Header70 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct 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.001.001.15")]

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

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

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

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

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

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

    #[yaserde(rename = "DtldChrgs")]
    #[cfg_attr(feature = "serde", serde(rename = "DtldChrgs"))]
    pub dtld_chrgs: Vec<InstalmentAmountDetails1>,

    #[yaserde(rename = "IntrstRate")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstRate"))]
    pub intrst_rate: Vec<InterestRateDetails1>,

    #[yaserde(rename = "GracePrd")]
    #[cfg_attr(feature = "serde", serde(rename = "GracePrd"))]
    pub grace_prd: Vec<GracePeriod1>,

    #[yaserde(rename = "PlanNtce")]
    #[cfg_attr(feature = "serde", serde(rename = "PlanNtce"))]
    pub plan_ntce: Vec<ActionMessage12>,
}

impl Validate for Instalment7 {}


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

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

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

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

    #[yaserde(rename = "Pctg")]
    #[cfg_attr(feature = "serde", serde(rename = "Pctg"))]
    pub pctg: PercentageRate,
}

impl Validate for InstalmentAmountDetails1 {}


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

pub enum InstalmentAmountDetailsType1Code {
    #[yaserde(rename = "TAXX")]
    #[cfg_attr(feature = "serde", serde(rename = "TAXX"))]
    Taxx,
    #[yaserde(rename = "RQST")]
    #[cfg_attr(feature = "serde", serde(rename = "RQST"))]
    Rqst,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHC")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHC"))]
    Othc,
    #[yaserde(rename = "INSU")]
    #[cfg_attr(feature = "serde", serde(rename = "INSU"))]
    Insu,
    #[yaserde(rename = "FUNA")]
    #[cfg_attr(feature = "serde", serde(rename = "FUNA"))]
    Funa,
    #[yaserde(rename = "FEES")]
    #[cfg_attr(feature = "serde", serde(rename = "FEES"))]
    Fees,
    #[yaserde(rename = "EXPN")]
    #[cfg_attr(feature = "serde", serde(rename = "EXPN"))]
    Expn,
    #[yaserde(rename = "AFCO")]
    #[cfg_attr(feature = "serde", serde(rename = "AFCO"))]
    Afco,
    __Unknown__(String),
}

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

impl Validate for InstalmentAmountDetailsType1Code {}



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

pub enum InstalmentPeriod1Code {
    #[yaserde(rename = "MNTH")]
    #[cfg_attr(feature = "serde", serde(rename = "MNTH"))]
    Mnth,
    #[yaserde(rename = "ANNU")]
    #[cfg_attr(feature = "serde", serde(rename = "ANNU"))]
    Annu,
    __Unknown__(String),
}

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

impl Validate for InstalmentPeriod1Code {}



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

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

pub enum InterestRate1Code {
    #[yaserde(rename = "GSRT")]
    #[cfg_attr(feature = "serde", serde(rename = "GSRT"))]
    Gsrt,
    #[yaserde(rename = "NTRT")]
    #[cfg_attr(feature = "serde", serde(rename = "NTRT"))]
    Ntrt,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    __Unknown__(String),
}

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

impl Validate for InterestRate1Code {}



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

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

    #[yaserde(rename = "Prd")]
    #[cfg_attr(feature = "serde", serde(rename = "Prd"))]
    pub prd: InstalmentPeriod1Code,

    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: BaseOneRate,
}

impl Validate for InterestRateDetails1 {}


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

    #[yaserde(rename = "KEKId")]
    #[cfg_attr(feature = "serde", serde(rename = "KEKId"))]
    pub kek_id: Kekidentifier7,

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

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

impl Validate for Kek9 {}


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

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

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

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

impl Validate for Kekidentifier7 {}


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

    #[yaserde(rename = "RcptId")]
    #[cfg_attr(feature = "serde", serde(rename = "RcptId"))]
    pub rcpt_id: Recipient13Choice,

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

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

impl Validate for KeyTransport10 {}


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

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

impl Validate for Leiidentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
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.001.001.15")]

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

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.001.001.15")]
pub struct LoyaltyAccount3 {
    #[yaserde(rename = "LltyId")]
    #[cfg_attr(feature = "serde", serde(rename = "LltyId"))]
    pub llty_id: Max35Text,

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

    #[yaserde(rename = "IdTp")]
    #[cfg_attr(feature = "serde", serde(rename = "IdTp"))]
    pub id_tp: CardIdentificationType1Code,

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

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

    #[yaserde(rename = "OwnrNm")]
    #[cfg_attr(feature = "serde", serde(rename = "OwnrNm"))]
    pub ownr_nm: Max45Text,

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

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

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

impl Validate for LoyaltyAccount3 {}


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

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.001.001.15")]
pub struct MandateRelatedInformation17 {
    #[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,

    #[yaserde(rename = "PrtctdMndtImg")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtctdMndtImg"))]
    pub prtctd_mndt_img: ContentInformationType39,
}

impl Validate for MandateRelatedInformation17 {}


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

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

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

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

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

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

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

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

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

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

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

impl Validate for Max9NumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.001.001.15")]
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.001.001.15")]

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

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

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

    #[yaserde(rename = "TknRqstr")]
    #[cfg_attr(feature = "serde", serde(rename = "TknRqstr"))]
    pub tkn_rqstr: PaymentTokenIdentifiers1,

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

    #[yaserde(rename = "TknAssrncData")]
    #[cfg_attr(feature = "serde", serde(rename = "TknAssrncData"))]
    pub tkn_assrnc_data: Max500Binary,

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

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

impl Validate for MerchantToken2 {}


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

pub enum MessageFunction46Code {
    #[yaserde(rename = "AUTQ")]
    #[cfg_attr(feature = "serde", serde(rename = "AUTQ"))]
    Autq,
    #[yaserde(rename = "AUTP")]
    #[cfg_attr(feature = "serde", serde(rename = "AUTP"))]
    Autp,
    #[yaserde(rename = "CCAV")]
    #[cfg_attr(feature = "serde", serde(rename = "CCAV"))]
    Ccav,
    #[yaserde(rename = "CCAK")]
    #[cfg_attr(feature = "serde", serde(rename = "CCAK"))]
    Ccak,
    #[yaserde(rename = "CCAQ")]
    #[cfg_attr(feature = "serde", serde(rename = "CCAQ"))]
    Ccaq,
    #[yaserde(rename = "CCAP")]
    #[cfg_attr(feature = "serde", serde(rename = "CCAP"))]
    Ccap,
    #[yaserde(rename = "CMPV")]
    #[cfg_attr(feature = "serde", serde(rename = "CMPV"))]
    Cmpv,
    #[yaserde(rename = "CMPK")]
    #[cfg_attr(feature = "serde", serde(rename = "CMPK"))]
    Cmpk,
    #[yaserde(rename = "DCAV")]
    #[cfg_attr(feature = "serde", serde(rename = "DCAV"))]
    Dcav,
    #[yaserde(rename = "DCRR")]
    #[cfg_attr(feature = "serde", serde(rename = "DCRR"))]
    Dcrr,
    #[yaserde(rename = "DCCQ")]
    #[cfg_attr(feature = "serde", serde(rename = "DCCQ"))]
    Dccq,
    #[yaserde(rename = "DCCP")]
    #[cfg_attr(feature = "serde", serde(rename = "DCCP"))]
    Dccp,
    #[yaserde(rename = "DGNP")]
    #[cfg_attr(feature = "serde", serde(rename = "DGNP"))]
    Dgnp,
    #[yaserde(rename = "DGNQ")]
    #[cfg_attr(feature = "serde", serde(rename = "DGNQ"))]
    Dgnq,
    #[yaserde(rename = "FAUQ")]
    #[cfg_attr(feature = "serde", serde(rename = "FAUQ"))]
    Fauq,
    #[yaserde(rename = "FAUP")]
    #[cfg_attr(feature = "serde", serde(rename = "FAUP"))]
    Faup,
    #[yaserde(rename = "FCMV")]
    #[cfg_attr(feature = "serde", serde(rename = "FCMV"))]
    Fcmv,
    #[yaserde(rename = "FCMK")]
    #[cfg_attr(feature = "serde", serde(rename = "FCMK"))]
    Fcmk,
    #[yaserde(rename = "FRVA")]
    #[cfg_attr(feature = "serde", serde(rename = "FRVA"))]
    Frva,
    #[yaserde(rename = "FRVR")]
    #[cfg_attr(feature = "serde", serde(rename = "FRVR"))]
    Frvr,
    #[yaserde(rename = "RCLQ")]
    #[cfg_attr(feature = "serde", serde(rename = "RCLQ"))]
    Rclq,
    #[yaserde(rename = "RCLP")]
    #[cfg_attr(feature = "serde", serde(rename = "RCLP"))]
    Rclp,
    #[yaserde(rename = "RVRA")]
    #[cfg_attr(feature = "serde", serde(rename = "RVRA"))]
    Rvra,
    #[yaserde(rename = "RVRR")]
    #[cfg_attr(feature = "serde", serde(rename = "RVRR"))]
    Rvrr,
    #[yaserde(rename = "CDDQ")]
    #[cfg_attr(feature = "serde", serde(rename = "CDDQ"))]
    Cddq,
    #[yaserde(rename = "CDDK")]
    #[cfg_attr(feature = "serde", serde(rename = "CDDK"))]
    Cddk,
    #[yaserde(rename = "CDDR")]
    #[cfg_attr(feature = "serde", serde(rename = "CDDR"))]
    Cddr,
    #[yaserde(rename = "CDDP")]
    #[cfg_attr(feature = "serde", serde(rename = "CDDP"))]
    Cddp,
    #[yaserde(rename = "TRNR")]
    #[cfg_attr(feature = "serde", serde(rename = "TRNR"))]
    Trnr,
    #[yaserde(rename = "TRNA")]
    #[cfg_attr(feature = "serde", serde(rename = "TRNA"))]
    Trna,
    #[yaserde(rename = "NFRQ")]
    #[cfg_attr(feature = "serde", serde(rename = "NFRQ"))]
    Nfrq,
    #[yaserde(rename = "NFRP")]
    #[cfg_attr(feature = "serde", serde(rename = "NFRP"))]
    Nfrp,
    #[yaserde(rename = "TRPQ")]
    #[cfg_attr(feature = "serde", serde(rename = "TRPQ"))]
    Trpq,
    #[yaserde(rename = "TRPP")]
    #[cfg_attr(feature = "serde", serde(rename = "TRPP"))]
    Trpp,
    #[yaserde(rename = "DCRQ")]
    #[cfg_attr(feature = "serde", serde(rename = "DCRQ"))]
    Dcrq,
    #[yaserde(rename = "DCRP")]
    #[cfg_attr(feature = "serde", serde(rename = "DCRP"))]
    Dcrp,
    __Unknown__(String),
}

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

impl Validate for MessageFunction46Code {}



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

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

impl Validate for Min2Max3NumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct 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 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.001.001.15")]
pub struct MobileData6 {
    #[yaserde(rename = "MobCtryCd")]
    #[cfg_attr(feature = "serde", serde(rename = "MobCtryCd"))]
    pub mob_ctry_cd: Min2Max3AlphaText,

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

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

    #[yaserde(rename = "Glctn")]
    #[cfg_attr(feature = "serde", serde(rename = "Glctn"))]
    pub glctn: Geolocation1,

    #[yaserde(rename = "SnstvMobData")]
    #[cfg_attr(feature = "serde", serde(rename = "SnstvMobData"))]
    pub snstv_mob_data: SensitiveMobileData1,

    #[yaserde(rename = "PrtctdMobData")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtctdMobData"))]
    pub prtctd_mob_data: ContentInformationType40,
}

impl Validate for MobileData6 {}


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

impl Validate for NameAndAddress3 {}


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

pub enum NamePrefix2Code {
    #[yaserde(rename = "DOCT")]
    #[cfg_attr(feature = "serde", serde(rename = "DOCT"))]
    Doct,
    #[yaserde(rename = "MADM")]
    #[cfg_attr(feature = "serde", serde(rename = "MADM"))]
    Madm,
    #[yaserde(rename = "MISS")]
    #[cfg_attr(feature = "serde", serde(rename = "MISS"))]
    Miss,
    #[yaserde(rename = "MIST")]
    #[cfg_attr(feature = "serde", serde(rename = "MIST"))]
    Mist,
    #[yaserde(rename = "MIKS")]
    #[cfg_attr(feature = "serde", serde(rename = "MIKS"))]
    Miks,
    __Unknown__(String),
}

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

impl Validate for NamePrefix2Code {}



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

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

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

    #[yaserde(rename = "PINFrmt")]
    #[cfg_attr(feature = "serde", serde(rename = "PINFrmt"))]
    pub pin_frmt: Pinformat3Code,

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

impl Validate for OnLinePIN11 {}


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

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

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

impl Validate for OnLineReason2Code {}



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

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

    #[yaserde(rename = "LctnCtgy")]
    #[cfg_attr(feature = "serde", serde(rename = "LctnCtgy"))]
    pub lctn_ctgy: LocationCategory4Code,

    #[yaserde(rename = "LctnAndCtct")]
    #[cfg_attr(feature = "serde", serde(rename = "LctnAndCtct"))]
    pub lctn_and_ctct: CommunicationAddress9,

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

impl Validate for Organisation45 {}


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

    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Leiidentifier,

    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Vec<GenericOrganisationIdentification3>,
}

impl Validate for OrganisationIdentification39 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.001.001.15")]
pub struct OrganisationIdentificationSchemeName1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ExternalOrganisationIdentification1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max35Text>,
}

impl Validate for OrganisationIdentificationSchemeName1Choice {}




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

    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max128Text,
}

impl Validate for OtherContact1 {}


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


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

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

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

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

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

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

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

pub enum PoicomponentType7Code {
    #[yaserde(rename = "AQPP")]
    #[cfg_attr(feature = "serde", serde(rename = "AQPP"))]
    Aqpp,
    #[yaserde(rename = "APPR")]
    #[cfg_attr(feature = "serde", serde(rename = "APPR"))]
    Appr,
    #[yaserde(rename = "TLPR")]
    #[cfg_attr(feature = "serde", serde(rename = "TLPR"))]
    Tlpr,
    #[yaserde(rename = "SCPR")]
    #[cfg_attr(feature = "serde", serde(rename = "SCPR"))]
    Scpr,
    #[yaserde(rename = "SERV")]
    #[cfg_attr(feature = "serde", serde(rename = "SERV"))]
    Serv,
    #[yaserde(rename = "TERM")]
    #[cfg_attr(feature = "serde", serde(rename = "TERM"))]
    Term,
    #[yaserde(rename = "DVCE")]
    #[cfg_attr(feature = "serde", serde(rename = "DVCE"))]
    Dvce,
    #[yaserde(rename = "SECM")]
    #[cfg_attr(feature = "serde", serde(rename = "SECM"))]
    Secm,
    #[yaserde(rename = "APLI")]
    #[cfg_attr(feature = "serde", serde(rename = "APLI"))]
    Apli,
    #[yaserde(rename = "EMVK")]
    #[cfg_attr(feature = "serde", serde(rename = "EMVK"))]
    Emvk,
    #[yaserde(rename = "EMVO")]
    #[cfg_attr(feature = "serde", serde(rename = "EMVO"))]
    Emvo,
    #[yaserde(rename = "MDWR")]
    #[cfg_attr(feature = "serde", serde(rename = "MDWR"))]
    Mdwr,
    #[yaserde(rename = "DRVR")]
    #[cfg_attr(feature = "serde", serde(rename = "DRVR"))]
    Drvr,
    #[yaserde(rename = "OPST")]
    #[cfg_attr(feature = "serde", serde(rename = "OPST"))]
    Opst,
    #[yaserde(rename = "MRPR")]
    #[cfg_attr(feature = "serde", serde(rename = "MRPR"))]
    Mrpr,
    #[yaserde(rename = "CRTF")]
    #[cfg_attr(feature = "serde", serde(rename = "CRTF"))]
    Crtf,
    #[yaserde(rename = "TMSP")]
    #[cfg_attr(feature = "serde", serde(rename = "TMSP"))]
    Tmsp,
    #[yaserde(rename = "SACP")]
    #[cfg_attr(feature = "serde", serde(rename = "SACP"))]
    Sacp,
    #[yaserde(rename = "SAPR")]
    #[cfg_attr(feature = "serde", serde(rename = "SAPR"))]
    Sapr,
    #[yaserde(rename = "LOGF")]
    #[cfg_attr(feature = "serde", serde(rename = "LOGF"))]
    Logf,
    #[yaserde(rename = "MDFL")]
    #[cfg_attr(feature = "serde", serde(rename = "MDFL"))]
    Mdfl,
    #[yaserde(rename = "SOFT")]
    #[cfg_attr(feature = "serde", serde(rename = "SOFT"))]
    Soft,
    #[yaserde(rename = "CONF")]
    #[cfg_attr(feature = "serde", serde(rename = "CONF"))]
    Conf,
    #[yaserde(rename = "RPFL")]
    #[cfg_attr(feature = "serde", serde(rename = "RPFL"))]
    Rpfl,
    #[yaserde(rename = "PROB")]
    #[cfg_attr(feature = "serde", serde(rename = "PROB"))]
    Prob,
    __Unknown__(String),
}

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

impl Validate for PoicomponentType7Code {}



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

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

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

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

    #[yaserde(rename = "PackgBlck")]
    #[cfg_attr(feature = "serde", serde(rename = "PackgBlck"))]
    pub packg_blck: Vec<ExternallyDefinedData5>,
}

impl Validate for PackageType5 {}


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

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

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

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

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

impl Validate for Parameter16 {}


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

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

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

impl Validate for Parameter17 {}


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

impl Validate for Parameter18 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.001.001.15")]
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.001.001.15")]
pub struct Party52Choice {
    #[yaserde(rename = "OrgId")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgId"))]
    pub org_id: Option<OrganisationIdentification39>,
    #[yaserde(rename = "PrvtId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvtId"))]
    pub prvt_id: Option<PersonIdentification18>,
}

impl Validate for Party52Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.001.001.15")]
pub struct PartyIdentification177Choice {
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_b_i_c: Option<AnyBICDec2014Identifier>,
    #[yaserde(rename = "PrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
    pub prtry_id: Option<GenericIdentification1>,
}

impl Validate for PartyIdentification177Choice {}




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

    #[yaserde(rename = "PstlAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "PstlAdr"))]
    pub pstl_adr: PostalAddress27,

    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Party52Choice,

    #[yaserde(rename = "CtryOfRes")]
    #[cfg_attr(feature = "serde", serde(rename = "CtryOfRes"))]
    pub ctry_of_res: CountryCode,

    #[yaserde(rename = "CtctDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "CtctDtls"))]
    pub ctct_dtls: Contact13,
}

impl Validate for PartyIdentification272 {}


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

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

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

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

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

impl Validate for PartyType35Code {}



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

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

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

    #[yaserde(rename = "PrvtCardData")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvtCardData"))]
    pub prvt_card_data: Max100KBinary,

    #[yaserde(rename = "PlainCardData")]
    #[cfg_attr(feature = "serde", serde(rename = "PlainCardData"))]
    pub plain_card_data: PlainCardData22,

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

    #[yaserde(rename = "MskdPAN")]
    #[cfg_attr(feature = "serde", serde(rename = "MskdPAN"))]
    pub mskd_pan: Max30Text,

    #[yaserde(rename = "IssrBIN")]
    #[cfg_attr(feature = "serde", serde(rename = "IssrBIN"))]
    pub issr_bin: Max15NumericText,

    #[yaserde(rename = "CardCtryCd")]
    #[cfg_attr(feature = "serde", serde(rename = "CardCtryCd"))]
    pub card_ctry_cd: Max3Text,

    #[yaserde(rename = "CardCcyCd")]
    #[cfg_attr(feature = "serde", serde(rename = "CardCcyCd"))]
    pub card_ccy_cd: Exact3AlphaNumericText,

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

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

    #[yaserde(rename = "CardPdctTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CardPdctTp"))]
    pub card_pdct_tp: CardProductType1Code,

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

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

    #[yaserde(rename = "AllwdPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "AllwdPdct"))]
    pub allwd_pdct: Vec<Max70Text>,

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

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

impl Validate for PaymentCard35 {}


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

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

impl Validate for PaymentContext29 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.001.001.15")]
pub struct PaymentContext30 {
    #[yaserde(rename = "PmtCntxt")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtCntxt"))]
    pub pmt_cntxt: PaymentContext29,

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

    #[yaserde(rename = "CdtTrfCntxt")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtTrfCntxt"))]
    pub cdt_trf_cntxt: CreditTransferContext1,

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

impl Validate for PaymentContext30 {}


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

impl Validate for PersonIdentification18 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.001.001.15")]
pub struct PersonIdentificationSchemeName1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ExternalPersonIdentification1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max35Text>,
}

impl Validate for PersonIdentificationSchemeName1Choice {}




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

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

    #[yaserde(rename = "Trck1")]
    #[cfg_attr(feature = "serde", serde(rename = "Trck1"))]
    pub trck_1: Max76Text,

    #[yaserde(rename = "Trck2")]
    #[cfg_attr(feature = "serde", serde(rename = "Trck2"))]
    pub trck_2: Max37Text,

    #[yaserde(rename = "Trck3")]
    #[cfg_attr(feature = "serde", serde(rename = "Trck3"))]
    pub trck_3: Max104Text,

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

    #[yaserde(rename = "NtryMd")]
    #[cfg_attr(feature = "serde", serde(rename = "NtryMd"))]
    pub ntry_md: CardDataReading5Code,
}

impl Validate for PlainCardData17 {}


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

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

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

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

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

    #[yaserde(rename = "Trck1")]
    #[cfg_attr(feature = "serde", serde(rename = "Trck1"))]
    pub trck_1: Max76Text,

    #[yaserde(rename = "Trck2")]
    #[cfg_attr(feature = "serde", serde(rename = "Trck2"))]
    pub trck_2: Max37Text,

    #[yaserde(rename = "Trck3")]
    #[cfg_attr(feature = "serde", serde(rename = "Trck3"))]
    pub trck_3: Max104Text,

    #[yaserde(rename = "CrdhldrNm")]
    #[cfg_attr(feature = "serde", serde(rename = "CrdhldrNm"))]
    pub crdhldr_nm: Max45Text,
}

impl Validate for PlainCardData22 {}


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

pub enum PlanOwner1Code {
    #[yaserde(rename = "ACCP")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCP"))]
    Accp,
    #[yaserde(rename = "ACQR")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
    Acqr,
    #[yaserde(rename = "ISSR")]
    #[cfg_attr(feature = "serde", serde(rename = "ISSR"))]
    Issr,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    __Unknown__(String),
}

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

impl Validate for PlanOwner1Code {}



#[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.001.001.15")]
pub struct PointOfInteraction16 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: GenericIdentification177,

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

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

    #[yaserde(rename = "Cpblties")]
    #[cfg_attr(feature = "serde", serde(rename = "Cpblties"))]
    pub cpblties: PointOfInteractionCapabilities11,

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

    #[yaserde(rename = "TermnlIntgtn")]
    #[cfg_attr(feature = "serde", serde(rename = "TermnlIntgtn"))]
    pub termnl_intgtn: LocationCategory3Code,

    #[yaserde(rename = "Cmpnt")]
    #[cfg_attr(feature = "serde", serde(rename = "Cmpnt"))]
    pub cmpnt: Vec<PointOfInteractionComponent18>,
}

impl Validate for PointOfInteraction16 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.001.001.15")]
pub struct PointOfInteractionCapabilities11 {
    #[yaserde(rename = "CardRdngCpblties")]
    #[cfg_attr(feature = "serde", serde(rename = "CardRdngCpblties"))]
    pub card_rdng_cpblties: Vec<CardDataReading8Code>,

    #[yaserde(rename = "CrdhldrVrfctnCpblties")]
    #[cfg_attr(feature = "serde", serde(rename = "CrdhldrVrfctnCpblties"))]
    pub crdhldr_vrfctn_cpblties: Vec<CardholderVerificationCapability4Code>,

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

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

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

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

    #[yaserde(rename = "OnLineCpblties")]
    #[cfg_attr(feature = "serde", serde(rename = "OnLineCpblties"))]
    pub on_line_cpblties: OnLineCapability1Code,

    #[yaserde(rename = "MsgCpblties")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgCpblties"))]
    pub msg_cpblties: Vec<DisplayCapabilities7>,
}

impl Validate for PointOfInteractionCapabilities11 {}


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

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

    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: PointOfInteractionComponentIdentification2,

    #[yaserde(rename = "Sts")]
    #[cfg_attr(feature = "serde", serde(rename = "Sts"))]
    pub sts: PointOfInteractionComponentStatus3,

    #[yaserde(rename = "StdCmplc")]
    #[cfg_attr(feature = "serde", serde(rename = "StdCmplc"))]
    pub std_cmplc: Vec<GenericIdentification48>,

    #[yaserde(rename = "Chrtcs")]
    #[cfg_attr(feature = "serde", serde(rename = "Chrtcs"))]
    pub chrtcs: PointOfInteractionComponentCharacteristics11,

    #[yaserde(rename = "Assmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "Assmnt"))]
    pub assmnt: Vec<PointOfInteractionComponentAssessment1>,

    #[yaserde(rename = "Packg")]
    #[cfg_attr(feature = "serde", serde(rename = "Packg"))]
    pub packg: Vec<PackageType5>,

    #[yaserde(rename = "PrbVal")]
    #[cfg_attr(feature = "serde", serde(rename = "PrbVal"))]
    pub prb_val: Max35Binary,
}

impl Validate for PointOfInteractionComponent18 {}


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

    #[yaserde(rename = "Com")]
    #[cfg_attr(feature = "serde", serde(rename = "Com"))]
    pub com: Vec<CommunicationCharacteristics5>,

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

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

    #[yaserde(rename = "SctyElmt")]
    #[cfg_attr(feature = "serde", serde(rename = "SctyElmt"))]
    pub scty_elmt: Vec<CryptographicKey19>,
}

impl Validate for PointOfInteractionComponentCharacteristics11 {}


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

    #[yaserde(rename = "Sts")]
    #[cfg_attr(feature = "serde", serde(rename = "Sts"))]
    pub sts: PoicomponentStatus1Code,

    #[yaserde(rename = "XpryDt")]
    #[cfg_attr(feature = "serde", serde(rename = "XpryDt"))]
    pub xpry_dt: Isodate,
}

impl Validate for PointOfInteractionComponentStatus3 {}


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

impl Validate for PositiveNumber {
    fn validate(&self) -> Result<(), String> { 
        if self.0 < "1".parse::<String>().unwrap() {
            return Err(format!("MinInclusive validation error: invalid value of 0! \nExpected: 0 >= 1.\nActual: 0 == {}", self.0));
        }
        Ok(())
    }
}

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

    #[yaserde(rename = "AdrLine")]
    #[cfg_attr(feature = "serde", serde(rename = "AdrLine"))]
    pub adr_line: Vec<Max70Text>,

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

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

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

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

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

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

impl Validate for PostalAddress1 {}


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Validate for PostalAddress27 {}


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

pub enum PreferredContactMethod2Code {
    #[yaserde(rename = "MAIL")]
    #[cfg_attr(feature = "serde", serde(rename = "MAIL"))]
    Mail,
    #[yaserde(rename = "FAXX")]
    #[cfg_attr(feature = "serde", serde(rename = "FAXX"))]
    Faxx,
    #[yaserde(rename = "LETT")]
    #[cfg_attr(feature = "serde", serde(rename = "LETT"))]
    Lett,
    #[yaserde(rename = "CELL")]
    #[cfg_attr(feature = "serde", serde(rename = "CELL"))]
    Cell,
    #[yaserde(rename = "ONLI")]
    #[cfg_attr(feature = "serde", serde(rename = "ONLI"))]
    Onli,
    #[yaserde(rename = "PHON")]
    #[cfg_attr(feature = "serde", serde(rename = "PHON"))]
    Phon,
    __Unknown__(String),
}

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

impl Validate for PreferredContactMethod2Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.001.001.15")]
pub struct ProcessRetry3 {
    #[yaserde(rename = "Dely")]
    #[cfg_attr(feature = "serde", serde(rename = "Dely"))]
    pub dely: Max9NumericText,

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

    #[yaserde(rename = "UnitOfTm")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitOfTm"))]
    pub unit_of_tm: TimeUnit1Code,
}

impl Validate for ProcessRetry3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.001.001.15")]
pub struct ProcessTiming6 {
    #[yaserde(rename = "StartTm")]
    #[cfg_attr(feature = "serde", serde(rename = "StartTm"))]
    pub start_tm: IsodateTime,

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

    #[yaserde(rename = "Prd")]
    #[cfg_attr(feature = "serde", serde(rename = "Prd"))]
    pub prd: Max9NumericText,

    #[yaserde(rename = "UnitOfTm")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitOfTm"))]
    pub unit_of_tm: TimeUnit1Code,
}

impl Validate for ProcessTiming6 {}


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

    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max2048Text,
}

impl Validate for ProxyAccountIdentification1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.001.001.15")]
pub struct ProxyAccountType1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ExternalProxyAccountType1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max35Text>,
}

impl Validate for ProxyAccountType1Choice {}




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

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

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.001.001.15")]
pub struct Recipient13Choice {
    #[yaserde(rename = "IssrAndSrlNb")]
    #[cfg_attr(feature = "serde", serde(rename = "IssrAndSrlNb"))]
    pub issr_and_srl_nb: Option<IssuerAndSerialNumber2>,
    #[yaserde(rename = "SbjtKeyIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "SbjtKeyIdr"))]
    pub sbjt_key_idr: Option<Max140Binary>,
}

impl Validate for Recipient13Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:caaa.001.001.15")]
pub struct Recipient15Choice {
    #[yaserde(rename = "KeyTrnsprt")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyTrnsprt"))]
    pub key_trnsprt: Option<KeyTransport10>,
    #[yaserde(rename = "KEK")]
    #[cfg_attr(feature = "serde", serde(rename = "KEK"))]
    pub kek: Option<Kek9>,
    #[yaserde(rename = "KeyIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyIdr"))]
    pub key_idr: Option<Kekidentifier7>,
}

impl Validate for Recipient15Choice {}




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

    #[yaserde(rename = "PlanNtce")]
    #[cfg_attr(feature = "serde", serde(rename = "PlanNtce"))]
    pub plan_ntce: Vec<ActionMessage12>,
}

impl Validate for RecurringTransaction7 {}


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

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

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

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.001.001.15")]
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.001.001.15")]
pub struct SignedData9 {
    #[yaserde(rename = "Vrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Vrsn"))]
    pub vrsn: Number,

    #[yaserde(rename = "DgstAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "DgstAlgo"))]
    pub dgst_algo: Vec<AlgorithmIdentification36>,

    #[yaserde(rename = "NcpsltdCntt")]
    #[cfg_attr(feature = "serde", serde(rename = "NcpsltdCntt"))]
    pub ncpsltd_cntt: EncapsulatedContent3,

    #[yaserde(rename = "Cert")]
    #[cfg_attr(feature = "serde", serde(rename = "Cert"))]
    pub cert: Vec<Max5000Binary>,

    #[yaserde(rename = "Sgnr")]
    #[cfg_attr(feature = "serde", serde(rename = "Sgnr"))]
    pub sgnr: Vec<Signer8>,
}

impl Validate for SignedData9 {}


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

    #[yaserde(rename = "SgnrId")]
    #[cfg_attr(feature = "serde", serde(rename = "SgnrId"))]
    pub sgnr_id: Recipient13Choice,

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

    #[yaserde(rename = "SgndAttrbts")]
    #[cfg_attr(feature = "serde", serde(rename = "SgndAttrbts"))]
    pub sgnd_attrbts: Vec<GenericInformation1>,

    #[yaserde(rename = "SgntrAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "SgntrAlgo"))]
    pub sgntr_algo: AlgorithmIdentification33,

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

impl Validate for Signer8 {}


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

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

pub enum SupportedPaymentOption2Code {
    #[yaserde(rename = "PART")]
    #[cfg_attr(feature = "serde", serde(rename = "PART"))]
    Part,
    #[yaserde(rename = "MSRV")]
    #[cfg_attr(feature = "serde", serde(rename = "MSRV"))]
    Msrv,
    #[yaserde(rename = "INSI")]
    #[cfg_attr(feature = "serde", serde(rename = "INSI"))]
    Insi,
    #[yaserde(rename = "PINQ")]
    #[cfg_attr(feature = "serde", serde(rename = "PINQ"))]
    Pinq,
    __Unknown__(String),
}

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

impl Validate for SupportedPaymentOption2Code {}



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

pub enum TimeUnit1Code {
    #[yaserde(rename = "DAYC")]
    #[cfg_attr(feature = "serde", serde(rename = "DAYC"))]
    Dayc,
    #[yaserde(rename = "HOUR")]
    #[cfg_attr(feature = "serde", serde(rename = "HOUR"))]
    Hour,
    #[yaserde(rename = "MINU")]
    #[cfg_attr(feature = "serde", serde(rename = "MINU"))]
    Minu,
    #[yaserde(rename = "MNTH")]
    #[cfg_attr(feature = "serde", serde(rename = "MNTH"))]
    Mnth,
    #[yaserde(rename = "SECO")]
    #[cfg_attr(feature = "serde", serde(rename = "SECO"))]
    Seco,
    #[yaserde(rename = "WEEK")]
    #[cfg_attr(feature = "serde", serde(rename = "WEEK"))]
    Week,
    #[yaserde(rename = "YEAR")]
    #[cfg_attr(feature = "serde", serde(rename = "YEAR"))]
    Year,
    __Unknown__(String),
}

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

impl Validate for TimeUnit1Code {}



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

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

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

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

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

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

pub enum UserInterface9Code {
    #[yaserde(rename = "CDSP")]
    #[cfg_attr(feature = "serde", serde(rename = "CDSP"))]
    Cdsp,
    #[yaserde(rename = "CRCP")]
    #[cfg_attr(feature = "serde", serde(rename = "CRCP"))]
    Crcp,
    #[yaserde(rename = "MDSP")]
    #[cfg_attr(feature = "serde", serde(rename = "MDSP"))]
    Mdsp,
    #[yaserde(rename = "MRCP")]
    #[cfg_attr(feature = "serde", serde(rename = "MRCP"))]
    Mrcp,
    #[yaserde(rename = "CRDO")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDO"))]
    Crdo,
    #[yaserde(rename = "CSTM")]
    #[cfg_attr(feature = "serde", serde(rename = "CSTM"))]
    Cstm,
    __Unknown__(String),
}

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

impl Validate for UserInterface9Code {}



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

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