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:catm.003.001.10")]
pub struct AcceptorConfiguration10 {
    #[yaserde(rename = "TermnlMgrId")]
    #[cfg_attr(feature = "serde", serde(rename = "TermnlMgrId"))]
    pub termnl_mgr_id: GenericIdentification176,

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

    #[yaserde(rename = "DataSet")]
    #[cfg_attr(feature = "serde", serde(rename = "DataSet"))]
    pub data_set: Vec<AcceptorConfigurationDataSet2>,
}

impl Validate for AcceptorConfiguration10 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.003.001.10")]
pub struct AcceptorConfigurationContent10 {
    #[yaserde(rename = "RplcCfgtn")]
    #[cfg_attr(feature = "serde", serde(rename = "RplcCfgtn"))]
    pub rplc_cfgtn: TrueFalseIndicator,

    #[yaserde(rename = "TMSPrtcolParams")]
    #[cfg_attr(feature = "serde", serde(rename = "TMSPrtcolParams"))]
    pub tms_prtcol_params: Vec<TmsprotocolParameters5>,

    #[yaserde(rename = "AcqrrPrtcolParams")]
    #[cfg_attr(feature = "serde", serde(rename = "AcqrrPrtcolParams"))]
    pub acqrr_prtcol_params: Vec<AcquirerProtocolParameters14>,

    #[yaserde(rename = "SvcPrvdrParams")]
    #[cfg_attr(feature = "serde", serde(rename = "SvcPrvdrParams"))]
    pub svc_prvdr_params: Vec<ServiceProviderParameters1>,

    #[yaserde(rename = "MrchntParams")]
    #[cfg_attr(feature = "serde", serde(rename = "MrchntParams"))]
    pub mrchnt_params: Vec<MerchantConfigurationParameters6>,

    #[yaserde(rename = "TermnlParams")]
    #[cfg_attr(feature = "serde", serde(rename = "TermnlParams"))]
    pub termnl_params: Vec<PaymentTerminalParameters8>,

    #[yaserde(rename = "ApplParams")]
    #[cfg_attr(feature = "serde", serde(rename = "ApplParams"))]
    pub appl_params: Vec<ApplicationParameters10>,

    #[yaserde(rename = "HstComParams")]
    #[cfg_attr(feature = "serde", serde(rename = "HstComParams"))]
    pub hst_com_params: Vec<HostCommunicationParameter6>,

    #[yaserde(rename = "SctyParams")]
    #[cfg_attr(feature = "serde", serde(rename = "SctyParams"))]
    pub scty_params: Vec<SecurityParameters13>,

    #[yaserde(rename = "SaleToPOIParams")]
    #[cfg_attr(feature = "serde", serde(rename = "SaleToPOIParams"))]
    pub sale_to_poi_params: Vec<SaleToPOIProtocolParameter1>,

    #[yaserde(rename = "TermnlPackg")]
    #[cfg_attr(feature = "serde", serde(rename = "TermnlPackg"))]
    pub termnl_packg: Vec<TerminalPackageType2>,
}

impl Validate for AcceptorConfigurationContent10 {}


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

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

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

    #[yaserde(rename = "POIId")]
    #[cfg_attr(feature = "serde", serde(rename = "POIId"))]
    pub poi_id: Vec<GenericIdentification176>,

    #[yaserde(rename = "CfgtnScp")]
    #[cfg_attr(feature = "serde", serde(rename = "CfgtnScp"))]
    pub cfgtn_scp: PartyType15Code,

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

impl Validate for AcceptorConfigurationDataSet2 {}


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

    #[yaserde(rename = "AccptrCfgtn")]
    #[cfg_attr(feature = "serde", serde(rename = "AccptrCfgtn"))]
    pub accptr_cfgtn: AcceptorConfiguration10,

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

impl Validate for AcceptorConfigurationUpdateV10 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.003.001.10")]
pub struct AcquirerHostConfiguration8 {
    #[yaserde(rename = "HstId")]
    #[cfg_attr(feature = "serde", serde(rename = "HstId"))]
    pub hst_id: Max35Text,

    #[yaserde(rename = "MsgToSnd")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgToSnd"))]
    pub msg_to_snd: Vec<MessageFunction43Code>,

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

impl Validate for AcquirerHostConfiguration8 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.003.001.10")]
pub struct AcquirerProtocolExchangeBehavior2 {
    #[yaserde(rename = "FinCaptr")]
    #[cfg_attr(feature = "serde", serde(rename = "FinCaptr"))]
    pub fin_captr: FinancialCapture1Code,

