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:cain.023.001.01")]
pub struct AccountDetails2 {
    #[yaserde(rename = "AcctNm")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctNm"))]
    pub acct_nm: Max70Text,

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

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

impl Validate for AccountDetails2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct Action9 {
    #[yaserde(rename = "Dstn")]
    #[cfg_attr(feature = "serde", serde(rename = "Dstn"))]
    pub dstn: PartyType20Code,

    #[yaserde(rename = "ActnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ActnTp"))]
    pub actn_tp: ActionType11Code,

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

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

impl Validate for Action9 {}


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

pub enum ActionDestination1Code {
    #[yaserde(rename = "FILE")]
    #[cfg_attr(feature = "serde", serde(rename = "FILE"))]
    File,
    #[yaserde(rename = "MOBL")]
    #[cfg_attr(feature = "serde", serde(rename = "MOBL"))]
    Mobl,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "PECR")]
    #[cfg_attr(feature = "serde", serde(rename = "PECR"))]
    Pecr,
    #[yaserde(rename = "POFS")]
    #[cfg_attr(feature = "serde", serde(rename = "POFS"))]
    Pofs,
    __Unknown__(String),
}

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

impl Validate for ActionDestination1Code {}



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

pub enum ActionType10Code {
    #[yaserde(rename = "ACTV")]
    #[cfg_attr(feature = "serde", serde(rename = "ACTV"))]
    Actv,
    #[yaserde(rename = "DEAC")]
    #[cfg_attr(feature = "serde", serde(rename = "DEAC"))]
    Deac,
    #[yaserde(rename = "DISP")]
    #[cfg_attr(feature = "serde", serde(rename = "DISP"))]
    Disp,
    #[yaserde(rename = "FUPD")]
    #[cfg_attr(feature = "serde", serde(rename = "FUPD"))]
    Fupd,
    #[yaserde(rename = "PRNT")]
    #[cfg_attr(feature = "serde", serde(rename = "PRNT"))]
    Prnt,
    #[yaserde(rename = "SNDM")]
    #[cfg_attr(feature = "serde", serde(rename = "SNDM"))]
    Sndm,
    __Unknown__(String),
}

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

impl Validate for ActionType10Code {}



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

pub enum ActionType11Code {
    #[yaserde(rename = "CNTI")]
    #[cfg_attr(feature = "serde", serde(rename = "CNTI"))]
    Cnti,
    #[yaserde(rename = "CNIS")]
    #[cfg_attr(feature = "serde", serde(rename = "CNIS"))]
    Cnis,
    #[yaserde(rename = "CNTA")]
    #[cfg_attr(feature = "serde", serde(rename = "CNTA"))]
    Cnta,
    #[yaserde(rename = "CNAS")]
    #[cfg_attr(feature = "serde", serde(rename = "CNAS"))]
    Cnas,
    #[yaserde(rename = "CPTR")]
    #[cfg_attr(feature = "serde", serde(rename = "CPTR"))]
    Cptr,
    #[yaserde(rename = "CHDV")]
    #[cfg_attr(feature = "serde", serde(rename = "CHDV"))]
    Chdv,
    #[yaserde(rename = "VIPM")]
    #[cfg_attr(feature = "serde", serde(rename = "VIPM"))]
    Vipm,
    #[yaserde(rename = "TRCK")]
    #[cfg_attr(feature = "serde", serde(rename = "TRCK"))]
    Trck,
    #[yaserde(rename = "TRXR")]
    #[cfg_attr(feature = "serde", serde(rename = "TRXR"))]
    Trxr,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "SIGN")]
    #[cfg_attr(feature = "serde", serde(rename = "SIGN"))]
    Sign,
    __Unknown__(String),
}

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

impl Validate for ActionType11Code {}



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

pub enum ActionType8Code {
    #[yaserde(rename = "APPV")]
    #[cfg_attr(feature = "serde", serde(rename = "APPV"))]
    Appv,
    #[yaserde(rename = "BLCK")]
    #[cfg_attr(feature = "serde", serde(rename = "BLCK"))]
    Blck,
    #[yaserde(rename = "CPTR")]
    #[cfg_attr(feature = "serde", serde(rename = "CPTR"))]
    Cptr,
    #[yaserde(rename = "DCLN")]
    #[cfg_attr(feature = "serde", serde(rename = "DCLN"))]
    Dcln,
    #[yaserde(rename = "RQID")]
    #[cfg_attr(feature = "serde", serde(rename = "RQID"))]
    Rqid,
    #[yaserde(rename = "NDCL")]
    #[cfg_attr(feature = "serde", serde(rename = "NDCL"))]
    Ndcl,
    #[yaserde(rename = "RFRL")]
    #[cfg_attr(feature = "serde", serde(rename = "RFRL"))]
    Rfrl,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "STUA")]
    #[cfg_attr(feature = "serde", serde(rename = "STUA"))]
    Stua,
    __Unknown__(String),
}

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

impl Validate for ActionType8Code {}



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

    #[yaserde(rename = "Dstn")]
    #[cfg_attr(feature = "serde", serde(rename = "Dstn"))]
    pub dstn: PartyType21Code,

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

    #[yaserde(rename = "DstnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "DstnTp"))]
    pub dstn_tp: ActionDestination1Code,

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

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

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

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

    #[yaserde(rename = "Cntt")]
    #[cfg_attr(feature = "serde", serde(rename = "Cntt"))]
    pub cntt: Content1,
}

impl Validate for AdditionalAction1 {}


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

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

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

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

impl Validate for AdditionalAmounts2 {}


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

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

impl Validate for AdditionalData1 {}


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

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

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

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

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

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

impl Validate for AdditionalFee1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct AdditionalInformation20 {
    #[yaserde(rename = "Rcpt")]
    #[cfg_attr(feature = "serde", serde(rename = "Rcpt"))]
    pub rcpt: PartyType22Code,

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

    #[yaserde(rename = "Trgt")]
    #[cfg_attr(feature = "serde", serde(rename = "Trgt"))]
    pub trgt: Vec<UserInterface6Code>,

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

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

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

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

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

impl Validate for AdditionalInformation20 {}


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

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

impl Validate for AdditionalRiskData1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct Address1 {
    #[yaserde(rename = "AdrLine1")]
    #[cfg_attr(feature = "serde", serde(rename = "AdrLine1"))]
    pub adr_line_1: Max70Text,

    #[yaserde(rename = "AdrLine2")]
    #[cfg_attr(feature = "serde", serde(rename = "AdrLine2"))]
    pub adr_line_2: 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 = "PstlCd")]
    #[cfg_attr(feature = "serde", serde(rename = "PstlCd"))]
    pub pstl_cd: Max16Text,

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

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

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

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

impl Validate for Address1 {}


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

pub enum Algorithm11Code {
    #[yaserde(rename = "HS25")]
    #[cfg_attr(feature = "serde", serde(rename = "HS25"))]
    Hs25,
    #[yaserde(rename = "HS38")]
    #[cfg_attr(feature = "serde", serde(rename = "HS38"))]
    Hs38,
    #[yaserde(rename = "HS51")]
    #[cfg_attr(feature = "serde", serde(rename = "HS51"))]
    Hs51,
    #[yaserde(rename = "HS01")]
    #[cfg_attr(feature = "serde", serde(rename = "HS01"))]
    Hs01,
    __Unknown__(String),
}

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

impl Validate for Algorithm11Code {}



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

pub enum Algorithm13Code {
    #[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 = "UKA1")]
    #[cfg_attr(feature = "serde", serde(rename = "UKA1"))]
    Uka1,
    #[yaserde(rename = "EA9C")]
    #[cfg_attr(feature = "serde", serde(rename = "EA9C"))]
    Ea9C,
    #[yaserde(rename = "EA5C")]
    #[cfg_attr(feature = "serde", serde(rename = "EA5C"))]
    Ea5C,
    __Unknown__(String),
}

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

impl Validate for Algorithm13Code {}



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

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

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

impl Validate for Algorithm16Code {}



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

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

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

impl Validate for Algorithm17Code {}



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

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

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

impl Validate for Algorithm18Code {}



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

pub enum Algorithm19Code {
    #[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 = "ECC5")]
    #[cfg_attr(feature = "serde", serde(rename = "ECC5"))]
    Ecc5,
    #[yaserde(rename = "ECC1")]
    #[cfg_attr(feature = "serde", serde(rename = "ECC1"))]
    Ecc1,
    #[yaserde(rename = "ECC4")]
    #[cfg_attr(feature = "serde", serde(rename = "ECC4"))]
    Ecc4,
    #[yaserde(rename = "ECC2")]
    #[cfg_attr(feature = "serde", serde(rename = "ECC2"))]
    Ecc2,
    #[yaserde(rename = "ECC3")]
    #[cfg_attr(feature = "serde", serde(rename = "ECC3"))]
    Ecc3,
    #[yaserde(rename = "ERS3")]
    #[cfg_attr(feature = "serde", serde(rename = "ERS3"))]
    Ers3,
    #[yaserde(rename = "ECP2")]
    #[cfg_attr(feature = "serde", serde(rename = "ECP2"))]
    Ecp2,
    #[yaserde(rename = "ECP3")]
    #[cfg_attr(feature = "serde", serde(rename = "ECP3"))]
    Ecp3,
    #[yaserde(rename = "ECP5")]
    #[cfg_attr(feature = "serde", serde(rename = "ECP5"))]
    Ecp5,
    __Unknown__(String),
}

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

impl Validate for Algorithm19Code {}



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

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

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

impl Validate for Algorithm20Code {}



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

pub enum Algorithm23Code {
    #[yaserde(rename = "EA2C")]
    #[cfg_attr(feature = "serde", serde(rename = "EA2C"))]
    Ea2C,
    #[yaserde(rename = "E3DC")]
    #[cfg_attr(feature = "serde", serde(rename = "E3DC"))]
    E3Dc,
    #[yaserde(rename = "EA9C")]
    #[cfg_attr(feature = "serde", serde(rename = "EA9C"))]
    Ea9C,
    #[yaserde(rename = "EA5C")]
    #[cfg_attr(feature = "serde", serde(rename = "EA5C"))]
    Ea5C,
    #[yaserde(rename = "EA2R")]
    #[cfg_attr(feature = "serde", serde(rename = "EA2R"))]
    Ea2R,
    #[yaserde(rename = "EA9R")]
    #[cfg_attr(feature = "serde", serde(rename = "EA9R"))]
    Ea9R,
    #[yaserde(rename = "EA5R")]
    #[cfg_attr(feature = "serde", serde(rename = "EA5R"))]
    Ea5R,
    #[yaserde(rename = "E3DR")]
    #[cfg_attr(feature = "serde", serde(rename = "E3DR"))]
    E3Dr,
    E36C,
    E36R,
    #[yaserde(rename = "SD5C")]
    #[cfg_attr(feature = "serde", serde(rename = "SD5C"))]
    Sd5C,
    __Unknown__(String),
}

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

impl Validate for Algorithm23Code {}



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

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

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

impl Validate for Algorithm5Code {}



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

pub enum Algorithm7Code {
    #[yaserde(rename = "ERSA")]
    #[cfg_attr(feature = "serde", serde(rename = "ERSA"))]
    Ersa,
    #[yaserde(rename = "RSAO")]
    #[cfg_attr(feature = "serde", serde(rename = "RSAO"))]
    Rsao,
    __Unknown__(String),
}

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

impl Validate for Algorithm7Code {}



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

pub enum Algorithm8Code {
    #[yaserde(rename = "MGF1")]
    #[cfg_attr(feature = "serde", serde(rename = "MGF1"))]
    Mgf1,
    __Unknown__(String),
}

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

impl Validate for Algorithm8Code {}



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

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

