rust_iso20022 0.1.0

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

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

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

impl Validate for Algorithm26Code {}



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

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

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

impl Validate for Algorithm27Code {}



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

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

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

impl Validate for Algorithm28Code {}



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

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

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

impl Validate for Algorithm29Code {}



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

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:catm.006.001.08")]

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

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

impl Validate for AlgorithmIdentification31 {}


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

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

impl Validate for AlgorithmIdentification32 {}


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

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

impl Validate for AlgorithmIdentification33 {}


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

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

impl Validate for AlgorithmIdentification34 {}


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

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

impl Validate for AlgorithmIdentification35 {}


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

impl Validate for AlgorithmIdentification36 {}


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

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

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

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

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

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

impl Validate for AuthenticatedData10 {}


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

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

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

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

impl Validate for ContentInformationType38 {}


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

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

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

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

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

impl Validate for ContentInformationType39 {}


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

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:catm.006.001.08")]

pub enum DataSetCategory19Code {
    #[yaserde(rename = "ACQP")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQP"))]
    Acqp,
    #[yaserde(rename = "APPR")]
    #[cfg_attr(feature = "serde", serde(rename = "APPR"))]
    Appr,
    #[yaserde(rename = "APSB")]
    #[cfg_attr(feature = "serde", serde(rename = "APSB"))]
    Apsb,
    #[yaserde(rename = "KDWL")]
    #[cfg_attr(feature = "serde", serde(rename = "KDWL"))]
    Kdwl,
    #[yaserde(rename = "KMGT")]
    #[cfg_attr(feature = "serde", serde(rename = "KMGT"))]
    Kmgt,
    #[yaserde(rename = "RPRT")]
    #[cfg_attr(feature = "serde", serde(rename = "RPRT"))]
    Rprt,
    #[yaserde(rename = "SWPK")]
    #[cfg_attr(feature = "serde", serde(rename = "SWPK"))]
    Swpk,
    #[yaserde(rename = "TMSP")]
    #[cfg_attr(feature = "serde", serde(rename = "TMSP"))]
    Tmsp,
    #[yaserde(rename = "MRPR")]
    #[cfg_attr(feature = "serde", serde(rename = "MRPR"))]
    Mrpr,
    #[yaserde(rename = "TRPR")]
    #[cfg_attr(feature = "serde", serde(rename = "TRPR"))]
    Trpr,
    #[yaserde(rename = "CRTF")]
    #[cfg_attr(feature = "serde", serde(rename = "CRTF"))]
    Crtf,
    #[yaserde(rename = "SACP")]
    #[cfg_attr(feature = "serde", serde(rename = "SACP"))]
    Sacp,
    #[yaserde(rename = "SAPR")]
    #[cfg_attr(feature = "serde", serde(rename = "SAPR"))]
    Sapr,
    #[yaserde(rename = "LOGF")]
    #[cfg_attr(feature = "serde", serde(rename = "LOGF"))]
    Logf,
    #[yaserde(rename = "RPFL")]
    #[cfg_attr(feature = "serde", serde(rename = "RPFL"))]
    Rpfl,
    #[yaserde(rename = "CONF")]
    #[cfg_attr(feature = "serde", serde(rename = "CONF"))]
    Conf,
    #[yaserde(rename = "SPRP")]
    #[cfg_attr(feature = "serde", serde(rename = "SPRP"))]
    Sprp,
    #[yaserde(rename = "TPKG")]
    #[cfg_attr(feature = "serde", serde(rename = "TPKG"))]
    Tpkg,
    __Unknown__(String),
}

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

impl Validate for DataSetCategory19Code {}



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

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

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

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

impl Validate for DigestedData6 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.006.001.08")]
pub struct Document {
    #[yaserde(rename = "MntncDlgtnRspn")]
    #[cfg_attr(feature = "serde", serde(rename = "MntncDlgtnRspn"))]
    pub mntnc_dlgtn_rspn: MaintenanceDelegationResponseV08,
}

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

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

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