    #[yaserde(rename = "BtchTrf")]
    #[cfg_attr(feature = "serde", serde(rename = "BtchTrf"))]
    pub btch_trf: ExchangeConfiguration9,

    #[yaserde(rename = "CmpltnXchg")]
    #[cfg_attr(feature = "serde", serde(rename = "CmpltnXchg"))]
    pub cmpltn_xchg: ExchangeConfiguration10,

    #[yaserde(rename = "CxlXchg")]
    #[cfg_attr(feature = "serde", serde(rename = "CxlXchg"))]
    pub cxl_xchg: CancellationProcess2Code,
}

impl Validate for AcquirerProtocolExchangeBehavior2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.003.001.10")]
pub struct AcquirerProtocolParameters14 {
    #[yaserde(rename = "ActnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ActnTp"))]
    pub actn_tp: TerminalManagementAction3Code,

    #[yaserde(rename = "AcqrrId")]
    #[cfg_attr(feature = "serde", serde(rename = "AcqrrId"))]
    pub acqrr_id: Vec<GenericIdentification176>,

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

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

    #[yaserde(rename = "Hst")]
    #[cfg_attr(feature = "serde", serde(rename = "Hst"))]
    pub hst: Vec<AcquirerHostConfiguration8>,

    #[yaserde(rename = "OnLineTx")]
    #[cfg_attr(feature = "serde", serde(rename = "OnLineTx"))]
    pub on_line_tx: AcquirerProtocolExchangeBehavior2,

    #[yaserde(rename = "OffLineTx")]
    #[cfg_attr(feature = "serde", serde(rename = "OffLineTx"))]
    pub off_line_tx: AcquirerProtocolExchangeBehavior2,

    #[yaserde(rename = "RcncltnXchg")]
    #[cfg_attr(feature = "serde", serde(rename = "RcncltnXchg"))]
    pub rcncltn_xchg: ExchangeConfiguration9,

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

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

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

    #[yaserde(rename = "SpltTtlCrit")]
    #[cfg_attr(feature = "serde", serde(rename = "SpltTtlCrit"))]
    pub splt_ttl_crit: Vec<ReconciliationCriteria1Code>,

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

    #[yaserde(rename = "AmtQlfrForRsvatn")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtQlfrForRsvatn"))]
    pub amt_qlfr_for_rsvatn: Vec<TypeOfAmount8Code>,

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

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

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

    #[yaserde(rename = "BtchTrfCntt")]
    #[cfg_attr(feature = "serde", serde(rename = "BtchTrfCntt"))]
    pub btch_trf_cntt: Vec<BatchTransactionType1Code>,

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

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

    #[yaserde(rename = "MsgItm")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgItm"))]
    pub msg_itm: Vec<MessageItemCondition1>,

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

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

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

impl Validate for AcquirerProtocolParameters14 {}


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

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

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

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

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

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

impl Validate for Algorithm24Code {}



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

pub enum Algorithm25Code {
    #[yaserde(rename = "ERS2")]
    #[cfg_attr(feature = "serde", serde(rename = "ERS2"))]
    Ers2,
    #[yaserde(rename = "ERS1")]
    #[cfg_attr(feature = "serde", serde(rename = "ERS1"))]
    Ers1,
    #[yaserde(rename = "RPSS")]
    #[cfg_attr(feature = "serde", serde(rename = "RPSS"))]
    Rpss,
    #[yaserde(rename = "ERS3")]
    #[cfg_attr(feature = "serde", serde(rename = "ERS3"))]
    Ers3,
    #[yaserde(rename = "ED32")]
    #[cfg_attr(feature = "serde", serde(rename = "ED32"))]
    Ed32,
    #[yaserde(rename = "ED33")]
    #[cfg_attr(feature = "serde", serde(rename = "ED33"))]
    Ed33,
    #[yaserde(rename = "ED35")]
    #[cfg_attr(feature = "serde", serde(rename = "ED35"))]
    Ed35,
    #[yaserde(rename = "ED23")]
    #[cfg_attr(feature = "serde", serde(rename = "ED23"))]
    Ed23,
    #[yaserde(rename = "ED25")]
    #[cfg_attr(feature = "serde", serde(rename = "ED25"))]
    Ed25,
    #[yaserde(rename = "ES22")]
    #[cfg_attr(feature = "serde", serde(rename = "ES22"))]
    Es22,
    #[yaserde(rename = "ES32")]
    #[cfg_attr(feature = "serde", serde(rename = "ES32"))]
    Es32,
    #[yaserde(rename = "ES33")]
    #[cfg_attr(feature = "serde", serde(rename = "ES33"))]
    Es33,
    #[yaserde(rename = "ES35")]
    #[cfg_attr(feature = "serde", serde(rename = "ES35"))]
    Es35,
    #[yaserde(rename = "ES23")]
    #[cfg_attr(feature = "serde", serde(rename = "ES23"))]
    Es23,
    #[yaserde(rename = "ES25")]
    #[cfg_attr(feature = "serde", serde(rename = "ES25"))]
    Es25,
    #[yaserde(rename = "ED22")]
    #[cfg_attr(feature = "serde", serde(rename = "ED22"))]
    Ed22,
    __Unknown__(String),
}

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

impl Validate for Algorithm25Code {}



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

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

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

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

impl Validate for AlgorithmIdentification29 {}


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

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

impl Validate for AlgorithmIdentification30 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.003.001.10")]
pub struct ApplicationParameters10 {
    #[yaserde(rename = "ActnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ActnTp"))]
    pub actn_tp: TerminalManagementAction3Code,

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

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