impl Validate for AlgorithmIdentification12 {}


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

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

impl Validate for AlgorithmIdentification18 {}


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

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

impl Validate for AlgorithmIdentification19 {}


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

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

impl Validate for AlgorithmIdentification20 {}


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

impl Validate for AlgorithmIdentification21 {}


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

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

impl Validate for AlgorithmIdentification22 {}


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

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

impl Validate for AlgorithmIdentification23 {}


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

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

impl Validate for AlgorithmIdentification24 {}


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

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

impl Validate for AlgorithmIdentification25 {}


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

impl Validate for AlgorithmIdentification26 {}


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

impl Validate for AlgorithmIdentification27 {}


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

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

impl Validate for AlgorithmIdentification28 {}


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

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

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

impl Validate for Amount14 {}


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

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

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

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

impl Validate for Amount4 {}


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

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

impl Validate for ApprovalData1 {}


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

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

    #[yaserde(rename = "Assgnr")]
    #[cfg_attr(feature = "serde", serde(rename = "Assgnr"))]
    pub assgnr: PartyType9Code,

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


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

pub enum AttributeType1Code {
    #[yaserde(rename = "CNAT")]
    #[cfg_attr(feature = "serde", serde(rename = "CNAT"))]
    Cnat,
    #[yaserde(rename = "LATT")]
    #[cfg_attr(feature = "serde", serde(rename = "LATT"))]
    Latt,
    #[yaserde(rename = "OATT")]
    #[cfg_attr(feature = "serde", serde(rename = "OATT"))]
    Oatt,
    #[yaserde(rename = "OUAT")]
    #[cfg_attr(feature = "serde", serde(rename = "OUAT"))]
    Ouat,
    #[yaserde(rename = "CATT")]
    #[cfg_attr(feature = "serde", serde(rename = "CATT"))]
    Catt,
    __Unknown__(String),
}

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

impl Validate for AttributeType1Code {}



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

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

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

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

impl Validate for AuthenticatedData5 {}


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

pub enum AuthenticationMethod11Code {
    #[yaserde(rename = "APKI")]
    #[cfg_attr(feature = "serde", serde(rename = "APKI"))]
    Apki,
    #[yaserde(rename = "ADVF")]
    #[cfg_attr(feature = "serde", serde(rename = "ADVF"))]
    Advf,
    #[yaserde(rename = "ARNB")]
    #[cfg_attr(feature = "serde", serde(rename = "ARNB"))]
    Arnb,
    #[yaserde(rename = "ARPC")]
    #[cfg_attr(feature = "serde", serde(rename = "ARPC"))]
    Arpc,
    #[yaserde(rename = "ARQC")]
    #[cfg_attr(feature = "serde", serde(rename = "ARQC"))]
    Arqc,
    #[yaserde(rename = "ATCC")]
    #[cfg_attr(feature = "serde", serde(rename = "ATCC"))]
    Atcc,
    #[yaserde(rename = "BTHD")]
    #[cfg_attr(feature = "serde", serde(rename = "BTHD"))]
    Bthd,
    #[yaserde(rename = "CHSA")]
    #[cfg_attr(feature = "serde", serde(rename = "CHSA"))]
    Chsa,
    #[yaserde(rename = "CHDN")]
    #[cfg_attr(feature = "serde", serde(rename = "CHDN"))]
    Chdn,
    #[yaserde(rename = "CUID")]
    #[cfg_attr(feature = "serde", serde(rename = "CUID"))]
    Cuid,
    #[yaserde(rename = "DRVI")]
    #[cfg_attr(feature = "serde", serde(rename = "DRVI"))]
    Drvi,
    #[yaserde(rename = "DRLN")]
    #[cfg_attr(feature = "serde", serde(rename = "DRLN"))]
    Drln,
    #[yaserde(rename = "EMAL")]
    #[cfg_attr(feature = "serde", serde(rename = "EMAL"))]
    Emal,
    #[yaserde(rename = "EMIN")]
    #[cfg_attr(feature = "serde", serde(rename = "EMIN"))]
    Emin,
    #[yaserde(rename = "EMRN")]
    #[cfg_attr(feature = "serde", serde(rename = "EMRN"))]
    Emrn,
    #[yaserde(rename = "IDCN")]
    #[cfg_attr(feature = "serde", serde(rename = "IDCN"))]
    Idcn,
    #[yaserde(rename = "MANU")]
    #[cfg_attr(feature = "serde", serde(rename = "MANU"))]
    Manu,
    #[yaserde(rename = "NVSC")]
    #[cfg_attr(feature = "serde", serde(rename = "NVSC"))]
    Nvsc,
    #[yaserde(rename = "FBIG")]
    #[cfg_attr(feature = "serde", serde(rename = "FBIG"))]
    Fbig,
    #[yaserde(rename = "FBIO")]
    #[cfg_attr(feature = "serde", serde(rename = "FBIO"))]
    Fbio,
    #[yaserde(rename = "OLDA")]
    #[cfg_attr(feature = "serde", serde(rename = "OLDA"))]
    Olda,
    #[yaserde(rename = "OLDS")]
    #[cfg_attr(feature = "serde", serde(rename = "OLDS"))]
    Olds,
    #[yaserde(rename = "OFPE")]
    #[cfg_attr(feature = "serde", serde(rename = "OFPE"))]
    Ofpe,
    #[yaserde(rename = "FCPN")]
    #[cfg_attr(feature = "serde", serde(rename = "FCPN"))]
    Fcpn,
    #[yaserde(rename = "OTPW")]
    #[cfg_attr(feature = "serde", serde(rename = "OTPW"))]
    Otpw,
    #[yaserde(rename = "NBIG")]
    #[cfg_attr(feature = "serde", serde(rename = "NBIG"))]
    Nbig,
    #[yaserde(rename = "NPIN")]
    #[cfg_attr(feature = "serde", serde(rename = "NPIN"))]
    Npin,
    #[yaserde(rename = "OCHI")]
    #[cfg_attr(feature = "serde", serde(rename = "OCHI"))]
    Ochi,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "PPSG")]
    #[cfg_attr(feature = "serde", serde(rename = "PPSG"))]
    Ppsg,
    #[yaserde(rename = "PSVE")]
    #[cfg_attr(feature = "serde", serde(rename = "PSVE"))]
    Psve,
    #[yaserde(rename = "PASN")]
    #[cfg_attr(feature = "serde", serde(rename = "PASN"))]
    Pasn,
    #[yaserde(rename = "PSWD")]
    #[cfg_attr(feature = "serde", serde(rename = "PSWD"))]
    Pswd,
    #[yaserde(rename = "TOKP")]
    #[cfg_attr(feature = "serde", serde(rename = "TOKP"))]
    Tokp,
    #[yaserde(rename = "PKIS")]
    #[cfg_attr(feature = "serde", serde(rename = "PKIS"))]
    Pkis,
    #[yaserde(rename = "PLOB")]
    #[cfg_attr(feature = "serde", serde(rename = "PLOB"))]
    Plob,
    #[yaserde(rename = "PCDV")]
    #[cfg_attr(feature = "serde", serde(rename = "PCDV"))]
    Pcdv,
    #[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 = "SHAF")]
    #[cfg_attr(feature = "serde", serde(rename = "SHAF"))]
    Shaf,
    #[yaserde(rename = "SHAT")]
    #[cfg_attr(feature = "serde", serde(rename = "SHAT"))]
    Shat,
    #[yaserde(rename = "CPSG")]
    #[cfg_attr(feature = "serde", serde(rename = "CPSG"))]
    Cpsg,
    #[yaserde(rename = "SSNB")]
    #[cfg_attr(feature = "serde", serde(rename = "SSNB"))]
    Ssnb,
    #[yaserde(rename = "TXIN")]
    #[cfg_attr(feature = "serde", serde(rename = "TXIN"))]
    Txin,
    #[yaserde(rename = "TOKA")]
    #[cfg_attr(feature = "serde", serde(rename = "TOKA"))]
    Toka,
    #[yaserde(rename = "CDHI")]
    #[cfg_attr(feature = "serde", serde(rename = "CDHI"))]
    Cdhi,
    #[yaserde(rename = "TOKN")]
    #[cfg_attr(feature = "serde", serde(rename = "TOKN"))]
    Tokn,
    #[yaserde(rename = "QWAC")]
    #[cfg_attr(feature = "serde", serde(rename = "QWAC"))]
    Qwac,
    #[yaserde(rename = "PHOM")]
    #[cfg_attr(feature = "serde", serde(rename = "PHOM"))]
    Phom,
    #[yaserde(rename = "PWOR")]
    #[cfg_attr(feature = "serde", serde(rename = "PWOR"))]
    Pwor,
    #[yaserde(rename = "THDS")]
    #[cfg_attr(feature = "serde", serde(rename = "THDS"))]
    Thds,
    #[yaserde(rename = "ADDB")]
    #[cfg_attr(feature = "serde", serde(rename = "ADDB"))]
    Addb,
    #[yaserde(rename = "ADDS")]
    #[cfg_attr(feature = "serde", serde(rename = "ADDS"))]
    Adds,
    #[yaserde(rename = "CSCV")]
    #[cfg_attr(feature = "serde", serde(rename = "CSCV"))]
    Cscv,
    #[yaserde(rename = "CRYP")]
    #[cfg_attr(feature = "serde", serde(rename = "CRYP"))]
    Cryp,
    #[yaserde(rename = "BIOM")]
    #[cfg_attr(feature = "serde", serde(rename = "BIOM"))]
    Biom,
    #[yaserde(rename = "MOBL")]
    #[cfg_attr(feature = "serde", serde(rename = "MOBL"))]
    Mobl,
    #[yaserde(rename = "FPIN")]
    #[cfg_attr(feature = "serde", serde(rename = "FPIN"))]
    Fpin,
    __Unknown__(String),
}

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

impl Validate for AuthenticationMethod11Code {}



#[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:cain.023.001.01")]
pub struct BatchManagementInformation1 {
    #[yaserde(rename = "ColltnId")]
    #[cfg_attr(feature = "serde", serde(rename = "ColltnId"))]
    pub colltn_id: Max35Text,

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

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

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

impl Validate for BatchManagementInformation1 {}


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

pub enum BytePadding1Code {
    #[yaserde(rename = "LNGT")]
    #[cfg_attr(feature = "serde", serde(rename = "LNGT"))]
    Lngt,
    #[yaserde(rename = "NUL8")]
    #[cfg_attr(feature = "serde", serde(rename = "NUL8"))]
    Nul8,
    #[yaserde(rename = "NULG")]
    #[cfg_attr(feature = "serde", serde(rename = "NULG"))]
    Nulg,
    #[yaserde(rename = "NULL")]
    #[cfg_attr(feature = "serde", serde(rename = "NULL"))]
    Null,
    #[yaserde(rename = "RAND")]
    #[cfg_attr(feature = "serde", serde(rename = "RAND"))]
    Rand,
    __Unknown__(String),
}

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

impl Validate for BytePadding1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct Capabilities1 {
    #[yaserde(rename = "CardRdngCpblty")]
    #[cfg_attr(feature = "serde", serde(rename = "CardRdngCpblty"))]
    pub card_rdng_cpblty: Vec<CardDataReading7Code>,

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

    #[yaserde(rename = "CardWrtgCpblties")]
    #[cfg_attr(feature = "serde", serde(rename = "CardWrtgCpblties"))]
    pub card_wrtg_cpblties: Vec<CardDataWriting1Code>,

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

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

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

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

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

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

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