impl Validate for EncryptedContent7 {}


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

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

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

impl Validate for EncryptionFormat2Code {}



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

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

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

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

impl Validate for EnvelopedData11 {}


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

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

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

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

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

impl Validate for GenericIdentification176 {}


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

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

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

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

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

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

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

impl Validate for GenericIdentification177 {}


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

    #[yaserde(rename = "UTMCordints")]
    #[cfg_attr(feature = "serde", serde(rename = "UTMCordints"))]
    pub utm_cordints: GeolocationUTMCoordinates1,
}

impl Validate for Geolocation1 {}


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

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

impl Validate for GeolocationGeographicCoordinates1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.006.001.08")]
pub struct GeolocationUTMCoordinates1 {
    #[yaserde(rename = "UTMZone")]
    #[cfg_attr(feature = "serde", serde(rename = "UTMZone"))]
    pub utm_zone: Max35Text,

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

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

impl Validate for GeolocationUTMCoordinates1 {}


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

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

impl Validate for IssuerAndSerialNumber2 {}


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

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

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

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

impl Validate for Kek9 {}


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

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

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

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

impl Validate for Kekidentifier7 {}


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

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

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

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

impl Validate for KeyTransport10 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.006.001.08")]
pub struct MaintenanceDelegation17 {
    #[yaserde(rename = "MntncSvc")]
    #[cfg_attr(feature = "serde", serde(rename = "MntncSvc"))]
    pub mntnc_svc: Vec<DataSetCategory19Code>,

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

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

    #[yaserde(rename = "DlgtnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "DlgtnTp"))]
    pub dlgtn_tp: TerminalManagementAction3Code,

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

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

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

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

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

    #[yaserde(rename = "POIIdAssoctn")]
    #[cfg_attr(feature = "serde", serde(rename = "POIIdAssoctn"))]
    pub poi_id_assoctn: Vec<MaintenanceIdentificationAssociation1>,
}

impl Validate for MaintenanceDelegation17 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.006.001.08")]
pub struct MaintenanceDelegationResponse8 {
    #[yaserde(rename = "TMId")]
    #[cfg_attr(feature = "serde", serde(rename = "TMId"))]
    pub tm_id: GenericIdentification176,

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

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

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

    #[yaserde(rename = "DlgtnRspn")]
    #[cfg_attr(feature = "serde", serde(rename = "DlgtnRspn"))]
    pub dlgtn_rspn: Vec<MaintenanceDelegation17>,
}

impl Validate for MaintenanceDelegationResponse8 {}


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

    #[yaserde(rename = "MntncDlgtnRspn")]
    #[cfg_attr(feature = "serde", serde(rename = "MntncDlgtnRspn"))]
    pub mntnc_dlgtn_rspn: MaintenanceDelegationResponse8,

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

impl Validate for MaintenanceDelegationResponseV08 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.006.001.08")]
pub struct MaintenanceIdentificationAssociation1 {
    #[yaserde(rename = "MstrTMId")]
    #[cfg_attr(feature = "serde", serde(rename = "MstrTMId"))]
    pub mstr_tm_id: Max35Text,

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

impl Validate for MaintenanceIdentificationAssociation1 {}


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

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

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

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

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

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

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct 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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.006.001.08")]
pub struct NetworkParameters7 {
    #[yaserde(rename = "Adr")]
    #[cfg_attr(feature = "serde", serde(rename = "Adr"))]
    pub adr: Vec<NetworkParameters9>,

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

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

    #[yaserde(rename = "SvrCert")]
    #[cfg_attr(feature = "serde", serde(rename = "SvrCert"))]
    pub svr_cert: Vec<Max10KBinary>,

    #[yaserde(rename = "SvrCertIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "SvrCertIdr"))]
    pub svr_cert_idr: Vec<Max140Binary>,