    #[yaserde(rename = "ParamFrmtIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "ParamFrmtIdr"))]
    pub param_frmt_idr: Max8Text,

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

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

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

    #[yaserde(rename = "Params")]
    #[cfg_attr(feature = "serde", serde(rename = "Params"))]
    pub params: Vec<Max100KBinary>,

    #[yaserde(rename = "NcrptdParams")]
    #[cfg_attr(feature = "serde", serde(rename = "NcrptdParams"))]
    pub ncrptd_params: ContentInformationType28,
}

impl Validate for ApplicationParameters10 {}


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

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

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

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

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

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

impl Validate for AuthenticatedData7 {}


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

pub enum BatchTransactionType1Code {
    #[yaserde(rename = "DTCT")]
    #[cfg_attr(feature = "serde", serde(rename = "DTCT"))]
    Dtct,
    #[yaserde(rename = "CNCL")]
    #[cfg_attr(feature = "serde", serde(rename = "CNCL"))]
    Cncl,
    #[yaserde(rename = "FAIL")]
    #[cfg_attr(feature = "serde", serde(rename = "FAIL"))]
    Fail,
    #[yaserde(rename = "DCLN")]
    #[cfg_attr(feature = "serde", serde(rename = "DCLN"))]
    Dcln,
    __Unknown__(String),
}

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

impl Validate for BatchTransactionType1Code {}



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

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

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

impl Validate for BytePadding1Code {}



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

pub enum CancellationProcess2Code {
    #[yaserde(rename = "ADVC")]
    #[cfg_attr(feature = "serde", serde(rename = "ADVC"))]
    Advc,
    #[yaserde(rename = "NALW")]
    #[cfg_attr(feature = "serde", serde(rename = "NALW"))]
    Nalw,
    #[yaserde(rename = "REQU")]
    #[cfg_attr(feature = "serde", serde(rename = "REQU"))]
    Requ,
    #[yaserde(rename = "APPL")]
    #[cfg_attr(feature = "serde", serde(rename = "APPL"))]
    Appl,
    __Unknown__(String),
}

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

impl Validate for CancellationProcess2Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.003.001.10")]
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.003.001.10")]
pub struct ClockSynchronisation3 {
    #[yaserde(rename = "POITmZone")]
    #[cfg_attr(feature = "serde", serde(rename = "POITmZone"))]
    pub poi_tm_zone: Max70Text,