    #[yaserde(rename = "CrdhldrVrfctnCpblty")]
    #[cfg_attr(feature = "serde", serde(rename = "CrdhldrVrfctnCpblty"))]
    pub crdhldr_vrfctn_cpblty: Vec<CardholderVerificationCapabilities1>,
}

impl Validate for Capabilities1 {}


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

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

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

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

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

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

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

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

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

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

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

impl Validate for CardData1 {}


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

pub enum CardDataReading7Code {
    #[yaserde(rename = "CDFL")]
    #[cfg_attr(feature = "serde", serde(rename = "CDFL"))]
    Cdfl,
    #[yaserde(rename = "ICPY")]
    #[cfg_attr(feature = "serde", serde(rename = "ICPY"))]
    Icpy,
    #[yaserde(rename = "MGST")]
    #[cfg_attr(feature = "serde", serde(rename = "MGST"))]
    Mgst,
    #[yaserde(rename = "ICCY")]
    #[cfg_attr(feature = "serde", serde(rename = "ICCY"))]
    Iccy,
    #[yaserde(rename = "MICR")]
    #[cfg_attr(feature = "serde", serde(rename = "MICR"))]
    Micr,
    #[yaserde(rename = "MLEY")]
    #[cfg_attr(feature = "serde", serde(rename = "MLEY"))]
    Mley,
    #[yaserde(rename = "OCRR")]
    #[cfg_attr(feature = "serde", serde(rename = "OCRR"))]
    Ocrr,
    #[yaserde(rename = "MSIP")]
    #[cfg_attr(feature = "serde", serde(rename = "MSIP"))]
    Msip,
    #[yaserde(rename = "OPTC")]
    #[cfg_attr(feature = "serde", serde(rename = "OPTC"))]
    Optc,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "RFID")]
    #[cfg_attr(feature = "serde", serde(rename = "RFID"))]
    Rfid,
    #[yaserde(rename = "UNSP")]
    #[cfg_attr(feature = "serde", serde(rename = "UNSP"))]
    Unsp,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "KEEN")]
    #[cfg_attr(feature = "serde", serde(rename = "KEEN"))]
    Keen,
    __Unknown__(String),
}

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

impl Validate for CardDataReading7Code {}



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

pub enum CardDataWriting1Code {
    #[yaserde(rename = "ICPY")]
    #[cfg_attr(feature = "serde", serde(rename = "ICPY"))]
    Icpy,
    #[yaserde(rename = "MGST")]
    #[cfg_attr(feature = "serde", serde(rename = "MGST"))]
    Mgst,
    #[yaserde(rename = "ICCY")]
    #[cfg_attr(feature = "serde", serde(rename = "ICCY"))]
    Iccy,
    #[yaserde(rename = "MSIP")]
    #[cfg_attr(feature = "serde", serde(rename = "MSIP"))]
    Msip,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "UNSP")]
    #[cfg_attr(feature = "serde", serde(rename = "UNSP"))]
    Unsp,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    __Unknown__(String),
}

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

impl Validate for CardDataWriting1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct CardManagementInitiation1 {
    #[yaserde(rename = "Envt")]
    #[cfg_attr(feature = "serde", serde(rename = "Envt"))]
    pub envt: Environment12,

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

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

    #[yaserde(rename = "PrcgRslt")]
    #[cfg_attr(feature = "serde", serde(rename = "PrcgRslt"))]
    pub prcg_rslt: ProcessingResult1,

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

    #[yaserde(rename = "PrtctdData")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtctdData"))]
    pub prtctd_data: Vec<ProtectedData1>,

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

impl Validate for CardManagementInitiation1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct CardManagementInitiationV01 {
    #[yaserde(rename = "Hdr")]
    #[cfg_attr(feature = "serde", serde(rename = "Hdr"))]
    pub hdr: Header39,

    #[yaserde(rename = "Body")]
    #[cfg_attr(feature = "serde", serde(rename = "Body"))]
    pub body: CardManagementInitiation1,

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

impl Validate for CardManagementInitiationV01 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct CardProgramme1 {
    #[yaserde(rename = "CardPrgrmmPropsd")]
    #[cfg_attr(feature = "serde", serde(rename = "CardPrgrmmPropsd"))]
    pub card_prgrmm_propsd: Vec<CardProgrammeMode2>,

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

impl Validate for CardProgramme1 {}


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

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

impl Validate for CardProgrammeMode1 {}


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

    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Vec<Max35Text>,
}

impl Validate for CardProgrammeMode2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct Cardholder15 {
    #[yaserde(rename = "CrdhldrNm")]
    #[cfg_attr(feature = "serde", serde(rename = "CrdhldrNm"))]
    pub crdhldr_nm: CardholderName1,

    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Vec<Credentials1>,

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

    #[yaserde(rename = "CtctInf")]
    #[cfg_attr(feature = "serde", serde(rename = "CtctInf"))]
    pub ctct_inf: Contact1,

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

impl Validate for Cardholder15 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct CardholderName1 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max70Text,

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

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

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

impl Validate for CardholderName1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct CardholderVerificationCapabilities1 {
    #[yaserde(rename = "Cpblty")]
    #[cfg_attr(feature = "serde", serde(rename = "Cpblty"))]
    pub cpblty: CardholderVerificationCapability5Code,

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

impl Validate for CardholderVerificationCapabilities1 {}


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

pub enum CardholderVerificationCapability5Code {
    #[yaserde(rename = "APKI")]
    #[cfg_attr(feature = "serde", serde(rename = "APKI"))]
    Apki,
    #[yaserde(rename = "NOVF")]
    #[cfg_attr(feature = "serde", serde(rename = "NOVF"))]
    Novf,
    #[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 = "NBIO")]
    #[cfg_attr(feature = "serde", serde(rename = "NBIO"))]
    Nbio,
    #[yaserde(rename = "NPIN")]
    #[cfg_attr(feature = "serde", serde(rename = "NPIN"))]
    Npin,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "SIGN")]
    #[cfg_attr(feature = "serde", serde(rename = "SIGN"))]
    Sign,
    #[yaserde(rename = "UNSP")]
    #[cfg_attr(feature = "serde", serde(rename = "UNSP"))]
    Unsp,
    #[yaserde(rename = "VORN")]
    #[cfg_attr(feature = "serde", serde(rename = "VORN"))]
    Vorn,
    #[yaserde(rename = "PKIS")]
    #[cfg_attr(feature = "serde", serde(rename = "PKIS"))]
    Pkis,
    #[yaserde(rename = "NOPN")]
    #[cfg_attr(feature = "serde", serde(rename = "NOPN"))]
    Nopn,
    #[yaserde(rename = "NOOP")]
    #[cfg_attr(feature = "serde", serde(rename = "NOOP"))]
    Noop,
    __Unknown__(String),
}

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

impl Validate for CardholderVerificationCapability5Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct CertificateIssuer1 {
    #[yaserde(rename = "RltvDstngshdNm")]
    #[cfg_attr(feature = "serde", serde(rename = "RltvDstngshdNm"))]
    pub rltv_dstngshd_nm: Vec<RelativeDistinguishedName1>,
}

impl Validate for CertificateIssuer1 {}


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

impl Validate for CommunicationCharacteristics3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct Contact1 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max70Text,

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

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

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

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

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

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

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

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

impl Validate for Contact1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct Content1 {
    #[yaserde(rename = "Val")]
    #[cfg_attr(feature = "serde", serde(rename = "Val"))]
    pub val: Max20KText,

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

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

impl Validate for Content1 {}


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

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

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

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

impl Validate for ContentInformationType19 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct ContentInformationType20 {
    #[yaserde(rename = "MACData")]
    #[cfg_attr(feature = "serde", serde(rename = "MACData"))]
    pub mac_data: Macdata1,

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

impl Validate for ContentInformationType20 {}


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

pub enum ContentType2Code {
    #[yaserde(rename = "DATA")]
    #[cfg_attr(feature = "serde", serde(rename = "DATA"))]
    Data,
    #[yaserde(rename = "SIGN")]
    #[cfg_attr(feature = "serde", serde(rename = "SIGN"))]
    Sign,
    #[yaserde(rename = "EVLP")]
    #[cfg_attr(feature = "serde", serde(rename = "EVLP"))]
    Evlp,
    #[yaserde(rename = "DGST")]
    #[cfg_attr(feature = "serde", serde(rename = "DGST"))]
    Dgst,
    #[yaserde(rename = "AUTH")]
    #[cfg_attr(feature = "serde", serde(rename = "AUTH"))]
    Auth,
    __Unknown__(String),
}

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

impl Validate for ContentType2Code {}



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

pub enum ContentType3Code {
    #[yaserde(rename = "EVLP")]
    #[cfg_attr(feature = "serde", serde(rename = "EVLP"))]
    Evlp,
    #[yaserde(rename = "IFSE")]
    #[cfg_attr(feature = "serde", serde(rename = "IFSE"))]
    Ifse,
    __Unknown__(String),
}

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

impl Validate for ContentType3Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct Context5 {
    #[yaserde(rename = "PtOfSvcCntxt")]
    #[cfg_attr(feature = "serde", serde(rename = "PtOfSvcCntxt"))]
    pub pt_of_svc_cntxt: PointOfServiceContext1,

    #[yaserde(rename = "TxCntxt")]
    #[cfg_attr(feature = "serde", serde(rename = "TxCntxt"))]
    pub tx_cntxt: TransactionContext1,

    #[yaserde(rename = "Vrfctn")]
    #[cfg_attr(feature = "serde", serde(rename = "Vrfctn"))]
    pub vrfctn: Vec<Verification1>,

    #[yaserde(rename = "RskCntxt")]
    #[cfg_attr(feature = "serde", serde(rename = "RskCntxt"))]
    pub rsk_cntxt: RiskContext1,
}

impl Validate for Context5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct Credentials1 {
    #[yaserde(rename = "IdCd")]
    #[cfg_attr(feature = "serde", serde(rename = "IdCd"))]
    pub id_cd: Identification2Code,

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

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

impl Validate for Credentials1 {}


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

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

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

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

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

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

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

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

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

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

impl Validate for CryptographicKey13 {}


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

pub enum CryptographicKeyType3Code {
    #[yaserde(rename = "AES2")]
    #[cfg_attr(feature = "serde", serde(rename = "AES2"))]
    Aes2,
    #[yaserde(rename = "EDE3")]
    #[cfg_attr(feature = "serde", serde(rename = "EDE3"))]
    Ede3,
    #[yaserde(rename = "DKP9")]
    #[cfg_attr(feature = "serde", serde(rename = "DKP9"))]
    Dkp9,
    #[yaserde(rename = "AES9")]
    #[cfg_attr(feature = "serde", serde(rename = "AES9"))]
    Aes9,
    #[yaserde(rename = "AES5")]
    #[cfg_attr(feature = "serde", serde(rename = "AES5"))]
    Aes5,
    #[yaserde(rename = "EDE4")]
    #[cfg_attr(feature = "serde", serde(rename = "EDE4"))]
    Ede4,
    __Unknown__(String),
}

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

impl Validate for CryptographicKeyType3Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct CustomerDevice2 {
    #[yaserde(rename = "Dvc")]
    #[cfg_attr(feature = "serde", serde(rename = "Dvc"))]
    pub dvc: Device1,

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

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

impl Validate for CustomerDevice2 {}


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

pub enum CustomerDeviceType1Code {
    #[yaserde(rename = "MOBL")]
    #[cfg_attr(feature = "serde", serde(rename = "MOBL"))]
    Mobl,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "PECR")]
    #[cfg_attr(feature = "serde", serde(rename = "PECR"))]
    Pecr,
    #[yaserde(rename = "TBLT")]
    #[cfg_attr(feature = "serde", serde(rename = "TBLT"))]
    Tblt,
    #[yaserde(rename = "NSCR")]
    #[cfg_attr(feature = "serde", serde(rename = "NSCR"))]
    Nscr,
    #[yaserde(rename = "SECR")]
    #[cfg_attr(feature = "serde", serde(rename = "SECR"))]
    Secr,
    __Unknown__(String),
}

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

impl Validate for CustomerDeviceType1Code {}



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

pub enum DetailAmount2Code {
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "SRCH")]
    #[cfg_attr(feature = "serde", serde(rename = "SRCH"))]
    Srch,
    __Unknown__(String),
}

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

impl Validate for DetailAmount2Code {}



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

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

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

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

impl Validate for DetailedAmount20 {}


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

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

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

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