    #[yaserde(rename = "ClntCert")]
    #[cfg_attr(feature = "serde", serde(rename = "ClntCert"))]
    pub clnt_cert: Vec<Max10KBinary>,

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

impl Validate for NetworkParameters7 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.006.001.08")]
pub struct NetworkParameters9 {
    #[yaserde(rename = "NtwkTp")]
    #[cfg_attr(feature = "serde", serde(rename = "NtwkTp"))]
    pub ntwk_tp: NetworkType1Code,

    #[yaserde(rename = "AdrVal")]
    #[cfg_attr(feature = "serde", serde(rename = "AdrVal"))]
    pub adr_val: Max500Text,
}

impl Validate for NetworkParameters9 {}


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

pub enum NetworkType1Code {
    #[yaserde(rename = "IPNW")]
    #[cfg_attr(feature = "serde", serde(rename = "IPNW"))]
    Ipnw,
    #[yaserde(rename = "PSTN")]
    #[cfg_attr(feature = "serde", serde(rename = "PSTN"))]
    Pstn,
    __Unknown__(String),
}

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

impl Validate for NetworkType1Code {}



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

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

impl Validate for OriginatorInformation1 {}


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

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

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

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

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

impl Validate for Parameter16 {}


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

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

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

impl Validate for Parameter17 {}


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

impl Validate for Parameter18 {}


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

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

impl Validate for Parameter7 {}


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

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

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

impl Validate for PartyType33Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.006.001.08")]
pub struct Recipient13Choice {
    #[yaserde(rename = "IssrAndSrlNb")]
    #[cfg_attr(feature = "serde", serde(rename = "IssrAndSrlNb"))]
    pub issr_and_srl_nb: Option<IssuerAndSerialNumber2>,
    #[yaserde(rename = "SbjtKeyIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "SbjtKeyIdr"))]
    pub sbjt_key_idr: Option<Max140Binary>,
}

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

impl Validate for Recipient15Choice {}




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

pub enum Response2Code {
    #[yaserde(rename = "APPR")]
    #[cfg_attr(feature = "serde", serde(rename = "APPR"))]
    Appr,
    #[yaserde(rename = "DECL")]
    #[cfg_attr(feature = "serde", serde(rename = "DECL"))]
    Decl,
    __Unknown__(String),
}

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

impl Validate for Response2Code {}



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

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

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

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

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

impl Validate for SignedData9 {}


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

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

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

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

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

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

impl Validate for Signer8 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.006.001.08")]
pub struct Tmsheader1 {
    #[yaserde(rename = "DwnldTrf")]
    #[cfg_attr(feature = "serde", serde(rename = "DwnldTrf"))]
    pub dwnld_trf: TrueFalseIndicator,

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

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

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

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

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

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

impl Validate for Tmsheader1 {}


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

pub enum TerminalManagementAction3Code {
    #[yaserde(rename = "CREA")]
    #[cfg_attr(feature = "serde", serde(rename = "CREA"))]
    Crea,
    #[yaserde(rename = "DELT")]
    #[cfg_attr(feature = "serde", serde(rename = "DELT"))]
    Delt,
    #[yaserde(rename = "UPDT")]
    #[cfg_attr(feature = "serde", serde(rename = "UPDT"))]
    Updt,
    __Unknown__(String),
}

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

impl Validate for TerminalManagementAction3Code {}



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

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

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

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

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

impl Validate for Traceability8 {}


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

impl Validate for TrueFalseIndicator {}

impl crate::MxMessage for Document {
    const BUSINESS_AREA: crate::BusinessArea = crate::BusinessArea::catm;
    const FUNCTIONALITY: &'static str = "006";
    const VARIANT: &'static str = "001";
    const VERSION: &'static str = "08";
    const MESSAGE_NAME: &'static str = "catm.006.001.08";
    const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:catm.006.001.08";
}