    #[yaserde(rename = "SynctnSvr")]
    #[cfg_attr(feature = "serde", serde(rename = "SynctnSvr"))]
    pub synctn_svr: Vec<NetworkParameters7>,

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

impl Validate for ClockSynchronisation3 {}


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

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

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

impl Validate for ContentInformationType25 {}


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

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

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

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

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

impl Validate for ContentInformationType26 {}


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

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

impl Validate for ContentInformationType28 {}


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

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

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

impl Validate for ContentType2Code {}



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

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

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

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

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

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

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

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

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

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

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

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

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

impl Validate for CryptographicKey15 {}


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

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

pub enum DataSetCategory10Code {
    #[yaserde(rename = "AQPR")]
    #[cfg_attr(feature = "serde", serde(rename = "AQPR"))]
    Aqpr,
    #[yaserde(rename = "APPR")]
    #[cfg_attr(feature = "serde", serde(rename = "APPR"))]
    Appr,
    #[yaserde(rename = "MTMG")]
    #[cfg_attr(feature = "serde", serde(rename = "MTMG"))]
    Mtmg,
    #[yaserde(rename = "MRPR")]
    #[cfg_attr(feature = "serde", serde(rename = "MRPR"))]
    Mrpr,
    #[yaserde(rename = "MTOR")]
    #[cfg_attr(feature = "serde", serde(rename = "MTOR"))]
    Mtor,
    #[yaserde(rename = "SCPR")]
    #[cfg_attr(feature = "serde", serde(rename = "SCPR"))]
    Scpr,
    #[yaserde(rename = "SWPK")]
    #[cfg_attr(feature = "serde", serde(rename = "SWPK"))]
    Swpk,
    #[yaserde(rename = "TRPR")]
    #[cfg_attr(feature = "serde", serde(rename = "TRPR"))]
    Trpr,
    #[yaserde(rename = "CRTF")]
    #[cfg_attr(feature = "serde", serde(rename = "CRTF"))]
    Crtf,
    #[yaserde(rename = "TMSP")]
    #[cfg_attr(feature = "serde", serde(rename = "TMSP"))]
    Tmsp,
    __Unknown__(String),
}

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

impl Validate for DataSetCategory10Code {}



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

pub enum DataSetCategory14Code {
    #[yaserde(rename = "AQPR")]
    #[cfg_attr(feature = "serde", serde(rename = "AQPR"))]
    Aqpr,
    #[yaserde(rename = "APPR")]
    #[cfg_attr(feature = "serde", serde(rename = "APPR"))]
    Appr,
    #[yaserde(rename = "TXCP")]
    #[cfg_attr(feature = "serde", serde(rename = "TXCP"))]
    Txcp,
    #[yaserde(rename = "AKCP")]
    #[cfg_attr(feature = "serde", serde(rename = "AKCP"))]
    Akcp,
    #[yaserde(rename = "DLGT")]
    #[cfg_attr(feature = "serde", serde(rename = "DLGT"))]
    Dlgt,
    #[yaserde(rename = "MGTP")]
    #[cfg_attr(feature = "serde", serde(rename = "MGTP"))]
    Mgtp,
    #[yaserde(rename = "MRPR")]
    #[cfg_attr(feature = "serde", serde(rename = "MRPR"))]
    Mrpr,
    #[yaserde(rename = "SCPR")]
    #[cfg_attr(feature = "serde", serde(rename = "SCPR"))]
    Scpr,
    #[yaserde(rename = "SWPK")]
    #[cfg_attr(feature = "serde", serde(rename = "SWPK"))]
    Swpk,
    #[yaserde(rename = "STRP")]
    #[cfg_attr(feature = "serde", serde(rename = "STRP"))]
    Strp,
    #[yaserde(rename = "TRPR")]
    #[cfg_attr(feature = "serde", serde(rename = "TRPR"))]
    Trpr,
    #[yaserde(rename = "VDPR")]
    #[cfg_attr(feature = "serde", serde(rename = "VDPR"))]
    Vdpr,
    #[yaserde(rename = "PARA")]
    #[cfg_attr(feature = "serde", serde(rename = "PARA"))]
    Para,
    #[yaserde(rename = "TMSP")]
    #[cfg_attr(feature = "serde", serde(rename = "TMSP"))]
    Tmsp,
    #[yaserde(rename = "CRTF")]
    #[cfg_attr(feature = "serde", serde(rename = "CRTF"))]
    Crtf,
    #[yaserde(rename = "LOGF")]
    #[cfg_attr(feature = "serde", serde(rename = "LOGF"))]
    Logf,
    #[yaserde(rename = "CMRQ")]
    #[cfg_attr(feature = "serde", serde(rename = "CMRQ"))]
    Cmrq,
    #[yaserde(rename = "MDFL")]
    #[cfg_attr(feature = "serde", serde(rename = "MDFL"))]
    Mdfl,
    #[yaserde(rename = "SOFT")]
    #[cfg_attr(feature = "serde", serde(rename = "SOFT"))]
    Soft,
    #[yaserde(rename = "CONF")]
    #[cfg_attr(feature = "serde", serde(rename = "CONF"))]
    Conf,
    #[yaserde(rename = "RPFL")]
    #[cfg_attr(feature = "serde", serde(rename = "RPFL"))]
    Rpfl,
    __Unknown__(String),
}

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

impl Validate for DataSetCategory14Code {}



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

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

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

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

impl Validate for DataSetIdentification8 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.003.001.10")]
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:catm.003.001.10")]
pub struct Document {
    #[yaserde(rename = "AccptrCfgtnUpd")]
    #[cfg_attr(feature = "serde", serde(rename = "AccptrCfgtnUpd"))]
    pub accptr_cfgtn_upd: AcceptorConfigurationUpdateV10,
}

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

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

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

impl Validate for EncryptedContent6 {}


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

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

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

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

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

impl Validate for EnvelopedData8 {}


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

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

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

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

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

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

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

impl Validate for ExchangeConfiguration10 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.003.001.10")]
pub struct ExchangeConfiguration9 {
    #[yaserde(rename = "XchgPlcy")]
    #[cfg_attr(feature = "serde", serde(rename = "XchgPlcy"))]
    pub xchg_plcy: Vec<ExchangePolicy2Code>,

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

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

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

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

impl Validate for ExchangeConfiguration9 {}


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

pub enum ExchangePolicy2Code {
    #[yaserde(rename = "ONDM")]
    #[cfg_attr(feature = "serde", serde(rename = "ONDM"))]
    Ondm,
    #[yaserde(rename = "IMMD")]
    #[cfg_attr(feature = "serde", serde(rename = "IMMD"))]
    Immd,
    #[yaserde(rename = "ASAP")]
    #[cfg_attr(feature = "serde", serde(rename = "ASAP"))]
    Asap,
    #[yaserde(rename = "AGRP")]
    #[cfg_attr(feature = "serde", serde(rename = "AGRP"))]
    Agrp,
    #[yaserde(rename = "NBLT")]
    #[cfg_attr(feature = "serde", serde(rename = "NBLT"))]
    Nblt,
    #[yaserde(rename = "TTLT")]
    #[cfg_attr(feature = "serde", serde(rename = "TTLT"))]
    Ttlt,
    #[yaserde(rename = "CYCL")]
    #[cfg_attr(feature = "serde", serde(rename = "CYCL"))]
    Cycl,
    #[yaserde(rename = "NONE")]
    #[cfg_attr(feature = "serde", serde(rename = "NONE"))]
    None,
    #[yaserde(rename = "BLCK")]
    #[cfg_attr(feature = "serde", serde(rename = "BLCK"))]
    Blck,
    __Unknown__(String),
}

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

impl Validate for ExchangePolicy2Code {}



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

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

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

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

impl Validate for ExternallyDefinedData2 {}


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

pub enum FinancialCapture1Code {
    #[yaserde(rename = "AUTH")]
    #[cfg_attr(feature = "serde", serde(rename = "AUTH"))]
    Auth,
    #[yaserde(rename = "COMP")]
    #[cfg_attr(feature = "serde", serde(rename = "COMP"))]
    Comp,
    #[yaserde(rename = "BTCH")]
    #[cfg_attr(feature = "serde", serde(rename = "BTCH"))]
    Btch,
    __Unknown__(String),
}

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

impl Validate for FinancialCapture1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.003.001.10")]
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.003.001.10")]
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.003.001.10")]
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.003.001.10")]
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.003.001.10")]
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.003.001.10")]
pub struct GeolocationUTMCoordinates1 {
    #[yaserde(rename = "UTMZone")]
    #[cfg_attr(feature = "serde", serde(rename = "UTMZone"))]
    pub utm_zone: Max35Text,

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

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

impl Validate for GeolocationUTMCoordinates1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.003.001.10")]
pub struct HostCommunicationParameter6 {
    #[yaserde(rename = "ActnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ActnTp"))]
    pub actn_tp: TerminalManagementAction3Code,

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

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