    #[yaserde(rename = "Lctn")]
    #[cfg_attr(feature = "serde", serde(rename = "Lctn"))]
    pub lctn: GeographicCoordinates1,

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

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

impl Validate for Device1 {}


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

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

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

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

impl Validate for DigestedData5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct DisplayCapabilities6 {
    #[yaserde(rename = "Dstn")]
    #[cfg_attr(feature = "serde", serde(rename = "Dstn"))]
    pub dstn: UserInterface1Code,

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


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct Document {
    #[yaserde(rename = "CardMgmtInitn")]
    #[cfg_attr(feature = "serde", serde(rename = "CardMgmtInitn"))]
    pub card_mgmt_initn: CardManagementInitiationV01,
}

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:cain.023.001.01")]
pub struct EcommerceData1 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: Max35Text,

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

impl Validate for EcommerceData1 {}


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

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

impl Validate for EncapsulatedContent3 {}


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

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

impl Validate for EncryptedContent4 {}


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

    #[yaserde(rename = "NcrptdDataElmt")]
    #[cfg_attr(feature = "serde", serde(rename = "NcrptdDataElmt"))]
    pub ncrptd_data_elmt: Vec<EncryptedDataElement1>,
}

impl Validate for EncryptedContent5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct EncryptedData1 {
    #[yaserde(rename = "Ctrl")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctrl"))]
    pub ctrl: Exact1HexBinaryText,

    #[yaserde(rename = "KeySetIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "KeySetIdr"))]
    pub key_set_idr: Max8NumericText,

    #[yaserde(rename = "DrvdInf")]
    #[cfg_attr(feature = "serde", serde(rename = "DrvdInf"))]
    pub drvd_inf: Max32HexBinaryText,

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

    #[yaserde(rename = "KeyLngth")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyLngth"))]
    pub key_lngth: Max4NumericText,

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

    #[yaserde(rename = "KeyIndx")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyIndx"))]
    pub key_indx: Max5NumericText,

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

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

    #[yaserde(rename = "NcrptdDataElmt")]
    #[cfg_attr(feature = "serde", serde(rename = "NcrptdDataElmt"))]
    pub ncrptd_data_elmt: Vec<EncryptedDataElement1>,
}

impl Validate for EncryptedData1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct EncryptedData1Choice {
    #[yaserde(rename = "BinryData")]
    #[cfg_attr(feature = "serde", serde(rename = "BinryData"))]
    pub binry_data: Option<Max100KBinary>,
    #[yaserde(rename = "HexBinryVal")]
    #[cfg_attr(feature = "serde", serde(rename = "HexBinryVal"))]
    pub hex_binry_val: Option<Max9999HexBinaryText>,
}

impl Validate for EncryptedData1Choice {}




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

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

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

    #[yaserde(rename = "ClearTxtDataFrmt")]
    #[cfg_attr(feature = "serde", serde(rename = "ClearTxtDataFrmt"))]
    pub clear_txt_data_frmt: EncryptedDataFormat1Code,

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

impl Validate for EncryptedDataElement1 {}


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

pub enum EncryptedDataFormat1Code {
    #[yaserde(rename = "ASCI")]
    #[cfg_attr(feature = "serde", serde(rename = "ASCI"))]
    Asci,
    #[yaserde(rename = "BINF")]
    #[cfg_attr(feature = "serde", serde(rename = "BINF"))]
    Binf,
    #[yaserde(rename = "EBCD")]
    #[cfg_attr(feature = "serde", serde(rename = "EBCD"))]
    Ebcd,
    #[yaserde(rename = "HEXF")]
    #[cfg_attr(feature = "serde", serde(rename = "HEXF"))]
    Hexf,
    #[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 EncryptedDataFormat1Code {
    fn default() -> EncryptedDataFormat1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for EncryptedDataFormat1Code {}



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

pub enum EncryptionFormat2Code {
    #[yaserde(rename = "TR31")]
    #[cfg_attr(feature = "serde", serde(rename = "TR31"))]
    Tr31,
    #[yaserde(rename = "TR34")]
    #[cfg_attr(feature = "serde", serde(rename = "TR34"))]
    Tr34,
    I238,
    __Unknown__(String),
}

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

impl Validate for EncryptionFormat2Code {}



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

pub enum EncryptionFormat3Code {
    #[yaserde(rename = "TR34")]
    #[cfg_attr(feature = "serde", serde(rename = "TR34"))]
    Tr34,
    #[yaserde(rename = "TR31")]
    #[cfg_attr(feature = "serde", serde(rename = "TR31"))]
    Tr31,
    #[yaserde(rename = "CTCE")]
    #[cfg_attr(feature = "serde", serde(rename = "CTCE"))]
    Ctce,
    #[yaserde(rename = "CBCE")]
    #[cfg_attr(feature = "serde", serde(rename = "CBCE"))]
    Cbce,
    __Unknown__(String),
}

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

impl Validate for EncryptionFormat3Code {}



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

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

impl Validate for EnvelopedData5 {}


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

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

impl Validate for EnvelopedData6 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct Environment12 {
    #[yaserde(rename = "Acqrr")]
    #[cfg_attr(feature = "serde", serde(rename = "Acqrr"))]
    pub acqrr: PartyIdentification197,

    #[yaserde(rename = "Sndr")]
    #[cfg_attr(feature = "serde", serde(rename = "Sndr"))]
    pub sndr: PartyIdentification197,

    #[yaserde(rename = "Rcvr")]
    #[cfg_attr(feature = "serde", serde(rename = "Rcvr"))]
    pub rcvr: PartyIdentification197,

    #[yaserde(rename = "Accptr")]
    #[cfg_attr(feature = "serde", serde(rename = "Accptr"))]
    pub accptr: PartyIdentification203,