    #[yaserde(rename = "Key")]
    #[cfg_attr(feature = "serde", serde(rename = "Key"))]
    pub key: Vec<Kekidentifier5>,

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

    #[yaserde(rename = "PhysIntrfc")]
    #[cfg_attr(feature = "serde", serde(rename = "PhysIntrfc"))]
    pub phys_intrfc: PhysicalInterfaceParameter1,
}

impl Validate for HostCommunicationParameter6 {}


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

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

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

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

impl Validate for Kek7 {}


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

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

impl Validate for Kekidentifier5 {}


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

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

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

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

impl Validate for KeyTransport7 {}


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

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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.003.001.10")]
pub struct LocalDateTime1 {
    #[yaserde(rename = "FrDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "FrDtTm"))]
    pub fr_dt_tm: IsodateTime,

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

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

impl Validate for LocalDateTime1 {}


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

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

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

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

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

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

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

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

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

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

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

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

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

impl Validate for Max9NumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.003.001.10")]
pub struct MerchantConfigurationParameters6 {
    #[yaserde(rename = "ActnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ActnTp"))]
    pub actn_tp: TerminalManagementAction3Code,

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

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

    #[yaserde(rename = "ParamFrmtIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "ParamFrmtIdr"))]
    pub param_frmt_idr: Max8Text,

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

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

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

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

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

impl Validate for MerchantConfigurationParameters6 {}


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

pub enum MessageFunction43Code {
    #[yaserde(rename = "FAUQ")]
    #[cfg_attr(feature = "serde", serde(rename = "FAUQ"))]
    Fauq,
    #[yaserde(rename = "CCAQ")]
    #[cfg_attr(feature = "serde", serde(rename = "CCAQ"))]
    Ccaq,
    #[yaserde(rename = "CMPV")]
    #[cfg_attr(feature = "serde", serde(rename = "CMPV"))]
    Cmpv,
    #[yaserde(rename = "DGNP")]
    #[cfg_attr(feature = "serde", serde(rename = "DGNP"))]
    Dgnp,
    #[yaserde(rename = "RCLQ")]
    #[cfg_attr(feature = "serde", serde(rename = "RCLQ"))]
    Rclq,
    #[yaserde(rename = "CCAV")]
    #[cfg_attr(feature = "serde", serde(rename = "CCAV"))]
    Ccav,
    #[yaserde(rename = "BTCH")]
    #[cfg_attr(feature = "serde", serde(rename = "BTCH"))]
    Btch,
    #[yaserde(rename = "FRVA")]
    #[cfg_attr(feature = "serde", serde(rename = "FRVA"))]
    Frva,
    #[yaserde(rename = "AUTQ")]
    #[cfg_attr(feature = "serde", serde(rename = "AUTQ"))]
    Autq,
    #[yaserde(rename = "FCMV")]
    #[cfg_attr(feature = "serde", serde(rename = "FCMV"))]
    Fcmv,
    #[yaserde(rename = "DCCQ")]
    #[cfg_attr(feature = "serde", serde(rename = "DCCQ"))]
    Dccq,
    #[yaserde(rename = "RVRA")]
    #[cfg_attr(feature = "serde", serde(rename = "RVRA"))]
    Rvra,
    #[yaserde(rename = "DCAV")]
    #[cfg_attr(feature = "serde", serde(rename = "DCAV"))]
    Dcav,
    #[yaserde(rename = "TRNA")]
    #[cfg_attr(feature = "serde", serde(rename = "TRNA"))]
    Trna,
    #[yaserde(rename = "NFRQ")]
    #[cfg_attr(feature = "serde", serde(rename = "NFRQ"))]
    Nfrq,
    #[yaserde(rename = "TRPQ")]
    #[cfg_attr(feature = "serde", serde(rename = "TRPQ"))]
    Trpq,
    __Unknown__(String),
}

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

impl Validate for MessageFunction43Code {}



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

    #[yaserde(rename = "Cond")]
    #[cfg_attr(feature = "serde", serde(rename = "Cond"))]
    pub cond: MessageItemCondition1Code,

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

impl Validate for MessageItemCondition1 {}


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

pub enum MessageItemCondition1Code {
    #[yaserde(rename = "MNDT")]
    #[cfg_attr(feature = "serde", serde(rename = "MNDT"))]
    Mndt,
    #[yaserde(rename = "CFVL")]
    #[cfg_attr(feature = "serde", serde(rename = "CFVL"))]
    Cfvl,
    #[yaserde(rename = "DFLT")]
    #[cfg_attr(feature = "serde", serde(rename = "DFLT"))]
    Dflt,
    #[yaserde(rename = "ALWV")]
    #[cfg_attr(feature = "serde", serde(rename = "ALWV"))]
    Alwv,
    #[yaserde(rename = "IFAV")]
    #[cfg_attr(feature = "serde", serde(rename = "IFAV"))]
    Ifav,
    #[yaserde(rename = "COPY")]
    #[cfg_attr(feature = "serde", serde(rename = "COPY"))]
    Copy,
    #[yaserde(rename = "UNSP")]
    #[cfg_attr(feature = "serde", serde(rename = "UNSP"))]
    Unsp,
    __Unknown__(String),
}

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

impl Validate for MessageItemCondition1Code {}



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

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

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

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

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