    #[yaserde(rename = "Termnl")]
    #[cfg_attr(feature = "serde", serde(rename = "Termnl"))]
    pub termnl: Terminal1,

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

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

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

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

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

impl Validate for Environment12 {}


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

impl Validate for Exact12Text {
    fn validate(&self) -> Result<(), String> { 
        if self.0.len() != 12 {
            return Err(format!("Length validation error. \nExpected: 0 length == 12 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

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

impl Validate for Exact15Text {
    fn validate(&self) -> Result<(), String> { 
        if self.0.len() != 15 {
            return Err(format!("Length validation error. \nExpected: 0 length == 15 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

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

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

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

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

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

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

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

impl Validate for ExternalEncryptedElementIdentification1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct FeeAmount2 {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: ImpliedCurrencyAndAmount,

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

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

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

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

impl Validate for FeeAmount2 {}


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

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

    #[yaserde(rename = "Assgnr")]
    #[cfg_attr(feature = "serde", serde(rename = "Assgnr"))]
    pub assgnr: PartyType18Code,

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


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

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

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

impl Validate for GenericIdentification48 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct GenericInformation1 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max70Text,

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

impl Validate for GenericInformation1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct GeographicCoordinates1 {
    #[yaserde(rename = "Lat")]
    #[cfg_attr(feature = "serde", serde(rename = "Lat"))]
    pub lat: Max16Text,

    #[yaserde(rename = "Long")]
    #[cfg_attr(feature = "serde", serde(rename = "Long"))]
    pub long: Max16Text,
}

impl Validate for GeographicCoordinates1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct Header39 {
    #[yaserde(rename = "MsgFctn")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgFctn"))]
    pub msg_fctn: MessageFunction17Code,

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

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

    #[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 = "BtchMgmtInf")]
    #[cfg_attr(feature = "serde", serde(rename = "BtchMgmtInf"))]
    pub btch_mgmt_inf: BatchManagementInformation1,

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

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

    #[yaserde(rename = "TracData")]
    #[cfg_attr(feature = "serde", serde(rename = "TracData"))]
    pub trac_data: Vec<AdditionalData1>,

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

impl Validate for Header39 {}


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

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

impl Validate for Iso3NumericCurrencyCode {}
#[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 Isotime (pub String);
crate::simple_type!(Isotime);

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

pub enum Identification2Code {
    #[yaserde(rename = "DRID")]
    #[cfg_attr(feature = "serde", serde(rename = "DRID"))]
    Drid,
    #[yaserde(rename = "NTID")]
    #[cfg_attr(feature = "serde", serde(rename = "NTID"))]
    Ntid,
    #[yaserde(rename = "PASS")]
    #[cfg_attr(feature = "serde", serde(rename = "PASS"))]
    Pass,
    #[yaserde(rename = "SSYN")]
    #[cfg_attr(feature = "serde", serde(rename = "SSYN"))]
    Ssyn,
    #[yaserde(rename = "ARNB")]
    #[cfg_attr(feature = "serde", serde(rename = "ARNB"))]
    Arnb,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "EMAL")]
    #[cfg_attr(feature = "serde", serde(rename = "EMAL"))]
    Emal,
    #[yaserde(rename = "PHNB")]
    #[cfg_attr(feature = "serde", serde(rename = "PHNB"))]
    Phnb,
    __Unknown__(String),
}

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

impl Validate for Identification2Code {}



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

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

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

impl Validate for IssuerAndSerialNumber1 {}


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

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

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

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

impl Validate for Kek5 {}


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

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

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

impl Validate for Kek6 {}


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

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

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

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

impl Validate for Kekidentifier2 {}


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

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

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

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

impl Validate for Kekidentifier6 {}


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

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

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

impl Validate for KeyTransport5 {}


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

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

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

impl Validate for KeyTransport6 {}


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

pub enum KeyUsage1Code {
    #[yaserde(rename = "ENCR")]
    #[cfg_attr(feature = "serde", serde(rename = "ENCR"))]
    Encr,
    #[yaserde(rename = "DCPT")]
    #[cfg_attr(feature = "serde", serde(rename = "DCPT"))]
    Dcpt,
    #[yaserde(rename = "DENC")]
    #[cfg_attr(feature = "serde", serde(rename = "DENC"))]
    Denc,
    #[yaserde(rename = "DDEC")]
    #[cfg_attr(feature = "serde", serde(rename = "DDEC"))]
    Ddec,
    #[yaserde(rename = "TRNI")]
    #[cfg_attr(feature = "serde", serde(rename = "TRNI"))]
    Trni,
    #[yaserde(rename = "TRNX")]
    #[cfg_attr(feature = "serde", serde(rename = "TRNX"))]
    Trnx,
    #[yaserde(rename = "MACG")]
    #[cfg_attr(feature = "serde", serde(rename = "MACG"))]
    Macg,
    #[yaserde(rename = "MACV")]
    #[cfg_attr(feature = "serde", serde(rename = "MACV"))]
    Macv,
    #[yaserde(rename = "SIGG")]
    #[cfg_attr(feature = "serde", serde(rename = "SIGG"))]
    Sigg,
    #[yaserde(rename = "SUGV")]
    #[cfg_attr(feature = "serde", serde(rename = "SUGV"))]
    Sugv,
    #[yaserde(rename = "PINE")]
    #[cfg_attr(feature = "serde", serde(rename = "PINE"))]
    Pine,
    #[yaserde(rename = "PIND")]
    #[cfg_attr(feature = "serde", serde(rename = "PIND"))]
    Pind,
    #[yaserde(rename = "PINV")]
    #[cfg_attr(feature = "serde", serde(rename = "PINV"))]
    Pinv,
    #[yaserde(rename = "KEYG")]
    #[cfg_attr(feature = "serde", serde(rename = "KEYG"))]
    Keyg,
    #[yaserde(rename = "KEYI")]
    #[cfg_attr(feature = "serde", serde(rename = "KEYI"))]
    Keyi,
    #[yaserde(rename = "KEYX")]
    #[cfg_attr(feature = "serde", serde(rename = "KEYX"))]
    Keyx,
    #[yaserde(rename = "KEYD")]
    #[cfg_attr(feature = "serde", serde(rename = "KEYD"))]
    Keyd,
    __Unknown__(String),
}

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

impl Validate for KeyUsage1Code {}



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

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

pub enum LifeCycleSupport1Code {
    #[yaserde(rename = "AUTH")]
    #[cfg_attr(feature = "serde", serde(rename = "AUTH"))]
    Auth,
    #[yaserde(rename = "FINC")]
    #[cfg_attr(feature = "serde", serde(rename = "FINC"))]
    Finc,
    __Unknown__(String),
}

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

impl Validate for LifeCycleSupport1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct Macdata1 {
    #[yaserde(rename = "Ctrl")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctrl"))]
    pub ctrl: Exact1HexBinaryText,

    #[yaserde(rename = "KeySetIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "KeySetIdr"))]
    pub key_set_idr: Max8NumericText,

    #[yaserde(rename = "DrvdInf")]
    #[cfg_attr(feature = "serde", serde(rename = "DrvdInf"))]
    pub drvd_inf: Max32HexBinaryText,

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

    #[yaserde(rename = "KeyLngth")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyLngth"))]
    pub key_lngth: Max4NumericText,

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

    #[yaserde(rename = "KeyIndx")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyIndx"))]
    pub key_indx: Max5NumericText,

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

    #[yaserde(rename = "InitlstnVctr")]
    #[cfg_attr(feature = "serde", serde(rename = "InitlstnVctr"))]
    pub initlstn_vctr: Max32HexBinaryText,
}

impl Validate for Macdata1 {}


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

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

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

impl Validate for Max10KText {
    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 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 Max12NumericText (pub String);
crate::simple_type!(Max12NumericText);

impl Validate for Max12NumericText {}
#[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 Max16HexBinaryText (pub String);
crate::simple_type!(Max16HexBinaryText);

impl Validate for Max16HexBinaryText {}
#[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 Max19HexBinaryText (pub String);
crate::simple_type!(Max19HexBinaryText);

impl Validate for Max19HexBinaryText {}
#[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 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 Max20KText (pub String);
crate::simple_type!(Max20KText);

impl Validate for Max20KText {
    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 Max23NumericText (pub String);
crate::simple_type!(Max23NumericText);

impl Validate for Max23NumericText {}
#[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 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 Max32HexBinaryText (pub String);
crate::simple_type!(Max32HexBinaryText);

impl Validate for Max32HexBinaryText {}
#[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 Max4NumericText (pub String);
crate::simple_type!(Max4NumericText);

impl Validate for Max4NumericText {}
#[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 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 Max8HexBinaryText (pub String);
crate::simple_type!(Max8HexBinaryText);

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

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

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

impl Validate for Max99Text {
    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() > 99 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 99 \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:cain.023.001.01")]
pub struct MemoryCharacteristics1 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

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

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

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

impl Validate for MemoryCharacteristics1 {}


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

pub enum MemoryUnit1Code {
    #[yaserde(rename = "BYTE")]
    #[cfg_attr(feature = "serde", serde(rename = "BYTE"))]
    Byte,
    #[yaserde(rename = "EXAB")]
    #[cfg_attr(feature = "serde", serde(rename = "EXAB"))]
    Exab,
    #[yaserde(rename = "GIGA")]
    #[cfg_attr(feature = "serde", serde(rename = "GIGA"))]
    Giga,
    #[yaserde(rename = "KILO")]
    #[cfg_attr(feature = "serde", serde(rename = "KILO"))]
    Kilo,
    #[yaserde(rename = "MEGA")]
    #[cfg_attr(feature = "serde", serde(rename = "MEGA"))]
    Mega,
    #[yaserde(rename = "PETA")]
    #[cfg_attr(feature = "serde", serde(rename = "PETA"))]
    Peta,
    #[yaserde(rename = "TERA")]
    #[cfg_attr(feature = "serde", serde(rename = "TERA"))]
    Tera,
    __Unknown__(String),
}

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

impl Validate for MemoryUnit1Code {}



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

pub enum MessageClass1Code {
    #[yaserde(rename = "ADDE")]
    #[cfg_attr(feature = "serde", serde(rename = "ADDE"))]
    Adde,
    #[yaserde(rename = "AMDT")]
    #[cfg_attr(feature = "serde", serde(rename = "AMDT"))]
    Amdt,
    #[yaserde(rename = "AUTH")]
    #[cfg_attr(feature = "serde", serde(rename = "AUTH"))]
    Auth,
    #[yaserde(rename = "CMGT")]
    #[cfg_attr(feature = "serde", serde(rename = "CMGT"))]
    Cmgt,
    #[yaserde(rename = "CBCK")]
    #[cfg_attr(feature = "serde", serde(rename = "CBCK"))]
    Cbck,
    #[yaserde(rename = "FEEC")]
    #[cfg_attr(feature = "serde", serde(rename = "FEEC"))]
    Feec,
    #[yaserde(rename = "FINL")]
    #[cfg_attr(feature = "serde", serde(rename = "FINL"))]
    Finl,
    #[yaserde(rename = "INQY")]
    #[cfg_attr(feature = "serde", serde(rename = "INQY"))]
    Inqy,
    #[yaserde(rename = "VERI")]
    #[cfg_attr(feature = "serde", serde(rename = "VERI"))]
    Veri,
    __Unknown__(String),
}

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

impl Validate for MessageClass1Code {}



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

pub enum MessageFunction17Code {
    #[yaserde(rename = "NOTI")]
    #[cfg_attr(feature = "serde", serde(rename = "NOTI"))]
    Noti,
    #[yaserde(rename = "REQU")]
    #[cfg_attr(feature = "serde", serde(rename = "REQU"))]
    Requ,
    #[yaserde(rename = "ADVC")]
    #[cfg_attr(feature = "serde", serde(rename = "ADVC"))]
    Advc,
    __Unknown__(String),
}

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

impl Validate for MessageFunction17Code {}



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

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

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

pub enum OnLineCapability2Code {
    #[yaserde(rename = "OFLN")]
    #[cfg_attr(feature = "serde", serde(rename = "OFLN"))]
    Ofln,
    #[yaserde(rename = "ONLN")]
    #[cfg_attr(feature = "serde", serde(rename = "ONLN"))]
    Onln,
    #[yaserde(rename = "BOTH")]
    #[cfg_attr(feature = "serde", serde(rename = "BOTH"))]
    Both,
    __Unknown__(String),
}

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

impl Validate for OnLineCapability2Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct OriginalDataElements1 {
    #[yaserde(rename = "MsgClss")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgClss"))]
    pub msg_clss: MessageClass1Code,

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

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

    #[yaserde(rename = "SndrId")]
    #[cfg_attr(feature = "serde", serde(rename = "SndrId"))]
    pub sndr_id: Max11NumericText,

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

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

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

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

    #[yaserde(rename = "SysTracAudtNb")]
    #[cfg_attr(feature = "serde", serde(rename = "SysTracAudtNb"))]
    pub sys_trac_audt_nb: Max12NumericText,

    #[yaserde(rename = "RtrvlRefNb")]
    #[cfg_attr(feature = "serde", serde(rename = "RtrvlRefNb"))]
    pub rtrvl_ref_nb: Exact12Text,

    #[yaserde(rename = "LifeCyclSpprt")]
    #[cfg_attr(feature = "serde", serde(rename = "LifeCyclSpprt"))]
    pub life_cycl_spprt: LifeCycleSupport1Code,

    #[yaserde(rename = "LifeCyclTracIdData")]
    #[cfg_attr(feature = "serde", serde(rename = "LifeCyclTracIdData"))]
    pub life_cycl_trac_id_data: TransactionLifeCycleIdentification1,

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

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

    #[yaserde(rename = "AcqrrRefNb")]
    #[cfg_attr(feature = "serde", serde(rename = "AcqrrRefNb"))]
    pub acqrr_ref_nb: Max23NumericText,

    #[yaserde(rename = "CardIssrRefData")]
    #[cfg_attr(feature = "serde", serde(rename = "CardIssrRefData"))]
    pub card_issr_ref_data: Max1000Text,
}

impl Validate for OriginalDataElements1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct OriginatorInformation1 {
    #[yaserde(rename = "Cert")]
    #[cfg_attr(feature = "serde", serde(rename = "Cert"))]
    pub cert: Vec<Max5000Binary>,
}

impl Validate for OriginatorInformation1 {}


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

pub enum OutputFormat1Code {
    #[yaserde(rename = "MREF")]
    #[cfg_attr(feature = "serde", serde(rename = "MREF"))]
    Mref,
    #[yaserde(rename = "TEXT")]
    #[cfg_attr(feature = "serde", serde(rename = "TEXT"))]
    Text,
    #[yaserde(rename = "HTML")]
    #[cfg_attr(feature = "serde", serde(rename = "HTML"))]
    Html,
    __Unknown__(String),
}

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

impl Validate for OutputFormat1Code {}



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

pub enum OutputFormat4Code {
    #[yaserde(rename = "FLNM")]
    #[cfg_attr(feature = "serde", serde(rename = "FLNM"))]
    Flnm,
    #[yaserde(rename = "MREF")]
    #[cfg_attr(feature = "serde", serde(rename = "MREF"))]
    Mref,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "SMSI")]
    #[cfg_attr(feature = "serde", serde(rename = "SMSI"))]
    Smsi,
    #[yaserde(rename = "TEXT")]
    #[cfg_attr(feature = "serde", serde(rename = "TEXT"))]
    Text,
    #[yaserde(rename = "URLI")]
    #[cfg_attr(feature = "serde", serde(rename = "URLI"))]
    Urli,
    #[yaserde(rename = "HTML")]
    #[cfg_attr(feature = "serde", serde(rename = "HTML"))]
    Html,
    __Unknown__(String),
}

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

impl Validate for OutputFormat4Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct Pindata1 {
    #[yaserde(rename = "Ctrl")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctrl"))]
    pub ctrl: Exact1HexBinaryText,

    #[yaserde(rename = "KeySetIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "KeySetIdr"))]
    pub key_set_idr: Max8NumericText,

    #[yaserde(rename = "DrvdInf")]
    #[cfg_attr(feature = "serde", serde(rename = "DrvdInf"))]
    pub drvd_inf: Max32HexBinaryText,

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

    #[yaserde(rename = "KeyLngth")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyLngth"))]
    pub key_lngth: Max4NumericText,

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

    #[yaserde(rename = "KeyIndx")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyIndx"))]
    pub key_indx: Max5NumericText,

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

    #[yaserde(rename = "NcrptdPINBlck")]
    #[cfg_attr(feature = "serde", serde(rename = "NcrptdPINBlck"))]
    pub ncrptd_pin_blck: Max16HexBinaryText,
}

impl Validate for Pindata1 {}


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

pub enum PoicommunicationType2Code {
    #[yaserde(rename = "BLTH")]
    #[cfg_attr(feature = "serde", serde(rename = "BLTH"))]
    Blth,
    #[yaserde(rename = "ETHR")]
    #[cfg_attr(feature = "serde", serde(rename = "ETHR"))]
    Ethr,
    #[yaserde(rename = "GPRS")]
    #[cfg_attr(feature = "serde", serde(rename = "GPRS"))]
    Gprs,
    #[yaserde(rename = "GSMF")]
    #[cfg_attr(feature = "serde", serde(rename = "GSMF"))]
    Gsmf,
    #[yaserde(rename = "PSTN")]
    #[cfg_attr(feature = "serde", serde(rename = "PSTN"))]
    Pstn,
    #[yaserde(rename = "RS23")]
    #[cfg_attr(feature = "serde", serde(rename = "RS23"))]
    Rs23,
    #[yaserde(rename = "USBD")]
    #[cfg_attr(feature = "serde", serde(rename = "USBD"))]
    Usbd,
    #[yaserde(rename = "USBH")]
    #[cfg_attr(feature = "serde", serde(rename = "USBH"))]
    Usbh,
    #[yaserde(rename = "WIFI")]
    #[cfg_attr(feature = "serde", serde(rename = "WIFI"))]
    Wifi,
    #[yaserde(rename = "WT2G")]
    #[cfg_attr(feature = "serde", serde(rename = "WT2G"))]
    Wt2G,
    #[yaserde(rename = "WT3G")]
    #[cfg_attr(feature = "serde", serde(rename = "WT3G"))]
    Wt3G,
    #[yaserde(rename = "WT4G")]
    #[cfg_attr(feature = "serde", serde(rename = "WT4G"))]
    Wt4G,
    #[yaserde(rename = "WT5G")]
    #[cfg_attr(feature = "serde", serde(rename = "WT5G"))]
    Wt5G,
    __Unknown__(String),
}

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

impl Validate for PoicommunicationType2Code {}



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

pub enum PoicomponentAssessment1Code {
    #[yaserde(rename = "APPL")]
    #[cfg_attr(feature = "serde", serde(rename = "APPL"))]
    Appl,
    #[yaserde(rename = "CERT")]
    #[cfg_attr(feature = "serde", serde(rename = "CERT"))]
    Cert,
    #[yaserde(rename = "EVAL")]
    #[cfg_attr(feature = "serde", serde(rename = "EVAL"))]
    Eval,
    __Unknown__(String),
}

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

impl Validate for PoicomponentAssessment1Code {}



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

pub enum PoicomponentStatus1Code {
    #[yaserde(rename = "WAIT")]
    #[cfg_attr(feature = "serde", serde(rename = "WAIT"))]
    Wait,
    #[yaserde(rename = "OUTD")]
    #[cfg_attr(feature = "serde", serde(rename = "OUTD"))]
    Outd,
    #[yaserde(rename = "OPER")]
    #[cfg_attr(feature = "serde", serde(rename = "OPER"))]
    Oper,
    #[yaserde(rename = "DACT")]
    #[cfg_attr(feature = "serde", serde(rename = "DACT"))]
    Dact,
    __Unknown__(String),
}

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

impl Validate for PoicomponentStatus1Code {}



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

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

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

impl Validate for PoicomponentType5Code {}



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

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

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

impl Validate for Parameter10 {}


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

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

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

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

impl Validate for Parameter11 {}


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

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

    #[yaserde(rename = "BPddg")]
    #[cfg_attr(feature = "serde", serde(rename = "BPddg"))]
    pub b_pddg: BytePadding1Code,
}

impl Validate for Parameter12 {}


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

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

impl Validate for Parameter13 {}


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

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


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

impl Validate for Parameter5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct Parameter7 {
    #[yaserde(rename = "InitlstnVctr")]
    #[cfg_attr(feature = "serde", serde(rename = "InitlstnVctr"))]
    pub initlstn_vctr: Max500Binary,

    #[yaserde(rename = "BPddg")]
    #[cfg_attr(feature = "serde", serde(rename = "BPddg"))]
    pub b_pddg: BytePadding1Code,
}

impl Validate for Parameter7 {}


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

impl Validate for Parameter9 {}


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

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

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

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

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

impl Validate for PartyIdentification197 {}


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

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

    #[yaserde(rename = "Assgnr")]
    #[cfg_attr(feature = "serde", serde(rename = "Assgnr"))]
    pub assgnr: PartyType18Code,

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

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

impl Validate for PartyIdentification200 {}


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

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

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

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

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

    #[yaserde(rename = "NmAndLctn")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndLctn"))]
    pub nm_and_lctn: Max99Text,

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

    #[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 = "PhneNb")]
    #[cfg_attr(feature = "serde", serde(rename = "PhneNb"))]
    pub phne_nb: Max35Text,

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

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

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

    #[yaserde(rename = "AddtlData")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlData"))]
    pub addtl_data: Vec<AdditionalData1>,

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

impl Validate for PartyIdentification203 {}


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

pub enum PartyType17Code {
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "ACQR")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
    Acqr,
    #[yaserde(rename = "ACQP")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQP"))]
    Acqp,
    #[yaserde(rename = "CISS")]
    #[cfg_attr(feature = "serde", serde(rename = "CISS"))]
    Ciss,
    #[yaserde(rename = "CISP")]
    #[cfg_attr(feature = "serde", serde(rename = "CISP"))]
    Cisp,
    #[yaserde(rename = "AGNT")]
    #[cfg_attr(feature = "serde", serde(rename = "AGNT"))]
    Agnt,
    __Unknown__(String),
}

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

impl Validate for PartyType17Code {}



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

pub enum PartyType18Code {
    #[yaserde(rename = "ACQR")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
    Acqr,
    #[yaserde(rename = "CISS")]
    #[cfg_attr(feature = "serde", serde(rename = "CISS"))]
    Ciss,
    #[yaserde(rename = "CSCH")]
    #[cfg_attr(feature = "serde", serde(rename = "CSCH"))]
    Csch,
    #[yaserde(rename = "AGNT")]
    #[cfg_attr(feature = "serde", serde(rename = "AGNT"))]
    Agnt,
    __Unknown__(String),
}

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

impl Validate for PartyType18Code {}



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

pub enum PartyType20Code {
    #[yaserde(rename = "ACCP")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCP"))]
    Accp,
    #[yaserde(rename = "ACQR")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
    Acqr,
    #[yaserde(rename = "CRDH")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDH"))]
    Crdh,
    #[yaserde(rename = "CISS")]
    #[cfg_attr(feature = "serde", serde(rename = "CISS"))]
    Ciss,
    #[yaserde(rename = "AGNT")]
    #[cfg_attr(feature = "serde", serde(rename = "AGNT"))]
    Agnt,
    __Unknown__(String),
}

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

impl Validate for PartyType20Code {}



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

pub enum PartyType21Code {
    #[yaserde(rename = "ACCP")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCP"))]
    Accp,
    #[yaserde(rename = "CRDH")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDH"))]
    Crdh,
    #[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 PartyType21Code {
    fn default() -> PartyType21Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for PartyType21Code {}



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

pub enum PartyType22Code {
    #[yaserde(rename = "CRDH")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDH"))]
    Crdh,
    #[yaserde(rename = "MERC")]
    #[cfg_attr(feature = "serde", serde(rename = "MERC"))]
    Merc,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "AGNT")]
    #[cfg_attr(feature = "serde", serde(rename = "AGNT"))]
    Agnt,
    __Unknown__(String),
}

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

impl Validate for PartyType22Code {}



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

pub enum PartyType26Code {
    #[yaserde(rename = "ACCP")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCP"))]
    Accp,
    #[yaserde(rename = "ACQR")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
    Acqr,
    #[yaserde(rename = "ICCA")]
    #[cfg_attr(feature = "serde", serde(rename = "ICCA"))]
    Icca,
    #[yaserde(rename = "CISS")]
    #[cfg_attr(feature = "serde", serde(rename = "CISS"))]
    Ciss,
    #[yaserde(rename = "DLIS")]
    #[cfg_attr(feature = "serde", serde(rename = "DLIS"))]
    Dlis,
    #[yaserde(rename = "AGNT")]
    #[cfg_attr(feature = "serde", serde(rename = "AGNT"))]
    Agnt,
    #[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 PartyType26Code {
    fn default() -> PartyType26Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for PartyType26Code {}



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

pub enum PartyType28Code {
    #[yaserde(rename = "ACCP")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCP"))]
    Accp,
    #[yaserde(rename = "ACQR")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
    Acqr,
    #[yaserde(rename = "AGNT")]
    #[cfg_attr(feature = "serde", serde(rename = "AGNT"))]
    Agnt,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "WLPR")]
    #[cfg_attr(feature = "serde", serde(rename = "WLPR"))]
    Wlpr,
    #[yaserde(rename = "ISUR")]
    #[cfg_attr(feature = "serde", serde(rename = "ISUR"))]
    Isur,
    __Unknown__(String),
}

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

impl Validate for PartyType28Code {}



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

pub enum PartyType7Code {
    #[yaserde(rename = "ACQR")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
    Acqr,
    #[yaserde(rename = "ITAG")]
    #[cfg_attr(feature = "serde", serde(rename = "ITAG"))]
    Itag,
    #[yaserde(rename = "PCPT")]
    #[cfg_attr(feature = "serde", serde(rename = "PCPT"))]
    Pcpt,
    #[yaserde(rename = "TMGT")]
    #[cfg_attr(feature = "serde", serde(rename = "TMGT"))]
    Tmgt,
    #[yaserde(rename = "SALE")]
    #[cfg_attr(feature = "serde", serde(rename = "SALE"))]
    Sale,
    __Unknown__(String),
}

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

impl Validate for PartyType7Code {}



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

pub enum PartyType9Code {
    #[yaserde(rename = "ACQR")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
    Acqr,
    #[yaserde(rename = "ACQP")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQP"))]
    Acqp,
    #[yaserde(rename = "CISS")]
    #[cfg_attr(feature = "serde", serde(rename = "CISS"))]
    Ciss,
    #[yaserde(rename = "CISP")]
    #[cfg_attr(feature = "serde", serde(rename = "CISP"))]
    Cisp,
    #[yaserde(rename = "CSCH")]
    #[cfg_attr(feature = "serde", serde(rename = "CSCH"))]
    Csch,
    #[yaserde(rename = "SCHP")]
    #[cfg_attr(feature = "serde", serde(rename = "SCHP"))]
    Schp,
    __Unknown__(String),
}

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

impl Validate for PartyType9Code {}



#[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)]
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:cain.023.001.01")]
pub struct PointOfInteractionComponent8 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: PoicomponentType5Code,

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

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

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

impl Validate for PointOfInteractionComponent8 {}


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

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

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

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

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

impl Validate for PointOfInteractionComponentAssessment1 {}


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

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

impl Validate for PointOfInteractionComponentCharacteristics4 {}


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

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

impl Validate for PointOfInteractionComponentIdentification1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct PointOfInteractionComponentStatus3 {
    #[yaserde(rename = "VrsnNb")]
    #[cfg_attr(feature = "serde", serde(rename = "VrsnNb"))]
    pub vrsn_nb: Max256Text,

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

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

impl Validate for PointOfInteractionComponentStatus3 {}


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

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

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

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

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

    #[yaserde(rename = "EComrcData")]
    #[cfg_attr(feature = "serde", serde(rename = "EComrcData"))]
    pub e_comrc_data: Vec<EcommerceData1>,

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

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

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

    #[yaserde(rename = "SctyChrtcs")]
    #[cfg_attr(feature = "serde", serde(rename = "SctyChrtcs"))]
    pub scty_chrtcs: Vec<SecurityCharacteristics1Code>,

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

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

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

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

    #[yaserde(rename = "SpclConds")]
    #[cfg_attr(feature = "serde", serde(rename = "SpclConds"))]
    pub spcl_conds: Vec<SpecialConditions1>,
}

impl Validate for PointOfServiceContext1 {}


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

pub enum Priority3Code {
    #[yaserde(rename = "URGT")]
    #[cfg_attr(feature = "serde", serde(rename = "URGT"))]
    Urgt,
    #[yaserde(rename = "HIGH")]
    #[cfg_attr(feature = "serde", serde(rename = "HIGH"))]
    High,
    #[yaserde(rename = "NORM")]
    #[cfg_attr(feature = "serde", serde(rename = "NORM"))]
    Norm,
    __Unknown__(String),
}

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

impl Validate for Priority3Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct ProcessingResult1 {
    #[yaserde(rename = "ApprvlData")]
    #[cfg_attr(feature = "serde", serde(rename = "ApprvlData"))]
    pub apprvl_data: ApprovalData1,

    #[yaserde(rename = "RsltData")]
    #[cfg_attr(feature = "serde", serde(rename = "RsltData"))]
    pub rslt_data: ResultData1,

    #[yaserde(rename = "OrgnlRsltData")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlRsltData"))]
    pub orgnl_rslt_data: ResultData1,

    #[yaserde(rename = "ActnReqrd")]
    #[cfg_attr(feature = "serde", serde(rename = "ActnReqrd"))]
    pub actn_reqrd: YesNoIndicator,

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

    #[yaserde(rename = "AddtlActn")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlActn"))]
    pub addtl_actn: Vec<AdditionalAction1>,

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

impl Validate for ProcessingResult1 {}


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

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

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

impl Validate for ProtectedData1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct Recipient5Choice {
    #[yaserde(rename = "IssrAndSrlNb")]
    #[cfg_attr(feature = "serde", serde(rename = "IssrAndSrlNb"))]
    pub issr_and_srl_nb: Option<IssuerAndSerialNumber1>,
    #[yaserde(rename = "KeyIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyIdr"))]
    pub key_idr: Option<Kekidentifier2>,
}

impl Validate for Recipient5Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct Recipient6Choice {
    #[yaserde(rename = "KeyTrnsprt")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyTrnsprt"))]
    pub key_trnsprt: Option<KeyTransport5>,
    #[yaserde(rename = "KEK")]
    #[cfg_attr(feature = "serde", serde(rename = "KEK"))]
    pub kek: Option<Kek5>,
    #[yaserde(rename = "KeyIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyIdr"))]
    pub key_idr: Option<Kekidentifier2>,
}

impl Validate for Recipient6Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct Recipient7Choice {
    #[yaserde(rename = "KeyTrnsprt")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyTrnsprt"))]
    pub key_trnsprt: Option<KeyTransport6>,
    #[yaserde(rename = "KEK")]
    #[cfg_attr(feature = "serde", serde(rename = "KEK"))]
    pub kek: Option<Kek6>,
    #[yaserde(rename = "KeyIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyIdr"))]
    pub key_idr: Option<Kekidentifier6>,
}

impl Validate for Recipient7Choice {}




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

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

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

impl Validate for Reconciliation3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct RelativeDistinguishedName1 {
    #[yaserde(rename = "AttrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "AttrTp"))]
    pub attr_tp: AttributeType1Code,

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

impl Validate for RelativeDistinguishedName1 {}


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

pub enum Response8Code {
    #[yaserde(rename = "PRCS")]
    #[cfg_attr(feature = "serde", serde(rename = "PRCS"))]
    Prcs,
    #[yaserde(rename = "UNPR")]
    #[cfg_attr(feature = "serde", serde(rename = "UNPR"))]
    Unpr,
    #[yaserde(rename = "UNRV")]
    #[cfg_attr(feature = "serde", serde(rename = "UNRV"))]
    Unrv,
    #[yaserde(rename = "REJT")]
    #[cfg_attr(feature = "serde", serde(rename = "REJT"))]
    Rejt,
    #[yaserde(rename = "TECH")]
    #[cfg_attr(feature = "serde", serde(rename = "TECH"))]
    Tech,
    #[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 Response8Code {
    fn default() -> Response8Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for Response8Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct ResultData1 {
    #[yaserde(rename = "Rslt")]
    #[cfg_attr(feature = "serde", serde(rename = "Rslt"))]
    pub rslt: Response8Code,

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

    #[yaserde(rename = "RsltDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "RsltDtls"))]
    pub rslt_dtls: Exact2AlphaNumericText,

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

    #[yaserde(rename = "AddtlRsltInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlRsltInf"))]
    pub addtl_rslt_inf: Vec<AdditionalData1>,
}

impl Validate for ResultData1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct RiskAssessment1 {
    #[yaserde(rename = "RskAssmntNtty")]
    #[cfg_attr(feature = "serde", serde(rename = "RskAssmntNtty"))]
    pub rsk_assmnt_ntty: PartyIdentification200,

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

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

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

    #[yaserde(rename = "AddtlRskData")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlRskData"))]
    pub addtl_rsk_data: Vec<AdditionalRiskData1>,

    #[yaserde(rename = "RcmmnddActn")]
    #[cfg_attr(feature = "serde", serde(rename = "RcmmnddActn"))]
    pub rcmmndd_actn: Vec<ActionType8Code>,

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

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

impl Validate for RiskAssessment1 {}


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

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

impl Validate for RiskAssessmentDataEntityProvider1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct RiskContext1 {
    #[yaserde(rename = "RskInptData")]
    #[cfg_attr(feature = "serde", serde(rename = "RskInptData"))]
    pub rsk_inpt_data: Vec<RiskInputData1>,

    #[yaserde(rename = "RskAssmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "RskAssmnt"))]
    pub rsk_assmnt: Vec<RiskAssessment1>,
}

impl Validate for RiskContext1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct RiskInputData1 {
    #[yaserde(rename = "Ntty")]
    #[cfg_attr(feature = "serde", serde(rename = "Ntty"))]
    pub ntty: RiskAssessmentDataEntityProvider1,

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

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

impl Validate for RiskInputData1 {}


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

pub enum SecurityCharacteristics1Code {
    #[yaserde(rename = "CETE")]
    #[cfg_attr(feature = "serde", serde(rename = "CETE"))]
    Cete,
    #[yaserde(rename = "CPTE")]
    #[cfg_attr(feature = "serde", serde(rename = "CPTE"))]
    Cpte,
    #[yaserde(rename = "CENC")]
    #[cfg_attr(feature = "serde", serde(rename = "CENC"))]
    Cenc,
    #[yaserde(rename = "CMAC")]
    #[cfg_attr(feature = "serde", serde(rename = "CMAC"))]
    Cmac,
    #[yaserde(rename = "ETEE")]
    #[cfg_attr(feature = "serde", serde(rename = "ETEE"))]
    Etee,
    #[yaserde(rename = "METE")]
    #[cfg_attr(feature = "serde", serde(rename = "METE"))]
    Mete,
    #[yaserde(rename = "MPTE")]
    #[cfg_attr(feature = "serde", serde(rename = "MPTE"))]
    Mpte,
    #[yaserde(rename = "OPNN")]
    #[cfg_attr(feature = "serde", serde(rename = "OPNN"))]
    Opnn,
    #[yaserde(rename = "PMAC")]
    #[cfg_attr(feature = "serde", serde(rename = "PMAC"))]
    Pmac,
    #[yaserde(rename = "PKIE")]
    #[cfg_attr(feature = "serde", serde(rename = "PKIE"))]
    Pkie,
    #[yaserde(rename = "PRAE")]
    #[cfg_attr(feature = "serde", serde(rename = "PRAE"))]
    Prae,
    #[yaserde(rename = "PRAM")]
    #[cfg_attr(feature = "serde", serde(rename = "PRAM"))]
    Pram,
    #[yaserde(rename = "PRVN")]
    #[cfg_attr(feature = "serde", serde(rename = "PRVN"))]
    Prvn,
    #[yaserde(rename = "STAM")]
    #[cfg_attr(feature = "serde", serde(rename = "STAM"))]
    Stam,
    #[yaserde(rename = "APTE")]
    #[cfg_attr(feature = "serde", serde(rename = "APTE"))]
    Apte,
    #[yaserde(rename = "AETE")]
    #[cfg_attr(feature = "serde", serde(rename = "AETE"))]
    Aete,
    #[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 SecurityCharacteristics1Code {
    fn default() -> SecurityCharacteristics1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for SecurityCharacteristics1Code {}



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

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

impl Validate for SettlementReportingEntity1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct SettlementService1 {
    #[yaserde(rename = "SttlmSvcPropsd")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmSvcPropsd"))]
    pub sttlm_svc_propsd: SettlementServiceMode1,

    #[yaserde(rename = "SttlmSvcApld")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmSvcApld"))]
    pub sttlm_svc_apld: SettlementServiceMode1,

    #[yaserde(rename = "SttlmSvcDts")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmSvcDts"))]
    pub sttlm_svc_dts: SettlementServiceDate1,

    #[yaserde(rename = "SttlmRptgNtty")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmRptgNtty"))]
    pub sttlm_rptg_ntty: SettlementReportingEntity1,
}

impl Validate for SettlementService1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct SettlementServiceDate1 {
    #[yaserde(rename = "ReqdSttlmDt")]
    #[cfg_attr(feature = "serde", serde(rename = "ReqdSttlmDt"))]
    pub reqd_sttlm_dt: Isodate,

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

    #[yaserde(rename = "SttlmTm")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmTm"))]
    pub sttlm_tm: Isotime,

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

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

impl Validate for SettlementServiceDate1 {}


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

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

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

    #[yaserde(rename = "SttlmPrty")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmPrty"))]
    pub sttlm_prty: Priority3Code,
}

impl Validate for SettlementServiceMode1 {}


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

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

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

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

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

impl Validate for SignedData5 {}


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

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

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

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

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

impl Validate for Signer4 {}


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

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

impl Validate for SpecialConditions1 {}


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

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

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

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

impl Validate for SponsoredMerchant1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct SupplementaryData1 {
    #[yaserde(rename = "PlcAndNm")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcAndNm"))]
    pub plc_and_nm: Max350Text,

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

impl Validate for SupplementaryData1 {}


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

impl Validate for SupplementaryDataEnvelope1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct Terminal1 {
    #[yaserde(rename = "TermnlId")]
    #[cfg_attr(feature = "serde", serde(rename = "TermnlId"))]
    pub termnl_id: TerminalIdentification1,

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

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

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

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

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

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

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

    #[yaserde(rename = "POICmpnt")]
    #[cfg_attr(feature = "serde", serde(rename = "POICmpnt"))]
    pub poi_cmpnt: Vec<PointOfInteractionComponent8>,
}

impl Validate for Terminal1 {}


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

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

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


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

pub enum TerminalIntegrationCategory1Code {
    #[yaserde(rename = "MPOI")]
    #[cfg_attr(feature = "serde", serde(rename = "MPOI"))]
    Mpoi,
    #[yaserde(rename = "MSLE")]
    #[cfg_attr(feature = "serde", serde(rename = "MSLE"))]
    Msle,
    #[yaserde(rename = "SSLE")]
    #[cfg_attr(feature = "serde", serde(rename = "SSLE"))]
    Ssle,
    __Unknown__(String),
}

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

impl Validate for TerminalIntegrationCategory1Code {}



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

pub enum TerminalType1Code {
    #[yaserde(rename = "ATMT")]
    #[cfg_attr(feature = "serde", serde(rename = "ATMT"))]
    Atmt,
    #[yaserde(rename = "MPOS")]
    #[cfg_attr(feature = "serde", serde(rename = "MPOS"))]
    Mpos,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "POST")]
    #[cfg_attr(feature = "serde", serde(rename = "POST"))]
    Post,
    __Unknown__(String),
}

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

impl Validate for TerminalType1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct Token1 {
    #[yaserde(rename = "PmtTkn")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtTkn"))]
    pub pmt_tkn: Max19NumericText,

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

    #[yaserde(rename = "TknRqstrId")]
    #[cfg_attr(feature = "serde", serde(rename = "TknRqstrId"))]
    pub tkn_rqstr_id: Max11NumericText,

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

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

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

impl Validate for Token1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct Traceability7 {
    #[yaserde(rename = "RlayId")]
    #[cfg_attr(feature = "serde", serde(rename = "RlayId"))]
    pub rlay_id: GenericIdentification172,

    #[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 Traceability7 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct Track2Data1Choice {
    #[yaserde(rename = "TxtVal")]
    #[cfg_attr(feature = "serde", serde(rename = "TxtVal"))]
    pub txt_val: Option<Max37Text>,
    #[yaserde(rename = "HexBinryVal")]
    #[cfg_attr(feature = "serde", serde(rename = "HexBinryVal"))]
    pub hex_binry_val: Option<Max19HexBinaryText>,
}

impl Validate for Track2Data1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct Transaction76 {
    #[yaserde(rename = "TxTp")]
    #[cfg_attr(feature = "serde", serde(rename = "TxTp"))]
    pub tx_tp: Exact2AlphaNumericText,

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

    #[yaserde(rename = "MsgRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgRsn"))]
    pub msg_rsn: Vec<Exact4NumericText>,

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

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

    #[yaserde(rename = "NewPINData")]
    #[cfg_attr(feature = "serde", serde(rename = "NewPINData"))]
    pub new_pin_data: Pindata1,

    #[yaserde(rename = "TxCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "TxCcy"))]
    pub tx_ccy: Iso3NumericCurrencyCode,

    #[yaserde(rename = "DtldAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "DtldAmt"))]
    pub dtld_amt: Vec<DetailedAmount20>,

    #[yaserde(rename = "RcncltnAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "RcncltnAmt"))]
    pub rcncltn_amt: Amount4,

    #[yaserde(rename = "AddtlAmts")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlAmts"))]
    pub addtl_amts: Vec<AdditionalAmounts2>,

    #[yaserde(rename = "AddtlFees")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlFees"))]
    pub addtl_fees: Vec<AdditionalFee1>,

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

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

    #[yaserde(rename = "AddtlData")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlData"))]
    pub addtl_data: Vec<AdditionalData1>,
}

impl Validate for Transaction76 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct TransactionContext1 {
    #[yaserde(rename = "MrchntCtgyCd")]
    #[cfg_attr(feature = "serde", serde(rename = "MrchntCtgyCd"))]
    pub mrchnt_ctgy_cd: Exact4NumericText,

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

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

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

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

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

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

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

    #[yaserde(rename = "TxInitr")]
    #[cfg_attr(feature = "serde", serde(rename = "TxInitr"))]
    pub tx_initr: TransactionInitiator1Code,

    #[yaserde(rename = "CardPrgrmm")]
    #[cfg_attr(feature = "serde", serde(rename = "CardPrgrmm"))]
    pub card_prgrmm: CardProgramme1,

    #[yaserde(rename = "SttlmSvc")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmSvc"))]
    pub sttlm_svc: SettlementService1,

    #[yaserde(rename = "Rcncltn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rcncltn"))]
    pub rcncltn: Reconciliation3,

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

impl Validate for TransactionContext1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct TransactionIdentification8 {
    #[yaserde(rename = "LclDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "LclDtTm"))]
    pub lcl_dt_tm: IsodateTime,

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

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

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

    #[yaserde(rename = "SysTracAudtNb")]
    #[cfg_attr(feature = "serde", serde(rename = "SysTracAudtNb"))]
    pub sys_trac_audt_nb: Max12NumericText,

    #[yaserde(rename = "RtrvlRefNb")]
    #[cfg_attr(feature = "serde", serde(rename = "RtrvlRefNb"))]
    pub rtrvl_ref_nb: Exact12Text,

    #[yaserde(rename = "LifeCyclSpprt")]
    #[cfg_attr(feature = "serde", serde(rename = "LifeCyclSpprt"))]
    pub life_cycl_spprt: LifeCycleSupport1Code,

    #[yaserde(rename = "LifeCyclTracIdData")]
    #[cfg_attr(feature = "serde", serde(rename = "LifeCyclTracIdData"))]
    pub life_cycl_trac_id_data: TransactionLifeCycleIdentification1,

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

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

    #[yaserde(rename = "AcqrrRefNb")]
    #[cfg_attr(feature = "serde", serde(rename = "AcqrrRefNb"))]
    pub acqrr_ref_nb: Max23NumericText,

    #[yaserde(rename = "CardIssrRefData")]
    #[cfg_attr(feature = "serde", serde(rename = "CardIssrRefData"))]
    pub card_issr_ref_data: Max1000Text,

    #[yaserde(rename = "OrgnlDataElmts")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlDataElmts"))]
    pub orgnl_data_elmts: OriginalDataElements1,
}

impl Validate for TransactionIdentification8 {}


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

pub enum TransactionInitiator1Code {
    #[yaserde(rename = "MERC")]
    #[cfg_attr(feature = "serde", serde(rename = "MERC"))]
    Merc,
    #[yaserde(rename = "CUST")]
    #[cfg_attr(feature = "serde", serde(rename = "CUST"))]
    Cust,
    __Unknown__(String),
}

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

impl Validate for TransactionInitiator1Code {}



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

    #[yaserde(rename = "AuthstnSeqNb")]
    #[cfg_attr(feature = "serde", serde(rename = "AuthstnSeqNb"))]
    pub authstn_seq_nb: Exact2NumericText,

    #[yaserde(rename = "PresntmntSeqNb")]
    #[cfg_attr(feature = "serde", serde(rename = "PresntmntSeqNb"))]
    pub presntmnt_seq_nb: Exact2NumericText,

    #[yaserde(rename = "PresntmntSeqCnt")]
    #[cfg_attr(feature = "serde", serde(rename = "PresntmntSeqCnt"))]
    pub presntmnt_seq_cnt: Exact2NumericText,

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

impl Validate for TransactionLifeCycleIdentification1 {}


#[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:cain.023.001.01")]

pub enum TypeOfAmount10Code {
    #[yaserde(rename = "INTC")]
    #[cfg_attr(feature = "serde", serde(rename = "INTC"))]
    Intc,
    #[yaserde(rename = "FEEP")]
    #[cfg_attr(feature = "serde", serde(rename = "FEEP"))]
    Feep,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "FEEA")]
    #[cfg_attr(feature = "serde", serde(rename = "FEEA"))]
    Feea,
    __Unknown__(String),
}

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

impl Validate for TypeOfAmount10Code {}



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

pub enum TypeOfAmount17Code {
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "ISCF")]
    #[cfg_attr(feature = "serde", serde(rename = "ISCF"))]
    Iscf,
    #[yaserde(rename = "ANTA")]
    #[cfg_attr(feature = "serde", serde(rename = "ANTA"))]
    Anta,
    __Unknown__(String),
}

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

impl Validate for TypeOfAmount17Code {}



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

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

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

impl Validate for UserInterface1Code {}



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

pub enum UserInterface6Code {
    #[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 = "FILE")]
    #[cfg_attr(feature = "serde", serde(rename = "FILE"))]
    File,
    #[yaserde(rename = "CHAP")]
    #[cfg_attr(feature = "serde", serde(rename = "CHAP"))]
    Chap,
    #[yaserde(rename = "MRAP")]
    #[cfg_attr(feature = "serde", serde(rename = "MRAP"))]
    Mrap,
    #[yaserde(rename = "MRIN")]
    #[cfg_attr(feature = "serde", serde(rename = "MRIN"))]
    Mrin,
    __Unknown__(String),
}

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

impl Validate for UserInterface6Code {}



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

    #[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 = "VrfctnInf")]
    #[cfg_attr(feature = "serde", serde(rename = "VrfctnInf"))]
    pub vrfctn_inf: Vec<VerificationInformation1>,

    #[yaserde(rename = "VrfctnRslt")]
    #[cfg_attr(feature = "serde", serde(rename = "VrfctnRslt"))]
    pub vrfctn_rslt: Vec<VerificationResult1>,
}

impl Validate for Verification1 {}


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

pub enum Verification2Code {
    #[yaserde(rename = "FAIL")]
    #[cfg_attr(feature = "serde", serde(rename = "FAIL"))]
    Fail,
    #[yaserde(rename = "FUTA")]
    #[cfg_attr(feature = "serde", serde(rename = "FUTA"))]
    Futa,
    #[yaserde(rename = "MISS")]
    #[cfg_attr(feature = "serde", serde(rename = "MISS"))]
    Miss,
    #[yaserde(rename = "NOVF")]
    #[cfg_attr(feature = "serde", serde(rename = "NOVF"))]
    Novf,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[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 Verification2Code {
    fn default() -> Verification2Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for Verification2Code {}



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

pub enum VerificationEntity1Code {
    #[yaserde(rename = "MERC")]
    #[cfg_attr(feature = "serde", serde(rename = "MERC"))]
    Merc,
    #[yaserde(rename = "ACQR")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
    Acqr,
    #[yaserde(rename = "AGNT")]
    #[cfg_attr(feature = "serde", serde(rename = "AGNT"))]
    Agnt,
    #[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 VerificationEntity1Code {
    fn default() -> VerificationEntity1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for VerificationEntity1Code {}



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

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

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

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

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

    #[yaserde(rename = "VldtyEndTm")]
    #[cfg_attr(feature = "serde", serde(rename = "VldtyEndTm"))]
    pub vldty_end_tm: Isotime,
}

impl Validate for VerificationInformation1 {}


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

    #[yaserde(rename = "Ntty")]
    #[cfg_attr(feature = "serde", serde(rename = "Ntty"))]
    pub ntty: VerificationEntity1Code,

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

    #[yaserde(rename = "Rslt")]
    #[cfg_attr(feature = "serde", serde(rename = "Rslt"))]
    pub rslt: Verification2Code,

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

    #[yaserde(rename = "RsltDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "RsltDtls"))]
    pub rslt_dtls: Vec<AdditionalData1>,
}

impl Validate for VerificationResult1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct VerificationValue1Choice {
    #[yaserde(rename = "TxtVal")]
    #[cfg_attr(feature = "serde", serde(rename = "TxtVal"))]
    pub txt_val: Option<Max2048Text>,
    #[yaserde(rename = "BinryVal")]
    #[cfg_attr(feature = "serde", serde(rename = "BinryVal"))]
    pub binry_val: Option<Max5000Binary>,
    #[yaserde(rename = "HexBinryVal")]
    #[cfg_attr(feature = "serde", serde(rename = "HexBinryVal"))]
    pub hex_binry_val: Option<Max9999HexBinaryText>,
    #[yaserde(rename = "PINData")]
    #[cfg_attr(feature = "serde", serde(rename = "PINData"))]
    pub pindata: Option<Pindata1>,
}

impl Validate for VerificationValue1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.023.001.01")]
pub struct Wallet1 {
    #[yaserde(rename = "Prvdr")]
    #[cfg_attr(feature = "serde", serde(rename = "Prvdr"))]
    pub prvdr: PartyIdentification197,

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

impl Validate for Wallet1 {}


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

impl Validate for YesNoIndicator {}

impl crate::MxMessage for Document {
    const BUSINESS_AREA: crate::BusinessArea = crate::BusinessArea::cain;
    const FUNCTIONALITY: &'static str = "023";
    const VARIANT: &'static str = "001";
    const VERSION: &'static str = "01";
    const MESSAGE_NAME: &'static str = "cain.023.001.01";
    const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:cain.023.001.01";
}