    #[yaserde(rename = "Accs")]
    #[cfg_attr(feature = "serde", serde(rename = "Accs"))]
    pub accs: NetworkParameters7,
}

impl Validate for NetworkParameters8 {}


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

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

pub enum NetworkType2Code {
    #[yaserde(rename = "SCK5")]
    #[cfg_attr(feature = "serde", serde(rename = "SCK5"))]
    Sck5,
    #[yaserde(rename = "SCK4")]
    #[cfg_attr(feature = "serde", serde(rename = "SCK4"))]
    Sck4,
    #[yaserde(rename = "HTTP")]
    #[cfg_attr(feature = "serde", serde(rename = "HTTP"))]
    Http,
    __Unknown__(String),
}

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

impl Validate for NetworkType2Code {}



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

pub enum NonFinancialRequestType1Code {
    #[yaserde(rename = "ACQR")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
    Acqr,
    #[yaserde(rename = "PARQ")]
    #[cfg_attr(feature = "serde", serde(rename = "PARQ"))]
    Parq,
    #[yaserde(rename = "RISK")]
    #[cfg_attr(feature = "serde", serde(rename = "RISK"))]
    Risk,
    #[yaserde(rename = "TOKN")]
    #[cfg_attr(feature = "serde", serde(rename = "TOKN"))]
    Tokn,
    __Unknown__(String),
}

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

impl Validate for NonFinancialRequestType1Code {}



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

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

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

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

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

impl Validate for Organisation26 {}


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

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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.003.001.10")]
pub struct PackageType2 {
    #[yaserde(rename = "PackgId")]
    #[cfg_attr(feature = "serde", serde(rename = "PackgId"))]
    pub packg_id: GenericIdentification176,

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

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

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

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

impl Validate for PackageType2 {}


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

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

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

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

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

impl Validate for Parameter15 {}


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

pub enum PartyType15Code {
    #[yaserde(rename = "PGRP")]
    #[cfg_attr(feature = "serde", serde(rename = "PGRP"))]
    Pgrp,
    #[yaserde(rename = "PSYS")]
    #[cfg_attr(feature = "serde", serde(rename = "PSYS"))]
    Psys,
    #[yaserde(rename = "PSNG")]
    #[cfg_attr(feature = "serde", serde(rename = "PSNG"))]
    Psng,
    __Unknown__(String),
}

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

impl Validate for PartyType15Code {}



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

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.003.001.10")]
pub struct PaymentTerminalParameters8 {
    #[yaserde(rename = "ActnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ActnTp"))]
    pub actn_tp: TerminalManagementAction3Code,

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

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

    #[yaserde(rename = "ParamFrmtIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "ParamFrmtIdr"))]
    pub param_frmt_idr: Max8Text,

    #[yaserde(rename = "ClckSynctn")]
    #[cfg_attr(feature = "serde", serde(rename = "ClckSynctn"))]
    pub clck_synctn: ClockSynchronisation3,

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

    #[yaserde(rename = "LclDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "LclDtTm"))]
    pub lcl_dt_tm: Vec<LocalDateTime1>,

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

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

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

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

impl Validate for PaymentTerminalParameters8 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.003.001.10")]
pub struct PhysicalInterfaceParameter1 {
    #[yaserde(rename = "IntrfcNm")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrfcNm"))]
    pub intrfc_nm: Max35Text,

    #[yaserde(rename = "IntrfcTp")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrfcTp"))]
    pub intrfc_tp: PoicommunicationType2Code,

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

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

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

    #[yaserde(rename = "AddtlParams")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlParams"))]
    pub addtl_params: Max2KBinary,
}

impl Validate for PhysicalInterfaceParameter1 {}


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

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

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

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

impl Validate for PointOfInteractionComponentIdentification2 {}


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

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

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.003.001.10")]
pub struct ProcessRetry3 {
    #[yaserde(rename = "Dely")]
    #[cfg_attr(feature = "serde", serde(rename = "Dely"))]
    pub dely: Max9NumericText,

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

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

impl Validate for ProcessRetry3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.003.001.10")]
pub struct ProcessTiming6 {
    #[yaserde(rename = "StartTm")]
    #[cfg_attr(feature = "serde", serde(rename = "StartTm"))]
    pub start_tm: IsodateTime,

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

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

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

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

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

impl Validate for Recipient9Choice {}




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

pub enum ReconciliationCriteria1Code {
    #[yaserde(rename = "BRND")]
    #[cfg_attr(feature = "serde", serde(rename = "BRND"))]
    Brnd,
    #[yaserde(rename = "PROF")]
    #[cfg_attr(feature = "serde", serde(rename = "PROF"))]
    Prof,
    #[yaserde(rename = "GRUP")]
    #[cfg_attr(feature = "serde", serde(rename = "GRUP"))]
    Grup,
    __Unknown__(String),
}

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

impl Validate for ReconciliationCriteria1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.003.001.10")]
pub struct RelativeDistinguishedName1 {
    #[yaserde(rename = "AttrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "AttrTp"))]
    pub attr_tp: AttributeType1Code,

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

impl Validate for RelativeDistinguishedName1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:catm.003.001.10")]
pub struct SaleToPOIProtocolParameter1 {
    #[yaserde(rename = "ActnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ActnTp"))]
    pub actn_tp: TerminalManagementAction3Code,

    #[yaserde(rename = "MrchntId")]
    #[cfg_attr(feature = "serde", serde(rename = "MrchntId"))]
    pub mrchnt_id: Organisation26,

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

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

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

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

impl Validate for SaleToPOIProtocolParameter1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.003.001.10")]
pub struct SecurityParameters13 {
    #[yaserde(rename = "ActnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ActnTp"))]
    pub actn_tp: TerminalManagementAction3Code,

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

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

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

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

impl Validate for SecurityParameters13 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.003.001.10")]
pub struct ServiceProviderParameters1 {
    #[yaserde(rename = "ActnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ActnTp"))]
    pub actn_tp: TerminalManagementAction3Code,

    #[yaserde(rename = "SvcPrvdrId")]
    #[cfg_attr(feature = "serde", serde(rename = "SvcPrvdrId"))]
    pub svc_prvdr_id: Vec<GenericIdentification176>,

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

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

    #[yaserde(rename = "Hst")]
    #[cfg_attr(feature = "serde", serde(rename = "Hst"))]
    pub hst: Vec<AcquirerHostConfiguration8>,

    #[yaserde(rename = "NonFinActnSpprtd")]
    #[cfg_attr(feature = "serde", serde(rename = "NonFinActnSpprtd"))]
    pub non_fin_actn_spprtd: Vec<NonFinancialRequestType1Code>,
}

impl Validate for ServiceProviderParameters1 {}


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

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

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

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

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

impl Validate for SignedData6 {}


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

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

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

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

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

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

impl Validate for Signer5 {}


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

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

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

    #[yaserde(rename = "MntncSvc")]
    #[cfg_attr(feature = "serde", serde(rename = "MntncSvc"))]
    pub mntnc_svc: Vec<DataSetCategory10Code>,

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

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

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

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

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

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

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

    #[yaserde(rename = "MsgItm")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgItm"))]
    pub msg_itm: Vec<MessageItemCondition1>,
}

impl Validate for TmsprotocolParameters5 {}


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

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.003.001.10")]
pub struct TerminalPackageType2 {
    #[yaserde(rename = "POICmpntId")]
    #[cfg_attr(feature = "serde", serde(rename = "POICmpntId"))]
    pub poi_cmpnt_id: Vec<PointOfInteractionComponentIdentification2>,

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

impl Validate for TerminalPackageType2 {}


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

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

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

impl Validate for TimeUnit1Code {}



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

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

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

impl Validate for TypeOfAmount8Code {}

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