rust_iso20022 0.1.1

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

// pub type Document = Document;
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct AccountDetails2 {
    #[yaserde(rename = "AcctNm")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctNm"))]
    pub acct_nm: Max70Text,

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

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

impl Validate for AccountDetails2 {}


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

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

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

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

impl Validate for Action9 {}


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

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

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

impl Validate for ActionDestination1Code {}



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

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

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

impl Validate for ActionType10Code {}



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

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

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

impl Validate for ActionType11Code {}



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

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

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

impl Validate for ActionType8Code {}



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

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

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

    #[yaserde(rename = "AddtlAccptrData")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlAccptrData"))]
    pub addtl_accptr_data: AdditionalAcceptorData1,

    #[yaserde(rename = "Cstmr")]
    #[cfg_attr(feature = "serde", serde(rename = "Cstmr"))]
    pub cstmr: Customer4,

    #[yaserde(rename = "Sale")]
    #[cfg_attr(feature = "serde", serde(rename = "Sale"))]
    pub sale: Sale1,

    #[yaserde(rename = "Fleet")]
    #[cfg_attr(feature = "serde", serde(rename = "Fleet"))]
    pub fleet: FleetData2,

    #[yaserde(rename = "Invc")]
    #[cfg_attr(feature = "serde", serde(rename = "Invc"))]
    pub invc: Invoice1,

    #[yaserde(rename = "TrvlAgcy")]
    #[cfg_attr(feature = "serde", serde(rename = "TrvlAgcy"))]
    pub trvl_agcy: TravelAgency2,

    #[yaserde(rename = "PssngrTrnsprt")]
    #[cfg_attr(feature = "serde", serde(rename = "PssngrTrnsprt"))]
    pub pssngr_trnsprt: PassengerTransport1,

    #[yaserde(rename = "VhclRntl")]
    #[cfg_attr(feature = "serde", serde(rename = "VhclRntl"))]
    pub vhcl_rntl: Vec<VehicleRentalService1>,

    #[yaserde(rename = "Ldgg")]
    #[cfg_attr(feature = "serde", serde(rename = "Ldgg"))]
    pub ldgg: Vec<Lodging2>,

    #[yaserde(rename = "ShppgData")]
    #[cfg_attr(feature = "serde", serde(rename = "ShppgData"))]
    pub shppg_data: ShippingData1,

    #[yaserde(rename = "TelecomSvcs")]
    #[cfg_attr(feature = "serde", serde(rename = "TelecomSvcs"))]
    pub telecom_svcs: TelecomServices1,

    #[yaserde(rename = "TempSvcs")]
    #[cfg_attr(feature = "serde", serde(rename = "TempSvcs"))]
    pub temp_svcs: Vec<TemporaryServices1>,

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

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

impl Validate for AddendumData1 {}


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

pub enum AddendumTaxType1Code {
    #[yaserde(rename = "TOTL")]
    #[cfg_attr(feature = "serde", serde(rename = "TOTL"))]
    Totl,
    #[yaserde(rename = "ALMI")]
    #[cfg_attr(feature = "serde", serde(rename = "ALMI"))]
    Almi,
    #[yaserde(rename = "ASNT")]
    #[cfg_attr(feature = "serde", serde(rename = "ASNT"))]
    Asnt,
    #[yaserde(rename = "BPTX")]
    #[cfg_attr(feature = "serde", serde(rename = "BPTX"))]
    Bptx,
    #[yaserde(rename = "KAPA")]
    #[cfg_attr(feature = "serde", serde(rename = "KAPA"))]
    Kapa,
    #[yaserde(rename = "NKAP")]
    #[cfg_attr(feature = "serde", serde(rename = "NKAP"))]
    Nkap,
    #[yaserde(rename = "CRTX")]
    #[cfg_attr(feature = "serde", serde(rename = "CRTX"))]
    Crtx,
    #[yaserde(rename = "CSTX")]
    #[cfg_attr(feature = "serde", serde(rename = "CSTX"))]
    Cstx,
    #[yaserde(rename = "CITX")]
    #[cfg_attr(feature = "serde", serde(rename = "CITX"))]
    Citx,
    #[yaserde(rename = "COAX")]
    #[cfg_attr(feature = "serde", serde(rename = "COAX"))]
    Coax,
    #[yaserde(rename = "CPST")]
    #[cfg_attr(feature = "serde", serde(rename = "CPST"))]
    Cpst,
    #[yaserde(rename = "CORT")]
    #[cfg_attr(feature = "serde", serde(rename = "CORT"))]
    Cort,
    #[yaserde(rename = "COTX")]
    #[cfg_attr(feature = "serde", serde(rename = "COTX"))]
    Cotx,
    #[yaserde(rename = "CUST")]
    #[cfg_attr(feature = "serde", serde(rename = "CUST"))]
    Cust,
    #[yaserde(rename = "DLTX")]
    #[cfg_attr(feature = "serde", serde(rename = "DLTX"))]
    Dltx,
    #[yaserde(rename = "DUTY")]
    #[cfg_attr(feature = "serde", serde(rename = "DUTY"))]
    Duty,
    #[yaserde(rename = "EMIT")]
    #[cfg_attr(feature = "serde", serde(rename = "EMIT"))]
    Emit,
    #[yaserde(rename = "EMUT")]
    #[cfg_attr(feature = "serde", serde(rename = "EMUT"))]
    Emut,
    #[yaserde(rename = "EMET")]
    #[cfg_attr(feature = "serde", serde(rename = "EMET"))]
    Emet,
    #[yaserde(rename = "EMST")]
    #[cfg_attr(feature = "serde", serde(rename = "EMST"))]
    Emst,
    #[yaserde(rename = "EMRT")]
    #[cfg_attr(feature = "serde", serde(rename = "EMRT"))]
    Emrt,
    #[yaserde(rename = "ENTX")]
    #[cfg_attr(feature = "serde", serde(rename = "ENTX"))]
    Entx,
    #[yaserde(rename = "ESET")]
    #[cfg_attr(feature = "serde", serde(rename = "ESET"))]
    Eset,
    #[yaserde(rename = "ENVT")]
    #[cfg_attr(feature = "serde", serde(rename = "ENVT"))]
    Envt,
    #[yaserde(rename = "EQUL")]
    #[cfg_attr(feature = "serde", serde(rename = "EQUL"))]
    Equl,
    #[yaserde(rename = "EQTX")]
    #[cfg_attr(feature = "serde", serde(rename = "EQTX"))]
    Eqtx,
    #[yaserde(rename = "EUTR")]
    #[cfg_attr(feature = "serde", serde(rename = "EUTR"))]
    Eutr,
    #[yaserde(rename = "EXEC")]
    #[cfg_attr(feature = "serde", serde(rename = "EXEC"))]
    Exec,
    #[yaserde(rename = "FEXT")]
    #[cfg_attr(feature = "serde", serde(rename = "FEXT"))]
    Fext,
    #[yaserde(rename = "FNST")]
    #[cfg_attr(feature = "serde", serde(rename = "FNST"))]
    Fnst,
    #[yaserde(rename = "FETX")]
    #[cfg_attr(feature = "serde", serde(rename = "FETX"))]
    Fetx,
    #[yaserde(rename = "FVAT")]
    #[cfg_attr(feature = "serde", serde(rename = "FVAT"))]
    Fvat,
    #[yaserde(rename = "FVTS")]
    #[cfg_attr(feature = "serde", serde(rename = "FVTS"))]
    Fvts,
    #[yaserde(rename = "FIMT")]
    #[cfg_attr(feature = "serde", serde(rename = "FIMT"))]
    Fimt,
    #[yaserde(rename = "FSST")]
    #[cfg_attr(feature = "serde", serde(rename = "FSST"))]
    Fsst,
    #[yaserde(rename = "FICA")]
    #[cfg_attr(feature = "serde", serde(rename = "FICA"))]
    Fica,
    #[yaserde(rename = "FRTX")]
    #[cfg_attr(feature = "serde", serde(rename = "FRTX"))]
    Frtx,
    #[yaserde(rename = "FSTX")]
    #[cfg_attr(feature = "serde", serde(rename = "FSTX"))]
    Fstx,
    #[yaserde(rename = "FSFT")]
    #[cfg_attr(feature = "serde", serde(rename = "FSFT"))]
    Fsft,
    #[yaserde(rename = "FUVT")]
    #[cfg_attr(feature = "serde", serde(rename = "FUVT"))]
    Fuvt,
    #[yaserde(rename = "GIFT")]
    #[cfg_attr(feature = "serde", serde(rename = "GIFT"))]
    Gift,
    #[yaserde(rename = "GCAT")]
    #[cfg_attr(feature = "serde", serde(rename = "GCAT"))]
    Gcat,
    #[yaserde(rename = "GRTX")]
    #[cfg_attr(feature = "serde", serde(rename = "GRTX"))]
    Grtx,
    #[yaserde(rename = "HVAT")]
    #[cfg_attr(feature = "serde", serde(rename = "HVAT"))]
    Hvat,
    #[yaserde(rename = "HATX")]
    #[cfg_attr(feature = "serde", serde(rename = "HATX"))]
    Hatx,
    #[yaserde(rename = "HSTX")]
    #[cfg_attr(feature = "serde", serde(rename = "HSTX"))]
    Hstx,
    #[yaserde(rename = "HWTX")]
    #[cfg_attr(feature = "serde", serde(rename = "HWTX"))]
    Hwtx,
    #[yaserde(rename = "INHT")]
    #[cfg_attr(feature = "serde", serde(rename = "INHT"))]
    Inht,
    #[yaserde(rename = "INPO")]
    #[cfg_attr(feature = "serde", serde(rename = "INPO"))]
    Inpo,
    #[yaserde(rename = "LTTX")]
    #[cfg_attr(feature = "serde", serde(rename = "LTTX"))]
    Lttx,
    #[yaserde(rename = "FLST")]
    #[cfg_attr(feature = "serde", serde(rename = "FLST"))]
    Flst,
    #[yaserde(rename = "LITX")]
    #[cfg_attr(feature = "serde", serde(rename = "LITX"))]
    Litx,
    #[yaserde(rename = "LOCO")]
    #[cfg_attr(feature = "serde", serde(rename = "LOCO"))]
    Loco,
    #[yaserde(rename = "LSTX")]
    #[cfg_attr(feature = "serde", serde(rename = "LSTX"))]
    Lstx,
    #[yaserde(rename = "LOCL")]
    #[cfg_attr(feature = "serde", serde(rename = "LOCL"))]
    Locl,
    #[yaserde(rename = "LUTX")]
    #[cfg_attr(feature = "serde", serde(rename = "LUTX"))]
    Lutx,
    #[yaserde(rename = "MATX")]
    #[cfg_attr(feature = "serde", serde(rename = "MATX"))]
    Matx,
    #[yaserde(rename = "METX")]
    #[cfg_attr(feature = "serde", serde(rename = "METX"))]
    Metx,
    #[yaserde(rename = "MITX")]
    #[cfg_attr(feature = "serde", serde(rename = "MITX"))]
    Mitx,
    #[yaserde(rename = "MUTX")]
    #[cfg_attr(feature = "serde", serde(rename = "MUTX"))]
    Mutx,
    #[yaserde(rename = "MUDE")]
    #[cfg_attr(feature = "serde", serde(rename = "MUDE"))]
    Mude,
    #[yaserde(rename = "COUN")]
    #[cfg_attr(feature = "serde", serde(rename = "COUN"))]
    Coun,
    #[yaserde(rename = "NATI")]
    #[cfg_attr(feature = "serde", serde(rename = "NATI"))]
    Nati,
    #[yaserde(rename = "OCTX")]
    #[cfg_attr(feature = "serde", serde(rename = "OCTX"))]
    Octx,
    #[yaserde(rename = "OPTX")]
    #[cfg_attr(feature = "serde", serde(rename = "OPTX"))]
    Optx,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "OTTX")]
    #[cfg_attr(feature = "serde", serde(rename = "OTTX"))]
    Ottx,
    #[yaserde(rename = "LEVY")]
    #[cfg_attr(feature = "serde", serde(rename = "LEVY"))]
    Levy,
    #[yaserde(rename = "POTX")]
    #[cfg_attr(feature = "serde", serde(rename = "POTX"))]
    Potx,
    #[yaserde(rename = "PRTX")]
    #[cfg_attr(feature = "serde", serde(rename = "PRTX"))]
    Prtx,
    #[yaserde(rename = "PSTX")]
    #[cfg_attr(feature = "serde", serde(rename = "PSTX"))]
    Pstx,
    #[yaserde(rename = "PPTX")]
    #[cfg_attr(feature = "serde", serde(rename = "PPTX"))]
    Pptx,
    #[yaserde(rename = "PROV")]
    #[cfg_attr(feature = "serde", serde(rename = "PROV"))]
    Prov,
    #[yaserde(rename = "PHET")]
    #[cfg_attr(feature = "serde", serde(rename = "PHET"))]
    Phet,
    #[yaserde(rename = "QUST")]
    #[cfg_attr(feature = "serde", serde(rename = "QUST"))]
    Qust,
    #[yaserde(rename = "ROCI")]
    #[cfg_attr(feature = "serde", serde(rename = "ROCI"))]
    Roci,
    #[yaserde(rename = "RCSB")]
    #[cfg_attr(feature = "serde", serde(rename = "RCSB"))]
    Rcsb,
    #[yaserde(rename = "RCSD")]
    #[cfg_attr(feature = "serde", serde(rename = "RCSD"))]
    Rcsd,
    #[yaserde(rename = "ROTX")]
    #[cfg_attr(feature = "serde", serde(rename = "ROTX"))]
    Rotx,
    #[yaserde(rename = "RVAT")]
    #[cfg_attr(feature = "serde", serde(rename = "RVAT"))]
    Rvat,
    #[yaserde(rename = "ROVI")]
    #[cfg_attr(feature = "serde", serde(rename = "ROVI"))]
    Rovi,
    #[yaserde(rename = "SAUT")]
    #[cfg_attr(feature = "serde", serde(rename = "SAUT"))]
    Saut,
    #[yaserde(rename = "SCTX")]
    #[cfg_attr(feature = "serde", serde(rename = "SCTX"))]
    Sctx,
    #[yaserde(rename = "SPTX")]
    #[cfg_attr(feature = "serde", serde(rename = "SPTX"))]
    Sptx,
    #[yaserde(rename = "STTA")]
    #[cfg_attr(feature = "serde", serde(rename = "STTA"))]
    Stta,
    #[yaserde(rename = "STAM")]
    #[cfg_attr(feature = "serde", serde(rename = "STAM"))]
    Stam,
    #[yaserde(rename = "SLST")]
    #[cfg_attr(feature = "serde", serde(rename = "SLST"))]
    Slst,
    #[yaserde(rename = "SLTX")]
    #[cfg_attr(feature = "serde", serde(rename = "SLTX"))]
    Sltx,
    #[yaserde(rename = "SETX")]
    #[cfg_attr(feature = "serde", serde(rename = "SETX"))]
    Setx,
    #[yaserde(rename = "STPT")]
    #[cfg_attr(feature = "serde", serde(rename = "STPT"))]
    Stpt,
    #[yaserde(rename = "SPTS")]
    #[cfg_attr(feature = "serde", serde(rename = "SPTS"))]
    Spts,
    #[yaserde(rename = "SPFT")]
    #[cfg_attr(feature = "serde", serde(rename = "SPFT"))]
    Spft,
    #[yaserde(rename = "SPTG")]
    #[cfg_attr(feature = "serde", serde(rename = "SPTG"))]
    Sptg,
    #[yaserde(rename = "SRTX")]
    #[cfg_attr(feature = "serde", serde(rename = "SRTX"))]
    Srtx,
    #[yaserde(rename = "SSTX")]
    #[cfg_attr(feature = "serde", serde(rename = "SSTX"))]
    Sstx,
    #[yaserde(rename = "STAT")]
    #[cfg_attr(feature = "serde", serde(rename = "STAT"))]
    Stat,
    #[yaserde(rename = "STSL")]
    #[cfg_attr(feature = "serde", serde(rename = "STSL"))]
    Stsl,
    #[yaserde(rename = "STEX")]
    #[cfg_attr(feature = "serde", serde(rename = "STEX"))]
    Stex,
    #[yaserde(rename = "SUTX")]
    #[cfg_attr(feature = "serde", serde(rename = "SUTX"))]
    Sutx,
    #[yaserde(rename = "CTAX")]
    #[cfg_attr(feature = "serde", serde(rename = "CTAX"))]
    Ctax,
    #[yaserde(rename = "TDDT")]
    #[cfg_attr(feature = "serde", serde(rename = "TDDT"))]
    Tddt,
    #[yaserde(rename = "TELT")]
    #[cfg_attr(feature = "serde", serde(rename = "TELT"))]
    Telt,
    #[yaserde(rename = "THTX")]
    #[cfg_attr(feature = "serde", serde(rename = "THTX"))]
    Thtx,
    #[yaserde(rename = "TRAX")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAX"))]
    Trax,
    #[yaserde(rename = "TRAN")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAN"))]
    Tran,
    #[yaserde(rename = "UNSP")]
    #[cfg_attr(feature = "serde", serde(rename = "UNSP"))]
    Unsp,
    #[yaserde(rename = "UUTX")]
    #[cfg_attr(feature = "serde", serde(rename = "UUTX"))]
    Uutx,
    #[yaserde(rename = "VATA")]
    #[cfg_attr(feature = "serde", serde(rename = "VATA"))]
    Vata,
    #[yaserde(rename = "VATB")]
    #[cfg_attr(feature = "serde", serde(rename = "VATB"))]
    Vatb,
    #[yaserde(rename = "WTAX")]
    #[cfg_attr(feature = "serde", serde(rename = "WTAX"))]
    Wtax,
    #[yaserde(rename = "WESV")]
    #[cfg_attr(feature = "serde", serde(rename = "WESV"))]
    Wesv,
    #[yaserde(rename = "WITF")]
    #[cfg_attr(feature = "serde", serde(rename = "WITF"))]
    Witf,
    #[yaserde(rename = "WITL")]
    #[cfg_attr(feature = "serde", serde(rename = "WITL"))]
    Witl,
    #[yaserde(rename = "WITH")]
    #[cfg_attr(feature = "serde", serde(rename = "WITH"))]
    With,
    __Unknown__(String),
}

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

impl Validate for AddendumTaxType1Code {}



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

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

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

    #[yaserde(rename = "CorpTaxIdTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CorpTaxIdTp"))]
    pub corp_tax_id_tp: CorporateTaxType1Code,

    #[yaserde(rename = "AddtlId")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlId"))]
    pub addtl_id: Vec<AdditionalIdentification1>,

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

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

impl Validate for AdditionalAcceptorData1 {}


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

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

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

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

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

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

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

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

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

impl Validate for AdditionalAction1 {}


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

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

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

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

impl Validate for AdditionalAmounts1 {}


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

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

impl Validate for AdditionalCharacteristicDetails1 {}


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

    #[yaserde(rename = "Ownr")]
    #[cfg_attr(feature = "serde", serde(rename = "Ownr"))]
    pub ownr: AdditionalCharacteristicDetails1,

    #[yaserde(rename = "Certfctn")]
    #[cfg_attr(feature = "serde", serde(rename = "Certfctn"))]
    pub certfctn: AdditionalCharacteristicDetails1,

    #[yaserde(rename = "OwnrEthncty")]
    #[cfg_attr(feature = "serde", serde(rename = "OwnrEthncty"))]
    pub ownr_ethncty: AdditionalCharacteristicDetails1,
}

impl Validate for AdditionalCharacteristics1 {}


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

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

impl Validate for AdditionalData1 {}


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

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

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

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

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

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

impl Validate for AdditionalFee1 {}


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

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

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

impl Validate for AdditionalIdentification1 {}


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

pub enum AdditionalIdentificationType1Code {
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "ICSN")]
    #[cfg_attr(feature = "serde", serde(rename = "ICSN"))]
    Icsn,
    #[yaserde(rename = "ATNU")]
    #[cfg_attr(feature = "serde", serde(rename = "ATNU"))]
    Atnu,
    __Unknown__(String),
}

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

impl Validate for AdditionalIdentificationType1Code {}



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

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

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

impl Validate for AdditionalInformation19 {}


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

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

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

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

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

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

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

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

impl Validate for AdditionalInformation20 {}


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

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

impl Validate for AdditionalRiskData1 {}


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

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

impl Validate for AdditionalService1 {}


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

pub enum AdditionalServiceType1Code {
    #[yaserde(rename = "CACT")]
    #[cfg_attr(feature = "serde", serde(rename = "CACT"))]
    Cact,
    #[yaserde(rename = "CSHB")]
    #[cfg_attr(feature = "serde", serde(rename = "CSHB"))]
    Cshb,
    #[yaserde(rename = "DCCV")]
    #[cfg_attr(feature = "serde", serde(rename = "DCCV"))]
    Dccv,
    #[yaserde(rename = "INTP")]
    #[cfg_attr(feature = "serde", serde(rename = "INTP"))]
    Intp,
    #[yaserde(rename = "INTT")]
    #[cfg_attr(feature = "serde", serde(rename = "INTT"))]
    Intt,
    #[yaserde(rename = "LOYT")]
    #[cfg_attr(feature = "serde", serde(rename = "LOYT"))]
    Loyt,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "PRST")]
    #[cfg_attr(feature = "serde", serde(rename = "PRST"))]
    Prst,
    __Unknown__(String),
}

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

impl Validate for AdditionalServiceType1Code {}



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

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

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

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

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

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

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

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

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

impl Validate for Address1 {}


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

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

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

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

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

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

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

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

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

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

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

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

impl Validate for Adjustment10 {}


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

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

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

impl Validate for Adjustment11 {}


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

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

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

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

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

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

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

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

impl Validate for Adjustment9 {}


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

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

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

impl Validate for Algorithm11Code {}



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

pub enum Algorithm13Code {
    #[yaserde(rename = "EA2C")]
    #[cfg_attr(feature = "serde", serde(rename = "EA2C"))]
    Ea2C,
    #[yaserde(rename = "E3DC")]
    #[cfg_attr(feature = "serde", serde(rename = "E3DC"))]
    E3Dc,
    #[yaserde(rename = "DKP9")]
    #[cfg_attr(feature = "serde", serde(rename = "DKP9"))]
    Dkp9,
    #[yaserde(rename = "UKPT")]
    #[cfg_attr(feature = "serde", serde(rename = "UKPT"))]
    Ukpt,
    #[yaserde(rename = "UKA1")]
    #[cfg_attr(feature = "serde", serde(rename = "UKA1"))]
    Uka1,
    #[yaserde(rename = "EA9C")]
    #[cfg_attr(feature = "serde", serde(rename = "EA9C"))]
    Ea9C,
    #[yaserde(rename = "EA5C")]
    #[cfg_attr(feature = "serde", serde(rename = "EA5C"))]
    Ea5C,
    __Unknown__(String),
}

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

impl Validate for Algorithm13Code {}



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

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

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

impl Validate for Algorithm16Code {}



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

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

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

impl Validate for Algorithm17Code {}



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

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

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

impl Validate for Algorithm18Code {}



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

pub enum Algorithm19Code {
    #[yaserde(rename = "ERS2")]
    #[cfg_attr(feature = "serde", serde(rename = "ERS2"))]
    Ers2,
    #[yaserde(rename = "ERS1")]
    #[cfg_attr(feature = "serde", serde(rename = "ERS1"))]
    Ers1,
    #[yaserde(rename = "RPSS")]
    #[cfg_attr(feature = "serde", serde(rename = "RPSS"))]
    Rpss,
    #[yaserde(rename = "ECC5")]
    #[cfg_attr(feature = "serde", serde(rename = "ECC5"))]
    Ecc5,
    #[yaserde(rename = "ECC1")]
    #[cfg_attr(feature = "serde", serde(rename = "ECC1"))]
    Ecc1,
    #[yaserde(rename = "ECC4")]
    #[cfg_attr(feature = "serde", serde(rename = "ECC4"))]
    Ecc4,
    #[yaserde(rename = "ECC2")]
    #[cfg_attr(feature = "serde", serde(rename = "ECC2"))]
    Ecc2,
    #[yaserde(rename = "ECC3")]
    #[cfg_attr(feature = "serde", serde(rename = "ECC3"))]
    Ecc3,
    #[yaserde(rename = "ERS3")]
    #[cfg_attr(feature = "serde", serde(rename = "ERS3"))]
    Ers3,
    #[yaserde(rename = "ECP2")]
    #[cfg_attr(feature = "serde", serde(rename = "ECP2"))]
    Ecp2,
    #[yaserde(rename = "ECP3")]
    #[cfg_attr(feature = "serde", serde(rename = "ECP3"))]
    Ecp3,
    #[yaserde(rename = "ECP5")]
    #[cfg_attr(feature = "serde", serde(rename = "ECP5"))]
    Ecp5,
    __Unknown__(String),
}

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

impl Validate for Algorithm19Code {}



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

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

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

impl Validate for Algorithm20Code {}



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

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

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

impl Validate for Algorithm23Code {}



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

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

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

impl Validate for Algorithm5Code {}



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

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

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

impl Validate for Algorithm7Code {}



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

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

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

impl Validate for Algorithm8Code {}



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

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

impl Validate for AlgorithmIdentification12 {}


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

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

impl Validate for AlgorithmIdentification18 {}


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

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

impl Validate for AlgorithmIdentification19 {}


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

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

impl Validate for AlgorithmIdentification20 {}


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

impl Validate for AlgorithmIdentification21 {}


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

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

impl Validate for AlgorithmIdentification22 {}


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

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

impl Validate for AlgorithmIdentification23 {}


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

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

impl Validate for AlgorithmIdentification24 {}


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

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

impl Validate for AlgorithmIdentification25 {}


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

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

impl Validate for AlgorithmIdentification26 {}


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

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

impl Validate for AlgorithmIdentification27 {}


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

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

impl Validate for AlgorithmIdentification28 {}


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

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

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

    #[yaserde(rename = "Tax")]
    #[cfg_attr(feature = "serde", serde(rename = "Tax"))]
    pub tax: Vec<Tax33>,
}

impl Validate for Amount10 {}


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

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

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

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

impl Validate for Amount11 {}


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

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

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

    #[yaserde(rename = "Hrs")]
    #[cfg_attr(feature = "serde", serde(rename = "Hrs"))]
    pub hrs: Max6NumericText,
}

impl Validate for Amount12 {}


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

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

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

impl Validate for Amount13 {}


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

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

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

impl Validate for Amount14 {}


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

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

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

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

impl Validate for Amount4 {}


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

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

impl Validate for Amount5 {}


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

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

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

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

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

impl Validate for Amount9 {}


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

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

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

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

    #[yaserde(rename = "Tax")]
    #[cfg_attr(feature = "serde", serde(rename = "Tax"))]
    pub tax: Vec<Tax33>,
}

impl Validate for AmountDetails1 {}


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

    #[yaserde(rename = "RltdDocNb")]
    #[cfg_attr(feature = "serde", serde(rename = "RltdDocNb"))]
    pub rltd_doc_nb: Max15Text,

    #[yaserde(rename = "SvcCtgyCd")]
    #[cfg_attr(feature = "serde", serde(rename = "SvcCtgyCd"))]
    pub svc_ctgy_cd: Max4Text,

    #[yaserde(rename = "SvcSubCtgyCd")]
    #[cfg_attr(feature = "serde", serde(rename = "SvcSubCtgyCd"))]
    pub svc_sub_ctgy_cd: Max4Text,

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

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

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

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

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

    #[yaserde(rename = "Tax")]
    #[cfg_attr(feature = "serde", serde(rename = "Tax"))]
    pub tax: Vec<Tax33>,

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

impl Validate for AncillaryPurchase1 {}


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

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

impl Validate for ApprovalData1 {}


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

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

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

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

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

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

impl Validate for ApprovalEntity1 {}


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

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

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

impl Validate for AttributeType1Code {}



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

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

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

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

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

impl Validate for AuthenticatedData5 {}


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

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

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

impl Validate for AuthenticationMethod11Code {}



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

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

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

    #[yaserde(rename = "AdddmData")]
    #[cfg_attr(feature = "serde", serde(rename = "AdddmData"))]
    pub adddm_data: AddendumData1,

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

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

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

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

impl Validate for AuthorisationInitiation1 {}


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

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

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

impl Validate for AuthorisationInitiationV02 {}


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

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

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

impl Validate for AuthorisedAmount1 {}


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

impl Validate for BaseOneRate {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct BatchManagementInformation1 {
    #[yaserde(rename = "ColltnId")]
    #[cfg_attr(feature = "serde", serde(rename = "ColltnId"))]
    pub colltn_id: Max35Text,

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

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

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

impl Validate for BatchManagementInformation1 {}


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

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

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

impl Validate for BytePadding1Code {}



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

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

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

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

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

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

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

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

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

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

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

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

impl Validate for Capabilities1 {}


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

pub enum CarRentalActivity1Code {
    #[yaserde(rename = "CARS")]
    #[cfg_attr(feature = "serde", serde(rename = "CARS"))]
    Cars,
    #[yaserde(rename = "GLBL")]
    #[cfg_attr(feature = "serde", serde(rename = "GLBL"))]
    Glbl,
    #[yaserde(rename = "INDV")]
    #[cfg_attr(feature = "serde", serde(rename = "INDV"))]
    Indv,
    #[yaserde(rename = "PETP")]
    #[cfg_attr(feature = "serde", serde(rename = "PETP"))]
    Petp,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    __Unknown__(String),
}

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

impl Validate for CarRentalActivity1Code {}



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

pub enum CarRentalServiceType2Code {
    #[yaserde(rename = "ADJM")]
    #[cfg_attr(feature = "serde", serde(rename = "ADJM"))]
    Adjm,
    #[yaserde(rename = "AUTH")]
    #[cfg_attr(feature = "serde", serde(rename = "AUTH"))]
    Auth,
    #[yaserde(rename = "BAST")]
    #[cfg_attr(feature = "serde", serde(rename = "BAST"))]
    Bast,
    #[yaserde(rename = "CLEA")]
    #[cfg_attr(feature = "serde", serde(rename = "CLEA"))]
    Clea,
    #[yaserde(rename = "DMGS")]
    #[cfg_attr(feature = "serde", serde(rename = "DMGS"))]
    Dmgs,
    #[yaserde(rename = "DLVR")]
    #[cfg_attr(feature = "serde", serde(rename = "DLVR"))]
    Dlvr,
    #[yaserde(rename = "DPOF")]
    #[cfg_attr(feature = "serde", serde(rename = "DPOF"))]
    Dpof,
    #[yaserde(rename = "ENTE")]
    #[cfg_attr(feature = "serde", serde(rename = "ENTE"))]
    Ente,
    #[yaserde(rename = "EXTC")]
    #[cfg_attr(feature = "serde", serde(rename = "EXTC"))]
    Extc,
    #[yaserde(rename = "EXDY")]
    #[cfg_attr(feature = "serde", serde(rename = "EXDY"))]
    Exdy,
    #[yaserde(rename = "EXDI")]
    #[cfg_attr(feature = "serde", serde(rename = "EXDI"))]
    Exdi,
    #[yaserde(rename = "EXHR")]
    #[cfg_attr(feature = "serde", serde(rename = "EXHR"))]
    Exhr,
    #[yaserde(rename = "FINE")]
    #[cfg_attr(feature = "serde", serde(rename = "FINE"))]
    Fine,
    #[yaserde(rename = "FUEL")]
    #[cfg_attr(feature = "serde", serde(rename = "FUEL"))]
    Fuel,
    #[yaserde(rename = "GARA")]
    #[cfg_attr(feature = "serde", serde(rename = "GARA"))]
    Gara,
    #[yaserde(rename = "GPSY")]
    #[cfg_attr(feature = "serde", serde(rename = "GPSY"))]
    Gpsy,
    #[yaserde(rename = "INSU")]
    #[cfg_attr(feature = "serde", serde(rename = "INSU"))]
    Insu,
    #[yaserde(rename = "LATE")]
    #[cfg_attr(feature = "serde", serde(rename = "LATE"))]
    Late,
    #[yaserde(rename = "LIIN")]
    #[cfg_attr(feature = "serde", serde(rename = "LIIN"))]
    Liin,
    #[yaserde(rename = "LDIN")]
    #[cfg_attr(feature = "serde", serde(rename = "LDIN"))]
    Ldin,
    #[yaserde(rename = "MISC")]
    #[cfg_attr(feature = "serde", serde(rename = "MISC"))]
    Misc,
    #[yaserde(rename = "NAVI")]
    #[cfg_attr(feature = "serde", serde(rename = "NAVI"))]
    Navi,
    #[yaserde(rename = "NOSH")]
    #[cfg_attr(feature = "serde", serde(rename = "NOSH"))]
    Nosh,
    #[yaserde(rename = "ONEW")]
    #[cfg_attr(feature = "serde", serde(rename = "ONEW"))]
    Onew,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "PARK")]
    #[cfg_attr(feature = "serde", serde(rename = "PARK"))]
    Park,
    #[yaserde(rename = "PRIN")]
    #[cfg_attr(feature = "serde", serde(rename = "PRIN"))]
    Prin,
    #[yaserde(rename = "PFIN")]
    #[cfg_attr(feature = "serde", serde(rename = "PFIN"))]
    Pfin,
    #[yaserde(rename = "PHON")]
    #[cfg_attr(feature = "serde", serde(rename = "PHON"))]
    Phon,
    #[yaserde(rename = "REGD")]
    #[cfg_attr(feature = "serde", serde(rename = "REGD"))]
    Regd,
    #[yaserde(rename = "SMOK")]
    #[cfg_attr(feature = "serde", serde(rename = "SMOK"))]
    Smok,
    #[yaserde(rename = "TOLL")]
    #[cfg_attr(feature = "serde", serde(rename = "TOLL"))]
    Toll,
    #[yaserde(rename = "TOWI")]
    #[cfg_attr(feature = "serde", serde(rename = "TOWI"))]
    Towi,
    __Unknown__(String),
}

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

impl Validate for CarRentalServiceType2Code {}



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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Validate for CardData1 {}


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

pub enum CardDataReading5Code {
    #[yaserde(rename = "TAGC")]
    #[cfg_attr(feature = "serde", serde(rename = "TAGC"))]
    Tagc,
    #[yaserde(rename = "PHYS")]
    #[cfg_attr(feature = "serde", serde(rename = "PHYS"))]
    Phys,
    #[yaserde(rename = "BRCD")]
    #[cfg_attr(feature = "serde", serde(rename = "BRCD"))]
    Brcd,
    #[yaserde(rename = "MGST")]
    #[cfg_attr(feature = "serde", serde(rename = "MGST"))]
    Mgst,
    #[yaserde(rename = "CICC")]
    #[cfg_attr(feature = "serde", serde(rename = "CICC"))]
    Cicc,
    #[yaserde(rename = "DFLE")]
    #[cfg_attr(feature = "serde", serde(rename = "DFLE"))]
    Dfle,
    #[yaserde(rename = "CTLS")]
    #[cfg_attr(feature = "serde", serde(rename = "CTLS"))]
    Ctls,
    #[yaserde(rename = "ECTL")]
    #[cfg_attr(feature = "serde", serde(rename = "ECTL"))]
    Ectl,
    #[yaserde(rename = "CDFL")]
    #[cfg_attr(feature = "serde", serde(rename = "CDFL"))]
    Cdfl,
    __Unknown__(String),
}

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

impl Validate for CardDataReading5Code {}



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

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

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

impl Validate for CardDataReading7Code {}



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

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

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

impl Validate for CardDataWriting1Code {}



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

pub enum CardDepositType1Code {
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "ENVL")]
    #[cfg_attr(feature = "serde", serde(rename = "ENVL"))]
    Envl,
    #[yaserde(rename = "CHEC")]
    #[cfg_attr(feature = "serde", serde(rename = "CHEC"))]
    Chec,
    #[yaserde(rename = "CASH")]
    #[cfg_attr(feature = "serde", serde(rename = "CASH"))]
    Cash,
    __Unknown__(String),
}

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

impl Validate for CardDepositType1Code {}



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

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

impl Validate for CardProgramme1 {}


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

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

impl Validate for CardProgrammeMode1 {}


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

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

impl Validate for CardProgrammeMode2 {}


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

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

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

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

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

impl Validate for Cardholder15 {}


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

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

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

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

impl Validate for CardholderName1 {}


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

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

impl Validate for CardholderVerificationCapabilities1 {}


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

pub enum CardholderVerificationCapability5Code {
    #[yaserde(rename = "APKI")]
    #[cfg_attr(feature = "serde", serde(rename = "APKI"))]
    Apki,
    #[yaserde(rename = "NOVF")]
    #[cfg_attr(feature = "serde", serde(rename = "NOVF"))]
    Novf,
    #[yaserde(rename = "FBIG")]
    #[cfg_attr(feature = "serde", serde(rename = "FBIG"))]
    Fbig,
    #[yaserde(rename = "FBIO")]
    #[cfg_attr(feature = "serde", serde(rename = "FBIO"))]
    Fbio,
    #[yaserde(rename = "FDSG")]
    #[cfg_attr(feature = "serde", serde(rename = "FDSG"))]
    Fdsg,
    #[yaserde(rename = "FCPN")]
    #[cfg_attr(feature = "serde", serde(rename = "FCPN"))]
    Fcpn,
    #[yaserde(rename = "FEPN")]
    #[cfg_attr(feature = "serde", serde(rename = "FEPN"))]
    Fepn,
    #[yaserde(rename = "NBIO")]
    #[cfg_attr(feature = "serde", serde(rename = "NBIO"))]
    Nbio,
    #[yaserde(rename = "NPIN")]
    #[cfg_attr(feature = "serde", serde(rename = "NPIN"))]
    Npin,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "SIGN")]
    #[cfg_attr(feature = "serde", serde(rename = "SIGN"))]
    Sign,
    #[yaserde(rename = "UNSP")]
    #[cfg_attr(feature = "serde", serde(rename = "UNSP"))]
    Unsp,
    #[yaserde(rename = "VORN")]
    #[cfg_attr(feature = "serde", serde(rename = "VORN"))]
    Vorn,
    #[yaserde(rename = "PKIS")]
    #[cfg_attr(feature = "serde", serde(rename = "PKIS"))]
    Pkis,
    #[yaserde(rename = "NOPN")]
    #[cfg_attr(feature = "serde", serde(rename = "NOPN"))]
    Nopn,
    #[yaserde(rename = "NOOP")]
    #[cfg_attr(feature = "serde", serde(rename = "NOOP"))]
    Noop,
    __Unknown__(String),
}

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

impl Validate for CardholderVerificationCapability5Code {}



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

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

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

impl Validate for CarrierIdentification1 {}


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

impl Validate for CertificateIssuer1 {}


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

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

impl Validate for ClaimInformation1 {}


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

    #[yaserde(rename = "RmotPty")]
    #[cfg_attr(feature = "serde", serde(rename = "RmotPty"))]
    pub rmot_pty: Vec<PartyType7Code>,

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

impl Validate for CommunicationCharacteristics3 {}


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

pub enum CompanyAssigner2Code {
    #[yaserde(rename = "ASSO")]
    #[cfg_attr(feature = "serde", serde(rename = "ASSO"))]
    Asso,
    #[yaserde(rename = "AUTH")]
    #[cfg_attr(feature = "serde", serde(rename = "AUTH"))]
    Auth,
    #[yaserde(rename = "CPNY")]
    #[cfg_attr(feature = "serde", serde(rename = "CPNY"))]
    Cpny,
    #[yaserde(rename = "LEII")]
    #[cfg_attr(feature = "serde", serde(rename = "LEII"))]
    Leii,
    #[yaserde(rename = "TRAG")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAG"))]
    Trag,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    __Unknown__(String),
}

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

impl Validate for CompanyAssigner2Code {}



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

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

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

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

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

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

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

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

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

impl Validate for Contact1 {}


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

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

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

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

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

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

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

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

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

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

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

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

impl Validate for Contact2 {}


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

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

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

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

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

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

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

impl Validate for Contact3 {}


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

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

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

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

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

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

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

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

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

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

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

impl Validate for Contact6 {}


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

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

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

impl Validate for Content1 {}


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

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

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

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

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

impl Validate for ContentInformationType19 {}


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

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

impl Validate for ContentInformationType20 {}


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

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

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

impl Validate for ContentType2Code {}



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

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

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

impl Validate for ContentType3Code {}



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

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

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

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

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

impl Validate for Context1 {}


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

pub enum CorporateTaxType1Code {
    #[yaserde(rename = "SMBS")]
    #[cfg_attr(feature = "serde", serde(rename = "SMBS"))]
    Smbs,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "CORP")]
    #[cfg_attr(feature = "serde", serde(rename = "CORP"))]
    Corp,
    __Unknown__(String),
}

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

impl Validate for CorporateTaxType1Code {}



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

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

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

impl Validate for Credentials1 {}


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

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

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

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

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

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

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

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

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

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

impl Validate for CryptographicKey13 {}


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

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

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

impl Validate for CryptographicKeyType3Code {}



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

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

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

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

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

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

impl Validate for Customer3 {}


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

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

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

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

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

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

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

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

impl Validate for Customer4 {}


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

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

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

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

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

    #[yaserde(rename = "Ctct")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctct"))]
    pub ctct: Contact6,
}

impl Validate for Customer5 {}


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

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

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

impl Validate for Customer6 {}


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

pub enum CustomerAssigner1Code {
    #[yaserde(rename = "AUTH")]
    #[cfg_attr(feature = "serde", serde(rename = "AUTH"))]
    Auth,
    #[yaserde(rename = "CRCY")]
    #[cfg_attr(feature = "serde", serde(rename = "CRCY"))]
    Crcy,
    #[yaserde(rename = "CUST")]
    #[cfg_attr(feature = "serde", serde(rename = "CUST"))]
    Cust,
    #[yaserde(rename = "ONFL")]
    #[cfg_attr(feature = "serde", serde(rename = "ONFL"))]
    Onfl,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "TRAY")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAY"))]
    Tray,
    __Unknown__(String),
}

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

impl Validate for CustomerAssigner1Code {}



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

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

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

impl Validate for CustomerDevice2 {}


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

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

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

impl Validate for CustomerDeviceType1Code {}



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

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

impl Validate for CustomerReference1 {}


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

pub enum CustomerType2Code {
    #[yaserde(rename = "CSMR")]
    #[cfg_attr(feature = "serde", serde(rename = "CSMR"))]
    Csmr,
    #[yaserde(rename = "CPNY")]
    #[cfg_attr(feature = "serde", serde(rename = "CPNY"))]
    Cpny,
    __Unknown__(String),
}

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

impl Validate for CustomerType2Code {}



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

impl Validate for DecimalNumber {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct DeliveryInformation3 {
    #[yaserde(rename = "DlvryNoteNb")]
    #[cfg_attr(feature = "serde", serde(rename = "DlvryNoteNb"))]
    pub dlvry_note_nb: Max35Text,

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

    #[yaserde(rename = "Ctct")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctct"))]
    pub ctct: Contact6,

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

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

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

impl Validate for DeliveryInformation3 {}


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

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

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

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

impl Validate for DepartureOrArrival1 {}


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

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

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

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

impl Validate for DepartureOrArrival2 {}


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

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

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

impl Validate for DepositDetails1 {}


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

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

impl Validate for Destination2 {}


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

pub enum DetailAmount1Code {
    #[yaserde(rename = "CSHB")]
    #[cfg_attr(feature = "serde", serde(rename = "CSHB"))]
    Cshb,
    #[yaserde(rename = "DONN")]
    #[cfg_attr(feature = "serde", serde(rename = "DONN"))]
    Donn,
    #[yaserde(rename = "DCCF")]
    #[cfg_attr(feature = "serde", serde(rename = "DCCF"))]
    Dccf,
    #[yaserde(rename = "EXTR")]
    #[cfg_attr(feature = "serde", serde(rename = "EXTR"))]
    Extr,
    #[yaserde(rename = "FORX")]
    #[cfg_attr(feature = "serde", serde(rename = "FORX"))]
    Forx,
    #[yaserde(rename = "GRTY")]
    #[cfg_attr(feature = "serde", serde(rename = "GRTY"))]
    Grty,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "SRCH")]
    #[cfg_attr(feature = "serde", serde(rename = "SRCH"))]
    Srch,
    #[yaserde(rename = "TAXT")]
    #[cfg_attr(feature = "serde", serde(rename = "TAXT"))]
    Taxt,
    __Unknown__(String),
}

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

impl Validate for DetailAmount1Code {}



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

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

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

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

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

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

impl Validate for DetailedAmount19 {}


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

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

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

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

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

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

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

impl Validate for Device1 {}


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

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

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

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

impl Validate for DigestedData5 {}


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

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

impl Validate for Discount3 {}


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

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

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

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

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

impl Validate for DisplayCapabilities6 {}


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

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

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

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

    #[yaserde(rename = "DsptRef")]
    #[cfg_attr(feature = "serde", serde(rename = "DsptRef"))]
    pub dspt_ref: Vec<DisputeReference1>,

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

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

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

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

impl Validate for DisputeData1 {}


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

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

impl Validate for DisputeIdentification1 {}


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

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

    #[yaserde(rename = "DsptId")]
    #[cfg_attr(feature = "serde", serde(rename = "DsptId"))]
    pub dspt_id: Vec<DisputeIdentification1>,
}

impl Validate for DisputeReference1 {}


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

    #[yaserde(rename = "OdmtrStart")]
    #[cfg_attr(feature = "serde", serde(rename = "OdmtrStart"))]
    pub odmtr_start: Max10NumericText,

    #[yaserde(rename = "OdmtrRtr")]
    #[cfg_attr(feature = "serde", serde(rename = "OdmtrRtr"))]
    pub odmtr_rtr: Max10NumericText,

    #[yaserde(rename = "TtlDstnc")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlDstnc"))]
    pub ttl_dstnc: Max10NumericText,

    #[yaserde(rename = "FreeDstnc")]
    #[cfg_attr(feature = "serde", serde(rename = "FreeDstnc"))]
    pub free_dstnc: Max10NumericText,

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

impl Validate for Distance1 {}


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

impl Validate for Document {}


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

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

impl Validate for DocumentReference1 {}


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

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

    #[yaserde(rename = "DrvgLic")]
    #[cfg_attr(feature = "serde", serde(rename = "DrvgLic"))]
    pub drvg_lic: DrivingLicense1,

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

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

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

    #[yaserde(rename = "AddtlId")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlId"))]
    pub addtl_id: Vec<TravelDocument1>,

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

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

impl Validate for Driver1 {}


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

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

    #[yaserde(rename = "Ctct")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctct"))]
    pub ctct: Contact6,

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

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

    #[yaserde(rename = "DrvrCrdntl")]
    #[cfg_attr(feature = "serde", serde(rename = "DrvrCrdntl"))]
    pub drvr_crdntl: Vec<TravelDocument1>,

    #[yaserde(rename = "DrvgLic")]
    #[cfg_attr(feature = "serde", serde(rename = "DrvgLic"))]
    pub drvg_lic: DrivingLicense1,
}

impl Validate for DriverInParty1 {}


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

    #[yaserde(rename = "Form")]
    #[cfg_attr(feature = "serde", serde(rename = "Form"))]
    pub form: PresentationMedium2Code,

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

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

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

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

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

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

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

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

impl Validate for DrivingLicense1 {}


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

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

impl Validate for EcommerceData1 {}


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

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

impl Validate for EncapsulatedContent3 {}


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

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

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

impl Validate for EncryptedContent4 {}


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

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

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

impl Validate for EncryptedContent5 {}


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

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

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

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

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

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

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

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

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

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

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

impl Validate for EncryptedData1Choice {}




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

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

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

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

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

impl Validate for EncryptedDataElement1 {}


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

pub enum EncryptedDataFormat1Code {
    #[yaserde(rename = "ASCI")]
    #[cfg_attr(feature = "serde", serde(rename = "ASCI"))]
    Asci,
    #[yaserde(rename = "BINF")]
    #[cfg_attr(feature = "serde", serde(rename = "BINF"))]
    Binf,
    #[yaserde(rename = "EBCD")]
    #[cfg_attr(feature = "serde", serde(rename = "EBCD"))]
    Ebcd,
    #[yaserde(rename = "HEXF")]
    #[cfg_attr(feature = "serde", serde(rename = "HEXF"))]
    Hexf,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    __Unknown__(String),
}

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

impl Validate for EncryptedDataFormat1Code {}



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

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

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

impl Validate for EncryptionFormat2Code {}



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

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

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

impl Validate for EncryptionFormat3Code {}



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

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

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

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

impl Validate for EnvelopedData5 {}


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

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

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

impl Validate for EnvelopedData6 {}


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

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

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

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

    #[yaserde(rename = "Pyer")]
    #[cfg_attr(feature = "serde", serde(rename = "Pyer"))]
    pub pyer: PartyIdentification211,

    #[yaserde(rename = "Pyee")]
    #[cfg_attr(feature = "serde", serde(rename = "Pyee"))]
    pub pyee: PartyIdentification211,

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

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

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

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

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

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

impl Validate for Environment1 {}


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Validate for FeeAmount2 {}


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

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

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

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

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

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

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

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

impl Validate for FinancialInstitution4 {}


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

    #[yaserde(rename = "LineItm")]
    #[cfg_attr(feature = "serde", serde(rename = "LineItm"))]
    pub line_itm: Vec<FleetLineItem1>,
}

impl Validate for FleetData2 {}


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

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

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

impl Validate for FleetDiscountTotals1 {}


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

    #[yaserde(rename = "SvcTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SvcTp"))]
    pub svc_tp: FleetServiceType1Code,

    #[yaserde(rename = "FuelBrndCd")]
    #[cfg_attr(feature = "serde", serde(rename = "FuelBrndCd"))]
    pub fuel_brnd_cd: Max4Text,

    #[yaserde(rename = "FleetPdctCd")]
    #[cfg_attr(feature = "serde", serde(rename = "FleetPdctCd"))]
    pub fleet_pdct_cd: Max4Text,

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

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

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

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

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

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

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

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

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

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

    #[yaserde(rename = "Tax")]
    #[cfg_attr(feature = "serde", serde(rename = "Tax"))]
    pub tax: Vec<Tax33>,

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

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

impl Validate for FleetLineItem1 {}


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

pub enum FleetPurchaseType1Code {
    #[yaserde(rename = "FUEL")]
    #[cfg_attr(feature = "serde", serde(rename = "FUEL"))]
    Fuel,
    #[yaserde(rename = "NONF")]
    #[cfg_attr(feature = "serde", serde(rename = "NONF"))]
    Nonf,
    #[yaserde(rename = "FANF")]
    #[cfg_attr(feature = "serde", serde(rename = "FANF"))]
    Fanf,
    __Unknown__(String),
}

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

impl Validate for FleetPurchaseType1Code {}



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

pub enum FleetServiceType1Code {
    #[yaserde(rename = "SLSV")]
    #[cfg_attr(feature = "serde", serde(rename = "SLSV"))]
    Slsv,
    #[yaserde(rename = "HSDI")]
    #[cfg_attr(feature = "serde", serde(rename = "HSDI"))]
    Hsdi,
    #[yaserde(rename = "FLSV")]
    #[cfg_attr(feature = "serde", serde(rename = "FLSV"))]
    Flsv,
    __Unknown__(String),
}

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

impl Validate for FleetServiceType1Code {}



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

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

    #[yaserde(rename = "DrvrOrVhclCard")]
    #[cfg_attr(feature = "serde", serde(rename = "DrvrOrVhclCard"))]
    pub drvr_or_vhcl_card: PlainCardData20,

    #[yaserde(rename = "CardFuelPrmptCd")]
    #[cfg_attr(feature = "serde", serde(rename = "CardFuelPrmptCd"))]
    pub card_fuel_prmpt_cd: Max1Number,

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

    #[yaserde(rename = "TripInf")]
    #[cfg_attr(feature = "serde", serde(rename = "TripInf"))]
    pub trip_inf: TripInformation1,

    #[yaserde(rename = "LclAmnty")]
    #[cfg_attr(feature = "serde", serde(rename = "LclAmnty"))]
    pub lcl_amnty: Vec<LocalAmenity1>,

    #[yaserde(rename = "TxRltdData")]
    #[cfg_attr(feature = "serde", serde(rename = "TxRltdData"))]
    pub tx_rltd_data: Vec<PaymentTransaction117>,

    #[yaserde(rename = "AddtlData")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlData"))]
    pub addtl_data: AdditionalInformation19,
}

impl Validate for FleetSummary1 {}


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

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

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

impl Validate for Frequency12Code {}



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

    #[yaserde(rename = "FndgSrc")]
    #[cfg_attr(feature = "serde", serde(rename = "FndgSrc"))]
    pub fndg_src: FundingSource2,

    #[yaserde(rename = "ClmInf")]
    #[cfg_attr(feature = "serde", serde(rename = "ClmInf"))]
    pub clm_inf: ClaimInformation1,
}

impl Validate for FundingService1 {}


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

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

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

impl Validate for FundingSource2 {}


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

pub enum FundingSourceType2Code {
    #[yaserde(rename = "LOYL")]
    #[cfg_attr(feature = "serde", serde(rename = "LOYL"))]
    Loyl,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "SVNG")]
    #[cfg_attr(feature = "serde", serde(rename = "SVNG"))]
    Svng,
    #[yaserde(rename = "UVRL")]
    #[cfg_attr(feature = "serde", serde(rename = "UVRL"))]
    Uvrl,
    #[yaserde(rename = "CASH")]
    #[cfg_attr(feature = "serde", serde(rename = "CASH"))]
    Cash,
    #[yaserde(rename = "CRDT")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDT"))]
    Crdt,
    #[yaserde(rename = "CDBT")]
    #[cfg_attr(feature = "serde", serde(rename = "CDBT"))]
    Cdbt,
    #[yaserde(rename = "EPRS")]
    #[cfg_attr(feature = "serde", serde(rename = "EPRS"))]
    Eprs,
    #[yaserde(rename = "DBAC")]
    #[cfg_attr(feature = "serde", serde(rename = "DBAC"))]
    Dbac,
    #[yaserde(rename = "CURR")]
    #[cfg_attr(feature = "serde", serde(rename = "CURR"))]
    Curr,
    #[yaserde(rename = "CHQE")]
    #[cfg_attr(feature = "serde", serde(rename = "CHQE"))]
    Chqe,
    #[yaserde(rename = "PRPD")]
    #[cfg_attr(feature = "serde", serde(rename = "PRPD"))]
    Prpd,
    #[yaserde(rename = "LCDT")]
    #[cfg_attr(feature = "serde", serde(rename = "LCDT"))]
    Lcdt,
    __Unknown__(String),
}

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

impl Validate for FundingSourceType2Code {}



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

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

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

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

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

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

impl Validate for GenericIdentification172 {}


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

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

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

impl Validate for GenericIdentification48 {}


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

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

impl Validate for GenericInformation1 {}


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

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

impl Validate for GeographicCoordinates1 {}


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

pub enum GoodsAndServices1Code {
    #[yaserde(rename = "ELEC")]
    #[cfg_attr(feature = "serde", serde(rename = "ELEC"))]
    Elec,
    #[yaserde(rename = "PHYS")]
    #[cfg_attr(feature = "serde", serde(rename = "PHYS"))]
    Phys,
    #[yaserde(rename = "ELPH")]
    #[cfg_attr(feature = "serde", serde(rename = "ELPH"))]
    Elph,
    __Unknown__(String),
}

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

impl Validate for GoodsAndServices1Code {}



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

pub enum GoodsAndServicesSubType1Code {
    #[yaserde(rename = "CRCU")]
    #[cfg_attr(feature = "serde", serde(rename = "CRCU"))]
    Crcu,
    #[yaserde(rename = "FORX")]
    #[cfg_attr(feature = "serde", serde(rename = "FORX"))]
    Forx,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "SECS")]
    #[cfg_attr(feature = "serde", serde(rename = "SECS"))]
    Secs,
    __Unknown__(String),
}

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

impl Validate for GoodsAndServicesSubType1Code {}



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

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

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

impl Validate for GracePeriod1 {}


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

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

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

impl Validate for GracePeriodUnitType1Code {}



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

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

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

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

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

    #[yaserde(rename = "BtchMgmtInf")]
    #[cfg_attr(feature = "serde", serde(rename = "BtchMgmtInf"))]
    pub btch_mgmt_inf: BatchManagementInformation1,

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

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

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

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

impl Validate for Header42 {}


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

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

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

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

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

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

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

impl Validate for HiredVehicle1 {}


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

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

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

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

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

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

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

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

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

impl Validate for Identification2Code {}



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

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

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

    #[yaserde(rename = "Plan")]
    #[cfg_attr(feature = "serde", serde(rename = "Plan"))]
    pub plan: Vec<Plan1>,
}

impl Validate for Instalment3 {}


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

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

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

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

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

impl Validate for InstalmentAmountDetails1 {}


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

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

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

impl Validate for InstalmentAmountDetailsType1Code {}



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

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

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

impl Validate for InstalmentPeriod1Code {}



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

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

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

impl Validate for InterestRate1Code {}



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

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

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

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

impl Validate for InterestRateDetails1 {}


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

    #[yaserde(rename = "LineItm")]
    #[cfg_attr(feature = "serde", serde(rename = "LineItm"))]
    pub line_itm: Vec<InvoiceLineItem1>,
}

impl Validate for Invoice1 {}


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

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

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

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

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

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

    #[yaserde(rename = "ShipToIndstryCd")]
    #[cfg_attr(feature = "serde", serde(rename = "ShipToIndstryCd"))]
    pub ship_to_indstry_cd: Max50Text,

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

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

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

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

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

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

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

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

    #[yaserde(rename = "Adjstmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "Adjstmnt"))]
    pub adjstmnt: Adjustment11,

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

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

    #[yaserde(rename = "Tax")]
    #[cfg_attr(feature = "serde", serde(rename = "Tax"))]
    pub tax: Vec<Tax33>,

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

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

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

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

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

impl Validate for InvoiceLineItem1 {}


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

    #[yaserde(rename = "Sellr")]
    #[cfg_attr(feature = "serde", serde(rename = "Sellr"))]
    pub sellr: PartyIdentification206,

    #[yaserde(rename = "Buyr")]
    #[cfg_attr(feature = "serde", serde(rename = "Buyr"))]
    pub buyr: PartyIdentification206,

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

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

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

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

    #[yaserde(rename = "TaxTtl")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxTtl"))]
    pub tax_ttl: Vec<Tax33>,

    #[yaserde(rename = "TaxRclmMtd")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxRclmMtd"))]
    pub tax_rclm_mtd: TaxReclaimMethod1Code,

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

impl Validate for InvoiceSummary1 {}


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

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

impl Validate for IssuerAndSerialNumber1 {}


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

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

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

impl Validate for JourneyInformation1 {}


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

pub enum JourneyType1Code {
    #[yaserde(rename = "COAC")]
    #[cfg_attr(feature = "serde", serde(rename = "COAC"))]
    Coac,
    #[yaserde(rename = "EARL")]
    #[cfg_attr(feature = "serde", serde(rename = "EARL"))]
    Earl,
    #[yaserde(rename = "FLGT")]
    #[cfg_attr(feature = "serde", serde(rename = "FLGT"))]
    Flgt,
    #[yaserde(rename = "LATE")]
    #[cfg_attr(feature = "serde", serde(rename = "LATE"))]
    Late,
    #[yaserde(rename = "ONTM")]
    #[cfg_attr(feature = "serde", serde(rename = "ONTM"))]
    Ontm,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "TRAN")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAN"))]
    Tran,
    #[yaserde(rename = "VESS")]
    #[cfg_attr(feature = "serde", serde(rename = "VESS"))]
    Vess,
    __Unknown__(String),
}

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

impl Validate for JourneyType1Code {}



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

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

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

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

impl Validate for Kek5 {}


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

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

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

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

impl Validate for Kek6 {}


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

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

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

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

impl Validate for Kekidentifier2 {}


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

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

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

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

impl Validate for Kekidentifier6 {}


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

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

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

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

impl Validate for KeyTransport5 {}


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

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

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

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

impl Validate for KeyTransport6 {}


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

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

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

impl Validate for KeyUsage1Code {}



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

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

pub enum LegalStructure1Code {
    #[yaserde(rename = "STAE")]
    #[cfg_attr(feature = "serde", serde(rename = "STAE"))]
    Stae,
    #[yaserde(rename = "PVIN")]
    #[cfg_attr(feature = "serde", serde(rename = "PVIN"))]
    Pvin,
    #[yaserde(rename = "MUNI")]
    #[cfg_attr(feature = "serde", serde(rename = "MUNI"))]
    Muni,
    #[yaserde(rename = "CNTY")]
    #[cfg_attr(feature = "serde", serde(rename = "CNTY"))]
    Cnty,
    #[yaserde(rename = "NATI")]
    #[cfg_attr(feature = "serde", serde(rename = "NATI"))]
    Nati,
    __Unknown__(String),
}

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

impl Validate for LegalStructure1Code {}



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

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

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

impl Validate for LifeCycleSupport1Code {}



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

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

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

impl Validate for LocalAmenity1 {}


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

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

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

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

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

    #[yaserde(rename = "LclCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "LclCcy"))]
    pub lcl_ccy: Iso3NumericCurrencyCode,
}

impl Validate for Location3 {}


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

pub enum LocationAmenity1Code {
    #[yaserde(rename = "AADA")]
    #[cfg_attr(feature = "serde", serde(rename = "AADA"))]
    Aada,
    #[yaserde(rename = "AFLA")]
    #[cfg_attr(feature = "serde", serde(rename = "AFLA"))]
    Afla,
    #[yaserde(rename = "AVLA")]
    #[cfg_attr(feature = "serde", serde(rename = "AVLA"))]
    Avla,
    #[yaserde(rename = "CRWA")]
    #[cfg_attr(feature = "serde", serde(rename = "CRWA"))]
    Crwa,
    #[yaserde(rename = "CVSA")]
    #[cfg_attr(feature = "serde", serde(rename = "CVSA"))]
    Cvsa,
    #[yaserde(rename = "DISA")]
    #[cfg_attr(feature = "serde", serde(rename = "DISA"))]
    Disa,
    #[yaserde(rename = "EWAA")]
    #[cfg_attr(feature = "serde", serde(rename = "EWAA"))]
    Ewaa,
    #[yaserde(rename = "MRLA")]
    #[cfg_attr(feature = "serde", serde(rename = "MRLA"))]
    Mrla,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "PAPA")]
    #[cfg_attr(feature = "serde", serde(rename = "PAPA"))]
    Papa,
    #[yaserde(rename = "TSHA")]
    #[cfg_attr(feature = "serde", serde(rename = "TSHA"))]
    Tsha,
    #[yaserde(rename = "TSRA")]
    #[cfg_attr(feature = "serde", serde(rename = "TSRA"))]
    Tsra,
    #[yaserde(rename = "TSSA")]
    #[cfg_attr(feature = "serde", serde(rename = "TSSA"))]
    Tssa,
    #[yaserde(rename = "TFHA")]
    #[cfg_attr(feature = "serde", serde(rename = "TFHA"))]
    Tfha,
    #[yaserde(rename = "VSWA")]
    #[cfg_attr(feature = "serde", serde(rename = "VSWA"))]
    Vswa,
    #[yaserde(rename = "VHPA")]
    #[cfg_attr(feature = "serde", serde(rename = "VHPA"))]
    Vhpa,
    #[yaserde(rename = "VMRA")]
    #[cfg_attr(feature = "serde", serde(rename = "VMRA"))]
    Vmra,
    __Unknown__(String),
}

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

impl Validate for LocationAmenity1Code {}



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

    #[yaserde(rename = "LineItm")]
    #[cfg_attr(feature = "serde", serde(rename = "LineItm"))]
    pub line_itm: Vec<LodgingLineItem1>,
}

impl Validate for Lodging2 {}


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

pub enum LodgingActivity1Code {
    #[yaserde(rename = "APTM")]
    #[cfg_attr(feature = "serde", serde(rename = "APTM"))]
    Aptm,
    #[yaserde(rename = "BEBR")]
    #[cfg_attr(feature = "serde", serde(rename = "BEBR"))]
    Bebr,
    #[yaserde(rename = "COTT")]
    #[cfg_attr(feature = "serde", serde(rename = "COTT"))]
    Cott,
    #[yaserde(rename = "CRUI")]
    #[cfg_attr(feature = "serde", serde(rename = "CRUI"))]
    Crui,
    #[yaserde(rename = "HOME")]
    #[cfg_attr(feature = "serde", serde(rename = "HOME"))]
    Home,
    #[yaserde(rename = "HOST")]
    #[cfg_attr(feature = "serde", serde(rename = "HOST"))]
    Host,
    #[yaserde(rename = "HOTL")]
    #[cfg_attr(feature = "serde", serde(rename = "HOTL"))]
    Hotl,
    #[yaserde(rename = "LODG")]
    #[cfg_attr(feature = "serde", serde(rename = "LODG"))]
    Lodg,
    #[yaserde(rename = "MOTL")]
    #[cfg_attr(feature = "serde", serde(rename = "MOTL"))]
    Motl,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "RESO")]
    #[cfg_attr(feature = "serde", serde(rename = "RESO"))]
    Reso,
    #[yaserde(rename = "ROAB")]
    #[cfg_attr(feature = "serde", serde(rename = "ROAB"))]
    Roab,
    #[yaserde(rename = "TOSH")]
    #[cfg_attr(feature = "serde", serde(rename = "TOSH"))]
    Tosh,
    __Unknown__(String),
}

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

impl Validate for LodgingActivity1Code {}



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

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

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

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

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

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

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

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

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

    #[yaserde(rename = "Tax")]
    #[cfg_attr(feature = "serde", serde(rename = "Tax"))]
    pub tax: Vec<Tax33>,

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

impl Validate for LodgingLineItem1 {}


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

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

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

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

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

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

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

    #[yaserde(rename = "Ctct")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctct"))]
    pub ctct: Contact3,

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

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

impl Validate for LodgingProperty1 {}


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

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

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

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

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

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

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

impl Validate for LodgingRoom1 {}


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

pub enum LodgingService1Code {
    #[yaserde(rename = "ACCO")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCO"))]
    Acco,
    #[yaserde(rename = "AUDI")]
    #[cfg_attr(feature = "serde", serde(rename = "AUDI"))]
    Audi,
    #[yaserde(rename = "BANQ")]
    #[cfg_attr(feature = "serde", serde(rename = "BANQ"))]
    Banq,
    #[yaserde(rename = "BREK")]
    #[cfg_attr(feature = "serde", serde(rename = "BREK"))]
    Brek,
    #[yaserde(rename = "BUSS")]
    #[cfg_attr(feature = "serde", serde(rename = "BUSS"))]
    Buss,
    #[yaserde(rename = "CONC")]
    #[cfg_attr(feature = "serde", serde(rename = "CONC"))]
    Conc,
    #[yaserde(rename = "EARA")]
    #[cfg_attr(feature = "serde", serde(rename = "EARA"))]
    Eara,
    #[yaserde(rename = "EARD")]
    #[cfg_attr(feature = "serde", serde(rename = "EARD"))]
    Eard,
    #[yaserde(rename = "ENTR")]
    #[cfg_attr(feature = "serde", serde(rename = "ENTR"))]
    Entr,
    #[yaserde(rename = "FCAA")]
    #[cfg_attr(feature = "serde", serde(rename = "FCAA"))]
    Fcaa,
    #[yaserde(rename = "GAME")]
    #[cfg_attr(feature = "serde", serde(rename = "GAME"))]
    Game,
    #[yaserde(rename = "GARA")]
    #[cfg_attr(feature = "serde", serde(rename = "GARA"))]
    Gara,
    #[yaserde(rename = "GIFT")]
    #[cfg_attr(feature = "serde", serde(rename = "GIFT"))]
    Gift,
    #[yaserde(rename = "HEAL")]
    #[cfg_attr(feature = "serde", serde(rename = "HEAL"))]
    Heal,
    #[yaserde(rename = "INTE")]
    #[cfg_attr(feature = "serde", serde(rename = "INTE"))]
    Inte,
    #[yaserde(rename = "LAUN")]
    #[cfg_attr(feature = "serde", serde(rename = "LAUN"))]
    Laun,
    #[yaserde(rename = "LONG")]
    #[cfg_attr(feature = "serde", serde(rename = "LONG"))]
    Long,
    #[yaserde(rename = "MINI")]
    #[cfg_attr(feature = "serde", serde(rename = "MINI"))]
    Mini,
    #[yaserde(rename = "NOSH")]
    #[cfg_attr(feature = "serde", serde(rename = "NOSH"))]
    Nosh,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "PARK")]
    #[cfg_attr(feature = "serde", serde(rename = "PARK"))]
    Park,
    #[yaserde(rename = "PHON")]
    #[cfg_attr(feature = "serde", serde(rename = "PHON"))]
    Phon,
    #[yaserde(rename = "REST")]
    #[cfg_attr(feature = "serde", serde(rename = "REST"))]
    Rest,
    #[yaserde(rename = "RMSE")]
    #[cfg_attr(feature = "serde", serde(rename = "RMSE"))]
    Rmse,
    #[yaserde(rename = "SPAS")]
    #[cfg_attr(feature = "serde", serde(rename = "SPAS"))]
    Spas,
    #[yaserde(rename = "THRD")]
    #[cfg_attr(feature = "serde", serde(rename = "THRD"))]
    Thrd,
    #[yaserde(rename = "TRAN")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAN"))]
    Tran,
    #[yaserde(rename = "VODS")]
    #[cfg_attr(feature = "serde", serde(rename = "VODS"))]
    Vods,
    __Unknown__(String),
}

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

impl Validate for LodgingService1Code {}



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

    #[yaserde(rename = "Prprty")]
    #[cfg_attr(feature = "serde", serde(rename = "Prprty"))]
    pub prprty: LodgingProperty1,

    #[yaserde(rename = "Cstmr")]
    #[cfg_attr(feature = "serde", serde(rename = "Cstmr"))]
    pub cstmr: Customer5,

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

    #[yaserde(rename = "Room")]
    #[cfg_attr(feature = "serde", serde(rename = "Room"))]
    pub room: Vec<LodgingRoom1>,

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

    #[yaserde(rename = "Arrvl")]
    #[cfg_attr(feature = "serde", serde(rename = "Arrvl"))]
    pub arrvl: DepartureOrArrival2,

    #[yaserde(rename = "Dprture")]
    #[cfg_attr(feature = "serde", serde(rename = "Dprture"))]
    pub dprture: DepartureOrArrival1,

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

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

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

    #[yaserde(rename = "TtlTax")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlTax"))]
    pub ttl_tax: Vec<Tax33>,

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

    #[yaserde(rename = "AuthrsdAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "AuthrsdAmt"))]
    pub authrsd_amt: Vec<AuthorisedAmount1>,

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

    #[yaserde(rename = "LltyPrgrmm")]
    #[cfg_attr(feature = "serde", serde(rename = "LltyPrgrmm"))]
    pub llty_prgrmm: Vec<LoyaltyProgramme2>,

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

impl Validate for LodgingSummary1 {}


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

    #[yaserde(rename = "Adr")]
    #[cfg_attr(feature = "serde", serde(rename = "Adr"))]
    pub adr: Address1,

    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

    #[yaserde(rename = "MmbSts")]
    #[cfg_attr(feature = "serde", serde(rename = "MmbSts"))]
    pub mmb_sts: Max35Text,

    #[yaserde(rename = "XprtnDt")]
    #[cfg_attr(feature = "serde", serde(rename = "XprtnDt"))]
    pub xprtn_dt: Isodate,

    #[yaserde(rename = "LltyVal")]
    #[cfg_attr(feature = "serde", serde(rename = "LltyVal"))]
    pub llty_val: Max10NumericText,

    #[yaserde(rename = "LltyValTp")]
    #[cfg_attr(feature = "serde", serde(rename = "LltyValTp"))]
    pub llty_val_tp: LoyaltyValueType1Code,

    #[yaserde(rename = "OthrLltyValTp")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrLltyValTp"))]
    pub othr_llty_val_tp: Max35Text,

    #[yaserde(rename = "ValToCdt")]
    #[cfg_attr(feature = "serde", serde(rename = "ValToCdt"))]
    pub val_to_cdt: Max10NumericText,

    #[yaserde(rename = "ValToDbt")]
    #[cfg_attr(feature = "serde", serde(rename = "ValToDbt"))]
    pub val_to_dbt: Max10NumericText,

    #[yaserde(rename = "Bal")]
    #[cfg_attr(feature = "serde", serde(rename = "Bal"))]
    pub bal: Max10NumericText,
}

impl Validate for LoyaltyMember1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct LoyaltyProgramme1 {
    #[yaserde(rename = "PrgrmmElgbltyInd")]
    #[cfg_attr(feature = "serde", serde(rename = "PrgrmmElgbltyInd"))]
    pub prgrmm_elgblty_ind: Vec<TrueFalseIndicator>,

    #[yaserde(rename = "PrgrmmIssr")]
    #[cfg_attr(feature = "serde", serde(rename = "PrgrmmIssr"))]
    pub prgrmm_issr: Max35Text,

    #[yaserde(rename = "LltyMmb")]
    #[cfg_attr(feature = "serde", serde(rename = "LltyMmb"))]
    pub llty_mmb: LoyaltyMember1,
}

impl Validate for LoyaltyProgramme1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct LoyaltyProgramme2 {
    #[yaserde(rename = "PrgrmmTp")]
    #[cfg_attr(feature = "serde", serde(rename = "PrgrmmTp"))]
    pub prgrmm_tp: Max35Text,

    #[yaserde(rename = "PrgmId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrgmId"))]
    pub prgm_id: Max70Text,

    #[yaserde(rename = "PtcptId")]
    #[cfg_attr(feature = "serde", serde(rename = "PtcptId"))]
    pub ptcpt_id: Max70Text,
}

impl Validate for LoyaltyProgramme2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum LoyaltyValueType1Code {
    #[yaserde(rename = "MILE")]
    #[cfg_attr(feature = "serde", serde(rename = "MILE"))]
    Mile,
    #[yaserde(rename = "MONE")]
    #[cfg_attr(feature = "serde", serde(rename = "MONE"))]
    Mone,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "POIN")]
    #[cfg_attr(feature = "serde", serde(rename = "POIN"))]
    Poin,
    #[yaserde(rename = "PRIV")]
    #[cfg_attr(feature = "serde", serde(rename = "PRIV"))]
    Priv,
    __Unknown__(String),
}

impl Default for LoyaltyValueType1Code {
    fn default() -> LoyaltyValueType1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for LoyaltyValueType1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct Macdata1 {
    #[yaserde(rename = "Ctrl")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctrl"))]
    pub ctrl: Exact1HexBinaryText,

    #[yaserde(rename = "KeySetIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "KeySetIdr"))]
    pub key_set_idr: Max8NumericText,

    #[yaserde(rename = "DrvdInf")]
    #[cfg_attr(feature = "serde", serde(rename = "DrvdInf"))]
    pub drvd_inf: Max32HexBinaryText,

    #[yaserde(rename = "Algo")]
    #[cfg_attr(feature = "serde", serde(rename = "Algo"))]
    pub algo: Max2NumericText,

    #[yaserde(rename = "KeyLngth")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyLngth"))]
    pub key_lngth: Max4NumericText,

    #[yaserde(rename = "KeyPrtcn")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyPrtcn"))]
    pub key_prtcn: Max2NumericText,

    #[yaserde(rename = "KeyIndx")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyIndx"))]
    pub key_indx: Max5NumericText,

    #[yaserde(rename = "PddgMtd")]
    #[cfg_attr(feature = "serde", serde(rename = "PddgMtd"))]
    pub pddg_mtd: Max2NumericText,

    #[yaserde(rename = "InitlstnVctr")]
    #[cfg_attr(feature = "serde", serde(rename = "InitlstnVctr"))]
    pub initlstn_vctr: Max32HexBinaryText,
}

impl Validate for Macdata1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max1000Text (pub String);
crate::simple_type!(Max1000Text);

impl Validate for Max1000Text {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 1000 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 1000 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max100KBinary (pub String);
crate::simple_type!(Max100KBinary);

impl Validate for Max100KBinary {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 102400 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 102400 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max104Text (pub String);
crate::simple_type!(Max104Text);

impl Validate for Max104Text {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 104 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 104 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max10KHexBinaryText (pub String);
crate::simple_type!(Max10KHexBinaryText);

impl Validate for Max10KHexBinaryText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max10KText (pub String);
crate::simple_type!(Max10KText);

impl Validate for Max10KText {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 10000 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 10000 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max10NumberFraction2 (pub String);
crate::simple_type!(Max10NumberFraction2);

impl Validate for Max10NumberFraction2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max10NumericText (pub String);
crate::simple_type!(Max10NumericText);

impl Validate for Max10NumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max10Text (pub String);
crate::simple_type!(Max10Text);

impl Validate for Max10Text {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 10 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 10 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max11NumericText (pub String);
crate::simple_type!(Max11NumericText);

impl Validate for Max11NumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max12NumericText (pub String);
crate::simple_type!(Max12NumericText);

impl Validate for Max12NumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max140Binary (pub String);
crate::simple_type!(Max140Binary);

impl Validate for Max140Binary {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 140 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 140 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max140Text (pub String);
crate::simple_type!(Max140Text);

impl Validate for Max140Text {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 140 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 140 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max15NumericText (pub String);
crate::simple_type!(Max15NumericText);

impl Validate for Max15NumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max15Text (pub String);
crate::simple_type!(Max15Text);

impl Validate for Max15Text {
    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() > 15 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 15 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max16HexBinaryText (pub String);
crate::simple_type!(Max16HexBinaryText);

impl Validate for Max16HexBinaryText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max16Text (pub String);
crate::simple_type!(Max16Text);

impl Validate for Max16Text {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 16 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 16 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max19HexBinaryText (pub String);
crate::simple_type!(Max19HexBinaryText);

impl Validate for Max19HexBinaryText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max19NumericText (pub String);
crate::simple_type!(Max19NumericText);

impl Validate for Max19NumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max1Number (pub String);
crate::simple_type!(Max1Number);

impl Validate for Max1Number {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max2048Text (pub String);
crate::simple_type!(Max2048Text);

impl Validate for Max2048Text {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 2048 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 2048 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max20KText (pub String);
crate::simple_type!(Max20KText);

impl Validate for Max20KText {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 20000 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 20000 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max20Text (pub String);
crate::simple_type!(Max20Text);

impl Validate for Max20Text {
    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() > 20 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 20 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max23NumericText (pub String);
crate::simple_type!(Max23NumericText);

impl Validate for Max23NumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max256Text (pub String);
crate::simple_type!(Max256Text);

impl Validate for Max256Text {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 256 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 256 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max2NumericText (pub String);
crate::simple_type!(Max2NumericText);

impl Validate for Max2NumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max3000Binary (pub String);
crate::simple_type!(Max3000Binary);

impl Validate for Max3000Binary {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 3000 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 3000 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max32HexBinaryText (pub String);
crate::simple_type!(Max32HexBinaryText);

impl Validate for Max32HexBinaryText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max350Text (pub String);
crate::simple_type!(Max350Text);

impl Validate for Max350Text {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 350 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 350 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max35Binary (pub String);
crate::simple_type!(Max35Binary);

impl Validate for Max35Binary {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 35 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 35 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max35NumericText (pub String);
crate::simple_type!(Max35NumericText);

impl Validate for Max35NumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max35Text (pub String);
crate::simple_type!(Max35Text);

impl Validate for Max35Text {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 35 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 35 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max37Text (pub String);
crate::simple_type!(Max37Text);

impl Validate for Max37Text {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 37 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 37 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max3NumericText (pub String);
crate::simple_type!(Max3NumericText);

impl Validate for Max3NumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max40Text (pub String);
crate::simple_type!(Max40Text);

impl Validate for Max40Text {
    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() > 40 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 40 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max4NumericText (pub String);
crate::simple_type!(Max4NumericText);

impl Validate for Max4NumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max4Text (pub String);
crate::simple_type!(Max4Text);

impl Validate for Max4Text {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 4 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 4 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max5000Binary (pub String);
crate::simple_type!(Max5000Binary);

impl Validate for Max5000Binary {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 5000 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 5000 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max500Binary (pub String);
crate::simple_type!(Max500Binary);

impl Validate for Max500Binary {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 500 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 500 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max500Text (pub String);
crate::simple_type!(Max500Text);

impl Validate for Max500Text {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 500 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 500 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max50Text (pub String);
crate::simple_type!(Max50Text);

impl Validate for Max50Text {
    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() > 50 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 50 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max5NumericText (pub String);
crate::simple_type!(Max5NumericText);

impl Validate for Max5NumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max6NumberFraction2 (pub String);
crate::simple_type!(Max6NumberFraction2);

impl Validate for Max6NumberFraction2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max6NumericText (pub String);
crate::simple_type!(Max6NumericText);

impl Validate for Max6NumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max6Text (pub String);
crate::simple_type!(Max6Text);

impl Validate for Max6Text {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 6 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 6 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max70Text (pub String);
crate::simple_type!(Max70Text);

impl Validate for Max70Text {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 70 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 70 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max76Text (pub String);
crate::simple_type!(Max76Text);

impl Validate for Max76Text {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 76 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 76 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max8HexBinaryText (pub String);
crate::simple_type!(Max8HexBinaryText);

impl Validate for Max8HexBinaryText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max8NumericText (pub String);
crate::simple_type!(Max8NumericText);

impl Validate for Max8NumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max9999HexBinaryText (pub String);
crate::simple_type!(Max9999HexBinaryText);

impl Validate for Max9999HexBinaryText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Max99Text (pub String);
crate::simple_type!(Max99Text);

impl Validate for Max99Text {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 99 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 99 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct MemoryCharacteristics1 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

    #[yaserde(rename = "TtlSz")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlSz"))]
    pub ttl_sz: DecimalNumber,

    #[yaserde(rename = "FreeSz")]
    #[cfg_attr(feature = "serde", serde(rename = "FreeSz"))]
    pub free_sz: DecimalNumber,

    #[yaserde(rename = "Unit")]
    #[cfg_attr(feature = "serde", serde(rename = "Unit"))]
    pub unit: MemoryUnit1Code,
}

impl Validate for MemoryCharacteristics1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum MemoryUnit1Code {
    #[yaserde(rename = "BYTE")]
    #[cfg_attr(feature = "serde", serde(rename = "BYTE"))]
    Byte,
    #[yaserde(rename = "EXAB")]
    #[cfg_attr(feature = "serde", serde(rename = "EXAB"))]
    Exab,
    #[yaserde(rename = "GIGA")]
    #[cfg_attr(feature = "serde", serde(rename = "GIGA"))]
    Giga,
    #[yaserde(rename = "KILO")]
    #[cfg_attr(feature = "serde", serde(rename = "KILO"))]
    Kilo,
    #[yaserde(rename = "MEGA")]
    #[cfg_attr(feature = "serde", serde(rename = "MEGA"))]
    Mega,
    #[yaserde(rename = "PETA")]
    #[cfg_attr(feature = "serde", serde(rename = "PETA"))]
    Peta,
    #[yaserde(rename = "TERA")]
    #[cfg_attr(feature = "serde", serde(rename = "TERA"))]
    Tera,
    __Unknown__(String),
}

impl Default for MemoryUnit1Code {
    fn default() -> MemoryUnit1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for MemoryUnit1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum MessageClass1Code {
    #[yaserde(rename = "ADDE")]
    #[cfg_attr(feature = "serde", serde(rename = "ADDE"))]
    Adde,
    #[yaserde(rename = "AMDT")]
    #[cfg_attr(feature = "serde", serde(rename = "AMDT"))]
    Amdt,
    #[yaserde(rename = "AUTH")]
    #[cfg_attr(feature = "serde", serde(rename = "AUTH"))]
    Auth,
    #[yaserde(rename = "CMGT")]
    #[cfg_attr(feature = "serde", serde(rename = "CMGT"))]
    Cmgt,
    #[yaserde(rename = "CBCK")]
    #[cfg_attr(feature = "serde", serde(rename = "CBCK"))]
    Cbck,
    #[yaserde(rename = "FEEC")]
    #[cfg_attr(feature = "serde", serde(rename = "FEEC"))]
    Feec,
    #[yaserde(rename = "FINL")]
    #[cfg_attr(feature = "serde", serde(rename = "FINL"))]
    Finl,
    #[yaserde(rename = "INQY")]
    #[cfg_attr(feature = "serde", serde(rename = "INQY"))]
    Inqy,
    #[yaserde(rename = "VERI")]
    #[cfg_attr(feature = "serde", serde(rename = "VERI"))]
    Veri,
    __Unknown__(String),
}

impl Default for MessageClass1Code {
    fn default() -> MessageClass1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for MessageClass1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum MessageFunction16Code {
    #[yaserde(rename = "ADVC")]
    #[cfg_attr(feature = "serde", serde(rename = "ADVC"))]
    Advc,
    #[yaserde(rename = "NOTI")]
    #[cfg_attr(feature = "serde", serde(rename = "NOTI"))]
    Noti,
    #[yaserde(rename = "CAAD")]
    #[cfg_attr(feature = "serde", serde(rename = "CAAD"))]
    Caad,
    #[yaserde(rename = "CANO")]
    #[cfg_attr(feature = "serde", serde(rename = "CANO"))]
    Cano,
    #[yaserde(rename = "REQU")]
    #[cfg_attr(feature = "serde", serde(rename = "REQU"))]
    Requ,
    __Unknown__(String),
}

impl Default for MessageFunction16Code {
    fn default() -> MessageFunction16Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for MessageFunction16Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Min2Max3AlphaText (pub String);
crate::simple_type!(Min2Max3AlphaText);

impl Validate for Min2Max3AlphaText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Min2Max3NumericText (pub String);
crate::simple_type!(Min2Max3NumericText);

impl Validate for Min2Max3NumericText {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Min5Max16Binary (pub String);
crate::simple_type!(Min5Max16Binary);

impl Validate for Min5Max16Binary {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 5 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 5 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 16 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 16 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct Number (pub String);
crate::simple_type!(Number);

impl Validate for Number {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum OfficialDocumentType1Code {
    #[yaserde(rename = "ARNU")]
    #[cfg_attr(feature = "serde", serde(rename = "ARNU"))]
    Arnu,
    #[yaserde(rename = "AUTH")]
    #[cfg_attr(feature = "serde", serde(rename = "AUTH"))]
    Auth,
    #[yaserde(rename = "DIPL")]
    #[cfg_attr(feature = "serde", serde(rename = "DIPL"))]
    Dipl,
    #[yaserde(rename = "DVLC")]
    #[cfg_attr(feature = "serde", serde(rename = "DVLC"))]
    Dvlc,
    #[yaserde(rename = "EURO")]
    #[cfg_attr(feature = "serde", serde(rename = "EURO"))]
    Euro,
    #[yaserde(rename = "IDEN")]
    #[cfg_attr(feature = "serde", serde(rename = "IDEN"))]
    Iden,
    #[yaserde(rename = "INTE")]
    #[cfg_attr(feature = "serde", serde(rename = "INTE"))]
    Inte,
    #[yaserde(rename = "INPO")]
    #[cfg_attr(feature = "serde", serde(rename = "INPO"))]
    Inpo,
    #[yaserde(rename = "LZPR")]
    #[cfg_attr(feature = "serde", serde(rename = "LZPR"))]
    Lzpr,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "PASS")]
    #[cfg_attr(feature = "serde", serde(rename = "PASS"))]
    Pass,
    #[yaserde(rename = "VISA")]
    #[cfg_attr(feature = "serde", serde(rename = "VISA"))]
    Visa,
    #[yaserde(rename = "PERM")]
    #[cfg_attr(feature = "serde", serde(rename = "PERM"))]
    Perm,
    #[yaserde(rename = "REFU")]
    #[cfg_attr(feature = "serde", serde(rename = "REFU"))]
    Refu,
    __Unknown__(String),
}

impl Default for OfficialDocumentType1Code {
    fn default() -> OfficialDocumentType1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for OfficialDocumentType1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct OnBoardDiagnostics1 {
    #[yaserde(rename = "NgnIdleTm")]
    #[cfg_attr(feature = "serde", serde(rename = "NgnIdleTm"))]
    pub ngn_idle_tm: Max10NumberFraction2,

    #[yaserde(rename = "NgnTtlIdleTm")]
    #[cfg_attr(feature = "serde", serde(rename = "NgnTtlIdleTm"))]
    pub ngn_ttl_idle_tm: Max10NumberFraction2,

    #[yaserde(rename = "NgnHrs")]
    #[cfg_attr(feature = "serde", serde(rename = "NgnHrs"))]
    pub ngn_hrs: Max10NumberFraction2,

    #[yaserde(rename = "NgnTtlTm")]
    #[cfg_attr(feature = "serde", serde(rename = "NgnTtlTm"))]
    pub ngn_ttl_tm: Max6NumberFraction2,

    #[yaserde(rename = "NgnLd")]
    #[cfg_attr(feature = "serde", serde(rename = "NgnLd"))]
    pub ngn_ld: Max12NumericText,

    #[yaserde(rename = "NgnRPM")]
    #[cfg_attr(feature = "serde", serde(rename = "NgnRPM"))]
    pub ngn_rpm: Max5NumericText,

    #[yaserde(rename = "NgnOilTmprtr")]
    #[cfg_attr(feature = "serde", serde(rename = "NgnOilTmprtr"))]
    pub ngn_oil_tmprtr: Max6NumberFraction2,

    #[yaserde(rename = "NgnOilPrssr")]
    #[cfg_attr(feature = "serde", serde(rename = "NgnOilPrssr"))]
    pub ngn_oil_prssr: Max3NumericText,

    #[yaserde(rename = "NgnOilLifeRmng")]
    #[cfg_attr(feature = "serde", serde(rename = "NgnOilLifeRmng"))]
    pub ngn_oil_life_rmng: Max3NumericText,

    #[yaserde(rename = "ChckNgnWrngSts")]
    #[cfg_attr(feature = "serde", serde(rename = "ChckNgnWrngSts"))]
    pub chck_ngn_wrng_sts: Max35Text,

    #[yaserde(rename = "FuelTankLvlStart")]
    #[cfg_attr(feature = "serde", serde(rename = "FuelTankLvlStart"))]
    pub fuel_tank_lvl_start: Max4NumericText,

    #[yaserde(rename = "FuelGaugeLvl")]
    #[cfg_attr(feature = "serde", serde(rename = "FuelGaugeLvl"))]
    pub fuel_gauge_lvl: Max4NumericText,

    #[yaserde(rename = "FuelEcnmy")]
    #[cfg_attr(feature = "serde", serde(rename = "FuelEcnmy"))]
    pub fuel_ecnmy: Max6NumberFraction2,

    #[yaserde(rename = "RfrgrtnHrs")]
    #[cfg_attr(feature = "serde", serde(rename = "RfrgrtnHrs"))]
    pub rfrgrtn_hrs: Max10NumberFraction2,

    #[yaserde(rename = "RfrgrtnTmprtr")]
    #[cfg_attr(feature = "serde", serde(rename = "RfrgrtnTmprtr"))]
    pub rfrgrtn_tmprtr: Max6NumberFraction2,

    #[yaserde(rename = "CoolntTmprtr")]
    #[cfg_attr(feature = "serde", serde(rename = "CoolntTmprtr"))]
    pub coolnt_tmprtr: Max6NumberFraction2,

    #[yaserde(rename = "BttryVltg")]
    #[cfg_attr(feature = "serde", serde(rename = "BttryVltg"))]
    pub bttry_vltg: Max4NumericText,

    #[yaserde(rename = "HardBrakg")]
    #[cfg_attr(feature = "serde", serde(rename = "HardBrakg"))]
    pub hard_brakg: Max4NumericText,

    #[yaserde(rename = "HardAcclrtn")]
    #[cfg_attr(feature = "serde", serde(rename = "HardAcclrtn"))]
    pub hard_acclrtn: Max4NumericText,
}

impl Validate for OnBoardDiagnostics1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum OnLineCapability2Code {
    #[yaserde(rename = "OFLN")]
    #[cfg_attr(feature = "serde", serde(rename = "OFLN"))]
    Ofln,
    #[yaserde(rename = "ONLN")]
    #[cfg_attr(feature = "serde", serde(rename = "ONLN"))]
    Onln,
    #[yaserde(rename = "BOTH")]
    #[cfg_attr(feature = "serde", serde(rename = "BOTH"))]
    Both,
    __Unknown__(String),
}

impl Default for OnLineCapability2Code {
    fn default() -> OnLineCapability2Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for OnLineCapability2Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct OriginalDataElements1 {
    #[yaserde(rename = "MsgClss")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgClss"))]
    pub msg_clss: MessageClass1Code,

    #[yaserde(rename = "TxTp")]
    #[cfg_attr(feature = "serde", serde(rename = "TxTp"))]
    pub tx_tp: Exact2AlphaNumericText,

    #[yaserde(rename = "AcqrrId")]
    #[cfg_attr(feature = "serde", serde(rename = "AcqrrId"))]
    pub acqrr_id: Max11NumericText,

    #[yaserde(rename = "SndrId")]
    #[cfg_attr(feature = "serde", serde(rename = "SndrId"))]
    pub sndr_id: Max11NumericText,

    #[yaserde(rename = "LclDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "LclDtTm"))]
    pub lcl_dt_tm: IsodateTime,

    #[yaserde(rename = "TmZone")]
    #[cfg_attr(feature = "serde", serde(rename = "TmZone"))]
    pub tm_zone: Max70Text,

    #[yaserde(rename = "TxRef")]
    #[cfg_attr(feature = "serde", serde(rename = "TxRef"))]
    pub tx_ref: Max35Text,

    #[yaserde(rename = "TrnsmssnDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "TrnsmssnDtTm"))]
    pub trnsmssn_dt_tm: IsodateTime,

    #[yaserde(rename = "SysTracAudtNb")]
    #[cfg_attr(feature = "serde", serde(rename = "SysTracAudtNb"))]
    pub sys_trac_audt_nb: Max12NumericText,

    #[yaserde(rename = "RtrvlRefNb")]
    #[cfg_attr(feature = "serde", serde(rename = "RtrvlRefNb"))]
    pub rtrvl_ref_nb: Exact12Text,

    #[yaserde(rename = "LifeCyclSpprt")]
    #[cfg_attr(feature = "serde", serde(rename = "LifeCyclSpprt"))]
    pub life_cycl_spprt: LifeCycleSupport1Code,

    #[yaserde(rename = "LifeCyclTracIdData")]
    #[cfg_attr(feature = "serde", serde(rename = "LifeCyclTracIdData"))]
    pub life_cycl_trac_id_data: TransactionLifeCycleIdentification1,

    #[yaserde(rename = "LifeCyclTracIdMssng")]
    #[cfg_attr(feature = "serde", serde(rename = "LifeCyclTracIdMssng"))]
    pub life_cycl_trac_id_mssng: Max70Text,

    #[yaserde(rename = "AcqrrRefData")]
    #[cfg_attr(feature = "serde", serde(rename = "AcqrrRefData"))]
    pub acqrr_ref_data: Max140Text,

    #[yaserde(rename = "AcqrrRefNb")]
    #[cfg_attr(feature = "serde", serde(rename = "AcqrrRefNb"))]
    pub acqrr_ref_nb: Max23NumericText,

    #[yaserde(rename = "CardIssrRefData")]
    #[cfg_attr(feature = "serde", serde(rename = "CardIssrRefData"))]
    pub card_issr_ref_data: Max1000Text,
}

impl Validate for OriginalDataElements1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct OriginalTransactionAmount1 {
    #[yaserde(rename = "AmtQlfr")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtQlfr"))]
    pub amt_qlfr: TypeOfAmount11Code,

    #[yaserde(rename = "TxAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "TxAmt"))]
    pub tx_amt: TransactionAmount1,

    #[yaserde(rename = "CrdhldrBllgAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "CrdhldrBllgAmt"))]
    pub crdhldr_bllg_amt: Amount4,

    #[yaserde(rename = "RcncltnAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "RcncltnAmt"))]
    pub rcncltn_amt: Amount4,
}

impl Validate for OriginalTransactionAmount1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct OriginatorInformation1 {
    #[yaserde(rename = "Cert")]
    #[cfg_attr(feature = "serde", serde(rename = "Cert"))]
    pub cert: Vec<Max5000Binary>,
}

impl Validate for OriginatorInformation1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum OutputFormat1Code {
    #[yaserde(rename = "MREF")]
    #[cfg_attr(feature = "serde", serde(rename = "MREF"))]
    Mref,
    #[yaserde(rename = "TEXT")]
    #[cfg_attr(feature = "serde", serde(rename = "TEXT"))]
    Text,
    #[yaserde(rename = "HTML")]
    #[cfg_attr(feature = "serde", serde(rename = "HTML"))]
    Html,
    __Unknown__(String),
}

impl Default for OutputFormat1Code {
    fn default() -> OutputFormat1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for OutputFormat1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum OutputFormat4Code {
    #[yaserde(rename = "FLNM")]
    #[cfg_attr(feature = "serde", serde(rename = "FLNM"))]
    Flnm,
    #[yaserde(rename = "MREF")]
    #[cfg_attr(feature = "serde", serde(rename = "MREF"))]
    Mref,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "SMSI")]
    #[cfg_attr(feature = "serde", serde(rename = "SMSI"))]
    Smsi,
    #[yaserde(rename = "TEXT")]
    #[cfg_attr(feature = "serde", serde(rename = "TEXT"))]
    Text,
    #[yaserde(rename = "URLI")]
    #[cfg_attr(feature = "serde", serde(rename = "URLI"))]
    Urli,
    #[yaserde(rename = "HTML")]
    #[cfg_attr(feature = "serde", serde(rename = "HTML"))]
    Html,
    __Unknown__(String),
}

impl Default for OutputFormat4Code {
    fn default() -> OutputFormat4Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for OutputFormat4Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct Pindata1 {
    #[yaserde(rename = "Ctrl")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctrl"))]
    pub ctrl: Exact1HexBinaryText,

    #[yaserde(rename = "KeySetIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "KeySetIdr"))]
    pub key_set_idr: Max8NumericText,

    #[yaserde(rename = "DrvdInf")]
    #[cfg_attr(feature = "serde", serde(rename = "DrvdInf"))]
    pub drvd_inf: Max32HexBinaryText,

    #[yaserde(rename = "Algo")]
    #[cfg_attr(feature = "serde", serde(rename = "Algo"))]
    pub algo: Max2NumericText,

    #[yaserde(rename = "KeyLngth")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyLngth"))]
    pub key_lngth: Max4NumericText,

    #[yaserde(rename = "KeyPrtcn")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyPrtcn"))]
    pub key_prtcn: Max2NumericText,

    #[yaserde(rename = "KeyIndx")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyIndx"))]
    pub key_indx: Max5NumericText,

    #[yaserde(rename = "PINBlckFrmt")]
    #[cfg_attr(feature = "serde", serde(rename = "PINBlckFrmt"))]
    pub pin_blck_frmt: Max2NumericText,

    #[yaserde(rename = "NcrptdPINBlck")]
    #[cfg_attr(feature = "serde", serde(rename = "NcrptdPINBlck"))]
    pub ncrptd_pin_blck: Max16HexBinaryText,
}

impl Validate for Pindata1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum PoicommunicationType2Code {
    #[yaserde(rename = "BLTH")]
    #[cfg_attr(feature = "serde", serde(rename = "BLTH"))]
    Blth,
    #[yaserde(rename = "ETHR")]
    #[cfg_attr(feature = "serde", serde(rename = "ETHR"))]
    Ethr,
    #[yaserde(rename = "GPRS")]
    #[cfg_attr(feature = "serde", serde(rename = "GPRS"))]
    Gprs,
    #[yaserde(rename = "GSMF")]
    #[cfg_attr(feature = "serde", serde(rename = "GSMF"))]
    Gsmf,
    #[yaserde(rename = "PSTN")]
    #[cfg_attr(feature = "serde", serde(rename = "PSTN"))]
    Pstn,
    #[yaserde(rename = "RS23")]
    #[cfg_attr(feature = "serde", serde(rename = "RS23"))]
    Rs23,
    #[yaserde(rename = "USBD")]
    #[cfg_attr(feature = "serde", serde(rename = "USBD"))]
    Usbd,
    #[yaserde(rename = "USBH")]
    #[cfg_attr(feature = "serde", serde(rename = "USBH"))]
    Usbh,
    #[yaserde(rename = "WIFI")]
    #[cfg_attr(feature = "serde", serde(rename = "WIFI"))]
    Wifi,
    #[yaserde(rename = "WT2G")]
    #[cfg_attr(feature = "serde", serde(rename = "WT2G"))]
    Wt2G,
    #[yaserde(rename = "WT3G")]
    #[cfg_attr(feature = "serde", serde(rename = "WT3G"))]
    Wt3G,
    #[yaserde(rename = "WT4G")]
    #[cfg_attr(feature = "serde", serde(rename = "WT4G"))]
    Wt4G,
    #[yaserde(rename = "WT5G")]
    #[cfg_attr(feature = "serde", serde(rename = "WT5G"))]
    Wt5G,
    __Unknown__(String),
}

impl Default for PoicommunicationType2Code {
    fn default() -> PoicommunicationType2Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for PoicommunicationType2Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum PoicomponentAssessment1Code {
    #[yaserde(rename = "APPL")]
    #[cfg_attr(feature = "serde", serde(rename = "APPL"))]
    Appl,
    #[yaserde(rename = "CERT")]
    #[cfg_attr(feature = "serde", serde(rename = "CERT"))]
    Cert,
    #[yaserde(rename = "EVAL")]
    #[cfg_attr(feature = "serde", serde(rename = "EVAL"))]
    Eval,
    __Unknown__(String),
}

impl Default for PoicomponentAssessment1Code {
    fn default() -> PoicomponentAssessment1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for PoicomponentAssessment1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum PoicomponentStatus1Code {
    #[yaserde(rename = "WAIT")]
    #[cfg_attr(feature = "serde", serde(rename = "WAIT"))]
    Wait,
    #[yaserde(rename = "OUTD")]
    #[cfg_attr(feature = "serde", serde(rename = "OUTD"))]
    Outd,
    #[yaserde(rename = "OPER")]
    #[cfg_attr(feature = "serde", serde(rename = "OPER"))]
    Oper,
    #[yaserde(rename = "DACT")]
    #[cfg_attr(feature = "serde", serde(rename = "DACT"))]
    Dact,
    __Unknown__(String),
}

impl Default for PoicomponentStatus1Code {
    fn default() -> PoicomponentStatus1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for PoicomponentStatus1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum PoicomponentType5Code {
    #[yaserde(rename = "AQPP")]
    #[cfg_attr(feature = "serde", serde(rename = "AQPP"))]
    Aqpp,
    #[yaserde(rename = "APPR")]
    #[cfg_attr(feature = "serde", serde(rename = "APPR"))]
    Appr,
    #[yaserde(rename = "TLPR")]
    #[cfg_attr(feature = "serde", serde(rename = "TLPR"))]
    Tlpr,
    #[yaserde(rename = "SCPR")]
    #[cfg_attr(feature = "serde", serde(rename = "SCPR"))]
    Scpr,
    #[yaserde(rename = "SERV")]
    #[cfg_attr(feature = "serde", serde(rename = "SERV"))]
    Serv,
    #[yaserde(rename = "TERM")]
    #[cfg_attr(feature = "serde", serde(rename = "TERM"))]
    Term,
    #[yaserde(rename = "DVCE")]
    #[cfg_attr(feature = "serde", serde(rename = "DVCE"))]
    Dvce,
    #[yaserde(rename = "SECM")]
    #[cfg_attr(feature = "serde", serde(rename = "SECM"))]
    Secm,
    #[yaserde(rename = "APLI")]
    #[cfg_attr(feature = "serde", serde(rename = "APLI"))]
    Apli,
    #[yaserde(rename = "EMVK")]
    #[cfg_attr(feature = "serde", serde(rename = "EMVK"))]
    Emvk,
    #[yaserde(rename = "EMVO")]
    #[cfg_attr(feature = "serde", serde(rename = "EMVO"))]
    Emvo,
    #[yaserde(rename = "MDWR")]
    #[cfg_attr(feature = "serde", serde(rename = "MDWR"))]
    Mdwr,
    #[yaserde(rename = "DRVR")]
    #[cfg_attr(feature = "serde", serde(rename = "DRVR"))]
    Drvr,
    #[yaserde(rename = "OPST")]
    #[cfg_attr(feature = "serde", serde(rename = "OPST"))]
    Opst,
    #[yaserde(rename = "MRPR")]
    #[cfg_attr(feature = "serde", serde(rename = "MRPR"))]
    Mrpr,
    #[yaserde(rename = "CRTF")]
    #[cfg_attr(feature = "serde", serde(rename = "CRTF"))]
    Crtf,
    #[yaserde(rename = "TMSP")]
    #[cfg_attr(feature = "serde", serde(rename = "TMSP"))]
    Tmsp,
    #[yaserde(rename = "SACP")]
    #[cfg_attr(feature = "serde", serde(rename = "SACP"))]
    Sacp,
    #[yaserde(rename = "SAPR")]
    #[cfg_attr(feature = "serde", serde(rename = "SAPR"))]
    Sapr,
    __Unknown__(String),
}

impl Default for PoicomponentType5Code {
    fn default() -> PoicomponentType5Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for PoicomponentType5Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct Parameter10 {
    #[yaserde(rename = "NcrptnFrmt")]
    #[cfg_attr(feature = "serde", serde(rename = "NcrptnFrmt"))]
    pub ncrptn_frmt: EncryptionFormat2Code,

    #[yaserde(rename = "DgstAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "DgstAlgo"))]
    pub dgst_algo: Algorithm16Code,

    #[yaserde(rename = "MskGnrtrAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "MskGnrtrAlgo"))]
    pub msk_gnrtr_algo: AlgorithmIdentification18,
}

impl Validate for Parameter10 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct Parameter11 {
    #[yaserde(rename = "DgstAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "DgstAlgo"))]
    pub dgst_algo: Algorithm16Code,

    #[yaserde(rename = "MskGnrtrAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "MskGnrtrAlgo"))]
    pub msk_gnrtr_algo: AlgorithmIdentification12,

    #[yaserde(rename = "SaltLngth")]
    #[cfg_attr(feature = "serde", serde(rename = "SaltLngth"))]
    pub salt_lngth: Number,

    #[yaserde(rename = "TrlrFld")]
    #[cfg_attr(feature = "serde", serde(rename = "TrlrFld"))]
    pub trlr_fld: Number,
}

impl Validate for Parameter11 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct Parameter12 {
    #[yaserde(rename = "NcrptnFrmt")]
    #[cfg_attr(feature = "serde", serde(rename = "NcrptnFrmt"))]
    pub ncrptn_frmt: EncryptionFormat2Code,

    #[yaserde(rename = "InitlstnVctr")]
    #[cfg_attr(feature = "serde", serde(rename = "InitlstnVctr"))]
    pub initlstn_vctr: Max500Binary,

    #[yaserde(rename = "BPddg")]
    #[cfg_attr(feature = "serde", serde(rename = "BPddg"))]
    pub b_pddg: BytePadding1Code,
}

impl Validate for Parameter12 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct Parameter13 {
    #[yaserde(rename = "DgstAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "DgstAlgo"))]
    pub dgst_algo: Algorithm20Code,

    #[yaserde(rename = "MskGnrtrAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "MskGnrtrAlgo"))]
    pub msk_gnrtr_algo: AlgorithmIdentification26,
}

impl Validate for Parameter13 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct Parameter14 {
    #[yaserde(rename = "NcrptnFrmt")]
    #[cfg_attr(feature = "serde", serde(rename = "NcrptnFrmt"))]
    pub ncrptn_frmt: EncryptionFormat3Code,

    #[yaserde(rename = "InitlstnVctr")]
    #[cfg_attr(feature = "serde", serde(rename = "InitlstnVctr"))]
    pub initlstn_vctr: Max500Binary,

    #[yaserde(rename = "BPddg")]
    #[cfg_attr(feature = "serde", serde(rename = "BPddg"))]
    pub b_pddg: BytePadding1Code,
}

impl Validate for Parameter14 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct Parameter5 {
    #[yaserde(rename = "DgstAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "DgstAlgo"))]
    pub dgst_algo: Algorithm11Code,
}

impl Validate for Parameter5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct Parameter7 {
    #[yaserde(rename = "InitlstnVctr")]
    #[cfg_attr(feature = "serde", serde(rename = "InitlstnVctr"))]
    pub initlstn_vctr: Max500Binary,

    #[yaserde(rename = "BPddg")]
    #[cfg_attr(feature = "serde", serde(rename = "BPddg"))]
    pub b_pddg: BytePadding1Code,
}

impl Validate for Parameter7 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct Parameter9 {
    #[yaserde(rename = "DgstAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "DgstAlgo"))]
    pub dgst_algo: Algorithm16Code,
}

impl Validate for Parameter9 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct PartyIdentification197 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

    #[yaserde(rename = "Assgnr")]
    #[cfg_attr(feature = "serde", serde(rename = "Assgnr"))]
    pub assgnr: Max35Text,

    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: Iso3NumericCountryCode,

    #[yaserde(rename = "ShrtNm")]
    #[cfg_attr(feature = "serde", serde(rename = "ShrtNm"))]
    pub shrt_nm: Max35Text,

    #[yaserde(rename = "AddtlId")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlId"))]
    pub addtl_id: Max35Text,
}

impl Validate for PartyIdentification197 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct PartyIdentification200 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: PartyType28Code,

    #[yaserde(rename = "OthrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrTp"))]
    pub othr_tp: Max35Text,

    #[yaserde(rename = "Assgnr")]
    #[cfg_attr(feature = "serde", serde(rename = "Assgnr"))]
    pub assgnr: PartyType18Code,

    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: Iso3NumericCountryCode,

    #[yaserde(rename = "ShrtNm")]
    #[cfg_attr(feature = "serde", serde(rename = "ShrtNm"))]
    pub shrt_nm: Max35Text,
}

impl Validate for PartyIdentification200 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct PartyIdentification203 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

    #[yaserde(rename = "Assgnr")]
    #[cfg_attr(feature = "serde", serde(rename = "Assgnr"))]
    pub assgnr: Max35Text,

    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: Iso3NumericCountryCode,

    #[yaserde(rename = "ShrtNm")]
    #[cfg_attr(feature = "serde", serde(rename = "ShrtNm"))]
    pub shrt_nm: Max35Text,

    #[yaserde(rename = "AddtlId")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlId"))]
    pub addtl_id: Max35Text,

    #[yaserde(rename = "NmAndLctn")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndLctn"))]
    pub nm_and_lctn: Max99Text,

    #[yaserde(rename = "Adr")]
    #[cfg_attr(feature = "serde", serde(rename = "Adr"))]
    pub adr: Address1,

    #[yaserde(rename = "Email")]
    #[cfg_attr(feature = "serde", serde(rename = "Email"))]
    pub email: Max256Text,

    #[yaserde(rename = "URLAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "URLAdr"))]
    pub url_adr: Max256Text,

    #[yaserde(rename = "PhneNb")]
    #[cfg_attr(feature = "serde", serde(rename = "PhneNb"))]
    pub phne_nb: Max35Text,

    #[yaserde(rename = "CstmrSvc")]
    #[cfg_attr(feature = "serde", serde(rename = "CstmrSvc"))]
    pub cstmr_svc: Max35Text,

    #[yaserde(rename = "AddtlCtctInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlCtctInf"))]
    pub addtl_ctct_inf: Max256Text,

    #[yaserde(rename = "TaxRegnId")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxRegnId"))]
    pub tax_regn_id: Max35Text,

    #[yaserde(rename = "AddtlData")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlData"))]
    pub addtl_data: Vec<AdditionalData1>,

    #[yaserde(rename = "SpnsrdMrchnt")]
    #[cfg_attr(feature = "serde", serde(rename = "SpnsrdMrchnt"))]
    pub spnsrd_mrchnt: Vec<SponsoredMerchant1>,
}

impl Validate for PartyIdentification203 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct PartyIdentification206 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max70Text,

    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: PartyIdentification197,

    #[yaserde(rename = "Adr")]
    #[cfg_attr(feature = "serde", serde(rename = "Adr"))]
    pub adr: Address1,

    #[yaserde(rename = "Ctct")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctct"))]
    pub ctct: Contact3,

    #[yaserde(rename = "TaxRegnId")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxRegnId"))]
    pub tax_regn_id: Max70Text,

    #[yaserde(rename = "AddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
    pub addtl_inf: Max1000Text,
}

impl Validate for PartyIdentification206 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct PartyIdentification207 {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Max35Text,

    #[yaserde(rename = "Assgnr")]
    #[cfg_attr(feature = "serde", serde(rename = "Assgnr"))]
    pub assgnr: Max35Text,

    #[yaserde(rename = "IATACd")]
    #[cfg_attr(feature = "serde", serde(rename = "IATACd"))]
    pub iata_cd: Max35Text,

    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max70Text,

    #[yaserde(rename = "ShrtNm")]
    #[cfg_attr(feature = "serde", serde(rename = "ShrtNm"))]
    pub shrt_nm: Max35Text,

    #[yaserde(rename = "Adr")]
    #[cfg_attr(feature = "serde", serde(rename = "Adr"))]
    pub adr: Address1,

    #[yaserde(rename = "Ctct")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctct"))]
    pub ctct: Contact6,
}

impl Validate for PartyIdentification207 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct PartyIdentification208 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: Max4Text,

    #[yaserde(rename = "OthrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrTp"))]
    pub othr_tp: Max35Text,

    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max70Text,

    #[yaserde(rename = "Assgnr")]
    #[cfg_attr(feature = "serde", serde(rename = "Assgnr"))]
    pub assgnr: Max35Text,
}

impl Validate for PartyIdentification208 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct PartyIdentification209 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max70Text,

    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: PartyIdentification197,

    #[yaserde(rename = "Adr")]
    #[cfg_attr(feature = "serde", serde(rename = "Adr"))]
    pub adr: Address1,

    #[yaserde(rename = "Ctct")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctct"))]
    pub ctct: Contact6,

    #[yaserde(rename = "Instrs")]
    #[cfg_attr(feature = "serde", serde(rename = "Instrs"))]
    pub instrs: Max350Text,
}

impl Validate for PartyIdentification209 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct PartyIdentification210 {
    #[yaserde(rename = "PrsnlId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrsnlId"))]
    pub prsnl_id: Max35Text,

    #[yaserde(rename = "MplyeeId")]
    #[cfg_attr(feature = "serde", serde(rename = "MplyeeId"))]
    pub mplyee_id: PhoneNumber,

    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max70Text,

    #[yaserde(rename = "PrfssnlLvl")]
    #[cfg_attr(feature = "serde", serde(rename = "PrfssnlLvl"))]
    pub prfssnl_lvl: Max35Text,
}

impl Validate for PartyIdentification210 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct PartyIdentification211 {
    #[yaserde(rename = "FI")]
    #[cfg_attr(feature = "serde", serde(rename = "FI"))]
    pub fi: FinancialInstitution4,

    #[yaserde(rename = "Cstmr")]
    #[cfg_attr(feature = "serde", serde(rename = "Cstmr"))]
    pub cstmr: Customer3,
}

impl Validate for PartyIdentification211 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum PartyType17Code {
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "ACQR")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
    Acqr,
    #[yaserde(rename = "ACQP")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQP"))]
    Acqp,
    #[yaserde(rename = "CISS")]
    #[cfg_attr(feature = "serde", serde(rename = "CISS"))]
    Ciss,
    #[yaserde(rename = "CISP")]
    #[cfg_attr(feature = "serde", serde(rename = "CISP"))]
    Cisp,
    #[yaserde(rename = "AGNT")]
    #[cfg_attr(feature = "serde", serde(rename = "AGNT"))]
    Agnt,
    __Unknown__(String),
}

impl Default for PartyType17Code {
    fn default() -> PartyType17Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for PartyType17Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum PartyType18Code {
    #[yaserde(rename = "ACQR")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
    Acqr,
    #[yaserde(rename = "CISS")]
    #[cfg_attr(feature = "serde", serde(rename = "CISS"))]
    Ciss,
    #[yaserde(rename = "CSCH")]
    #[cfg_attr(feature = "serde", serde(rename = "CSCH"))]
    Csch,
    #[yaserde(rename = "AGNT")]
    #[cfg_attr(feature = "serde", serde(rename = "AGNT"))]
    Agnt,
    __Unknown__(String),
}

impl Default for PartyType18Code {
    fn default() -> PartyType18Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for PartyType18Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum PartyType20Code {
    #[yaserde(rename = "ACCP")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCP"))]
    Accp,
    #[yaserde(rename = "ACQR")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
    Acqr,
    #[yaserde(rename = "CRDH")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDH"))]
    Crdh,
    #[yaserde(rename = "CISS")]
    #[cfg_attr(feature = "serde", serde(rename = "CISS"))]
    Ciss,
    #[yaserde(rename = "AGNT")]
    #[cfg_attr(feature = "serde", serde(rename = "AGNT"))]
    Agnt,
    __Unknown__(String),
}

impl Default for PartyType20Code {
    fn default() -> PartyType20Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for PartyType20Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum PartyType21Code {
    #[yaserde(rename = "ACCP")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCP"))]
    Accp,
    #[yaserde(rename = "CRDH")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDH"))]
    Crdh,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    __Unknown__(String),
}

impl Default for PartyType21Code {
    fn default() -> PartyType21Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for PartyType21Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum PartyType22Code {
    #[yaserde(rename = "CRDH")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDH"))]
    Crdh,
    #[yaserde(rename = "MERC")]
    #[cfg_attr(feature = "serde", serde(rename = "MERC"))]
    Merc,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "AGNT")]
    #[cfg_attr(feature = "serde", serde(rename = "AGNT"))]
    Agnt,
    __Unknown__(String),
}

impl Default for PartyType22Code {
    fn default() -> PartyType22Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for PartyType22Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum PartyType26Code {
    #[yaserde(rename = "ACCP")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCP"))]
    Accp,
    #[yaserde(rename = "ACQR")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
    Acqr,
    #[yaserde(rename = "ICCA")]
    #[cfg_attr(feature = "serde", serde(rename = "ICCA"))]
    Icca,
    #[yaserde(rename = "CISS")]
    #[cfg_attr(feature = "serde", serde(rename = "CISS"))]
    Ciss,
    #[yaserde(rename = "DLIS")]
    #[cfg_attr(feature = "serde", serde(rename = "DLIS"))]
    Dlis,
    #[yaserde(rename = "AGNT")]
    #[cfg_attr(feature = "serde", serde(rename = "AGNT"))]
    Agnt,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    __Unknown__(String),
}

impl Default for PartyType26Code {
    fn default() -> PartyType26Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for PartyType26Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum PartyType28Code {
    #[yaserde(rename = "ACCP")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCP"))]
    Accp,
    #[yaserde(rename = "ACQR")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
    Acqr,
    #[yaserde(rename = "AGNT")]
    #[cfg_attr(feature = "serde", serde(rename = "AGNT"))]
    Agnt,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "WLPR")]
    #[cfg_attr(feature = "serde", serde(rename = "WLPR"))]
    Wlpr,
    #[yaserde(rename = "ISUR")]
    #[cfg_attr(feature = "serde", serde(rename = "ISUR"))]
    Isur,
    __Unknown__(String),
}

impl Default for PartyType28Code {
    fn default() -> PartyType28Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for PartyType28Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum PartyType32Code {
    #[yaserde(rename = "ACQR")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
    Acqr,
    #[yaserde(rename = "AGNT")]
    #[cfg_attr(feature = "serde", serde(rename = "AGNT"))]
    Agnt,
    #[yaserde(rename = "ISUR")]
    #[cfg_attr(feature = "serde", serde(rename = "ISUR"))]
    Isur,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    __Unknown__(String),
}

impl Default for PartyType32Code {
    fn default() -> PartyType32Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for PartyType32Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum PartyType7Code {
    #[yaserde(rename = "ACQR")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
    Acqr,
    #[yaserde(rename = "ITAG")]
    #[cfg_attr(feature = "serde", serde(rename = "ITAG"))]
    Itag,
    #[yaserde(rename = "PCPT")]
    #[cfg_attr(feature = "serde", serde(rename = "PCPT"))]
    Pcpt,
    #[yaserde(rename = "TMGT")]
    #[cfg_attr(feature = "serde", serde(rename = "TMGT"))]
    Tmgt,
    #[yaserde(rename = "SALE")]
    #[cfg_attr(feature = "serde", serde(rename = "SALE"))]
    Sale,
    __Unknown__(String),
}

impl Default for PartyType7Code {
    fn default() -> PartyType7Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for PartyType7Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum PartyType9Code {
    #[yaserde(rename = "ACQR")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
    Acqr,
    #[yaserde(rename = "ACQP")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQP"))]
    Acqp,
    #[yaserde(rename = "CISS")]
    #[cfg_attr(feature = "serde", serde(rename = "CISS"))]
    Ciss,
    #[yaserde(rename = "CISP")]
    #[cfg_attr(feature = "serde", serde(rename = "CISP"))]
    Cisp,
    #[yaserde(rename = "CSCH")]
    #[cfg_attr(feature = "serde", serde(rename = "CSCH"))]
    Csch,
    #[yaserde(rename = "SCHP")]
    #[cfg_attr(feature = "serde", serde(rename = "SCHP"))]
    Schp,
    __Unknown__(String),
}

impl Default for PartyType9Code {
    fn default() -> PartyType9Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for PartyType9Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct PassengerTransport1 {
    #[yaserde(rename = "Summry")]
    #[cfg_attr(feature = "serde", serde(rename = "Summry"))]
    pub summry: PassengerTransportSummary1,

    #[yaserde(rename = "TripLeg")]
    #[cfg_attr(feature = "serde", serde(rename = "TripLeg"))]
    pub trip_leg: Vec<TripLeg1>,

    #[yaserde(rename = "AncllryPurchs")]
    #[cfg_attr(feature = "serde", serde(rename = "AncllryPurchs"))]
    pub ancllry_purchs: Vec<AncillaryPurchase1>,

    #[yaserde(rename = "HirdVhclDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "HirdVhclDtls"))]
    pub hird_vhcl_dtls: Vec<HiredVehicle1>,
}

impl Validate for PassengerTransport1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct PassengerTransportSummary1 {
    #[yaserde(rename = "DocNb")]
    #[cfg_attr(feature = "serde", serde(rename = "DocNb"))]
    pub doc_nb: Max35Text,

    #[yaserde(rename = "Rsvatn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rsvatn"))]
    pub rsvatn: ReservationDetails3,

    #[yaserde(rename = "TrvlAuthstnCd")]
    #[cfg_attr(feature = "serde", serde(rename = "TrvlAuthstnCd"))]
    pub trvl_authstn_cd: Max70Text,

    #[yaserde(rename = "TcktIssr")]
    #[cfg_attr(feature = "serde", serde(rename = "TcktIssr"))]
    pub tckt_issr: Max35Text,

    #[yaserde(rename = "OpnTcktInd")]
    #[cfg_attr(feature = "serde", serde(rename = "OpnTcktInd"))]
    pub opn_tckt_ind: TrueFalseIndicator,

    #[yaserde(rename = "CstmrRef")]
    #[cfg_attr(feature = "serde", serde(rename = "CstmrRef"))]
    pub cstmr_ref: Vec<CustomerReference1>,

    #[yaserde(rename = "Pssngr")]
    #[cfg_attr(feature = "serde", serde(rename = "Pssngr"))]
    pub pssngr: Vec<Customer5>,

    #[yaserde(rename = "Dprture")]
    #[cfg_attr(feature = "serde", serde(rename = "Dprture"))]
    pub dprture: DepartureOrArrival1,

    #[yaserde(rename = "Drtn")]
    #[cfg_attr(feature = "serde", serde(rename = "Drtn"))]
    pub drtn: Max4NumericText,

    #[yaserde(rename = "InsrncInd")]
    #[cfg_attr(feature = "serde", serde(rename = "InsrncInd"))]
    pub insrnc_ind: TrueFalseIndicator,

    #[yaserde(rename = "TtlAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlAmt"))]
    pub ttl_amt: AmountDetails1,

    #[yaserde(rename = "SummryCmmdtyId")]
    #[cfg_attr(feature = "serde", serde(rename = "SummryCmmdtyId"))]
    pub summry_cmmdty_id: Max35Text,

    #[yaserde(rename = "LltyPrgrmm")]
    #[cfg_attr(feature = "serde", serde(rename = "LltyPrgrmm"))]
    pub llty_prgrmm: LoyaltyProgramme2,

    #[yaserde(rename = "AddtlData")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlData"))]
    pub addtl_data: Max350Text,
}

impl Validate for PassengerTransportSummary1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct PaymentTransaction117 {
    #[yaserde(rename = "PurchsTp")]
    #[cfg_attr(feature = "serde", serde(rename = "PurchsTp"))]
    pub purchs_tp: FleetPurchaseType1Code,

    #[yaserde(rename = "SummryCmmdtyId")]
    #[cfg_attr(feature = "serde", serde(rename = "SummryCmmdtyId"))]
    pub summry_cmmdty_id: Max35Text,

    #[yaserde(rename = "DscntTtl")]
    #[cfg_attr(feature = "serde", serde(rename = "DscntTtl"))]
    pub dscnt_ttl: FleetDiscountTotals1,

    #[yaserde(rename = "TaxTtl")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxTtl"))]
    pub tax_ttl: Vec<Tax33>,

    #[yaserde(rename = "TtlAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlAmt"))]
    pub ttl_amt: ImpliedCurrencyAndAmount,
}

impl Validate for PaymentTransaction117 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct PercentageRate (pub String);
crate::simple_type!(PercentageRate);

impl Validate for PercentageRate {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum PeriodUnit2Code {
    #[yaserde(rename = "HOUR")]
    #[cfg_attr(feature = "serde", serde(rename = "HOUR"))]
    Hour,
    #[yaserde(rename = "HFDA")]
    #[cfg_attr(feature = "serde", serde(rename = "HFDA"))]
    Hfda,
    #[yaserde(rename = "DAYS")]
    #[cfg_attr(feature = "serde", serde(rename = "DAYS"))]
    Days,
    #[yaserde(rename = "WEEK")]
    #[cfg_attr(feature = "serde", serde(rename = "WEEK"))]
    Week,
    #[yaserde(rename = "MNTH")]
    #[cfg_attr(feature = "serde", serde(rename = "MNTH"))]
    Mnth,
    #[yaserde(rename = "YEAR")]
    #[cfg_attr(feature = "serde", serde(rename = "YEAR"))]
    Year,
    #[yaserde(rename = "MINU")]
    #[cfg_attr(feature = "serde", serde(rename = "MINU"))]
    Minu,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    __Unknown__(String),
}

impl Default for PeriodUnit2Code {
    fn default() -> PeriodUnit2Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for PeriodUnit2Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum PeriodUnit3Code {
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "MNTH")]
    #[cfg_attr(feature = "serde", serde(rename = "MNTH"))]
    Mnth,
    #[yaserde(rename = "WEEK")]
    #[cfg_attr(feature = "serde", serde(rename = "WEEK"))]
    Week,
    #[yaserde(rename = "YEAR")]
    #[cfg_attr(feature = "serde", serde(rename = "YEAR"))]
    Year,
    #[yaserde(rename = "DAYS")]
    #[cfg_attr(feature = "serde", serde(rename = "DAYS"))]
    Days,
    #[yaserde(rename = "EXDY")]
    #[cfg_attr(feature = "serde", serde(rename = "EXDY"))]
    Exdy,
    __Unknown__(String),
}

impl Default for PeriodUnit3Code {
    fn default() -> PeriodUnit3Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for PeriodUnit3Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct PhoneNumber (pub String);
crate::simple_type!(PhoneNumber);

impl Validate for PhoneNumber {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct PlainCardData20 {
    #[yaserde(rename = "DrvrOrVhclId")]
    #[cfg_attr(feature = "serde", serde(rename = "DrvrOrVhclId"))]
    pub drvr_or_vhcl_id: Max20Text,

    #[yaserde(rename = "AddtlCardData")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlCardData"))]
    pub addtl_card_data: Max35Text,
}

impl Validate for PlainCardData20 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct Plan1 {
    #[yaserde(rename = "PlanId")]
    #[cfg_attr(feature = "serde", serde(rename = "PlanId"))]
    pub plan_id: Max35Text,

    #[yaserde(rename = "PlanOwnr")]
    #[cfg_attr(feature = "serde", serde(rename = "PlanOwnr"))]
    pub plan_ownr: PlanOwner1Code,

    #[yaserde(rename = "OthrPlanOwnr")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrPlanOwnr"))]
    pub othr_plan_ownr: Max35Text,

    #[yaserde(rename = "InstlmtPmtTp")]
    #[cfg_attr(feature = "serde", serde(rename = "InstlmtPmtTp"))]
    pub instlmt_pmt_tp: Max35Text,

    #[yaserde(rename = "PrdUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "PrdUnit"))]
    pub prd_unit: Frequency12Code,

    #[yaserde(rename = "NbOfPrds")]
    #[cfg_attr(feature = "serde", serde(rename = "NbOfPrds"))]
    pub nb_of_prds: Number,

    #[yaserde(rename = "IntrstRate")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstRate"))]
    pub intrst_rate: Vec<InterestRateDetails1>,

    #[yaserde(rename = "FrstPmtDt")]
    #[cfg_attr(feature = "serde", serde(rename = "FrstPmtDt"))]
    pub frst_pmt_dt: Isodate,

    #[yaserde(rename = "FrstAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "FrstAmt"))]
    pub frst_amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "SbsqntAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "SbsqntAmt"))]
    pub sbsqnt_amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "TtlNbOfPmts")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlNbOfPmts"))]
    pub ttl_nb_of_pmts: Number,

    #[yaserde(rename = "InstlmtCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "InstlmtCcy"))]
    pub instlmt_ccy: Iso3NumericCurrencyCode,

    #[yaserde(rename = "GracePrd")]
    #[cfg_attr(feature = "serde", serde(rename = "GracePrd"))]
    pub grace_prd: GracePeriod1,

    #[yaserde(rename = "AmtDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtDtls"))]
    pub amt_dtls: Vec<InstalmentAmountDetails1>,

    #[yaserde(rename = "GrdTtlAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "GrdTtlAmt"))]
    pub grd_ttl_amt: ImpliedCurrencyAndAmount,
}

impl Validate for Plan1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum PlanOwner1Code {
    #[yaserde(rename = "ACCP")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCP"))]
    Accp,
    #[yaserde(rename = "ACQR")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
    Acqr,
    #[yaserde(rename = "ISSR")]
    #[cfg_attr(feature = "serde", serde(rename = "ISSR"))]
    Issr,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    __Unknown__(String),
}

impl Default for PlanOwner1Code {
    fn default() -> PlanOwner1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for PlanOwner1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct PlusOrMinusIndicator (pub bool);
crate::simple_type!(PlusOrMinusIndicator);

impl Validate for PlusOrMinusIndicator {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct PointOfInteractionComponent8 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: PoicomponentType5Code,

    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: PointOfInteractionComponentIdentification1,

    #[yaserde(rename = "Sts")]
    #[cfg_attr(feature = "serde", serde(rename = "Sts"))]
    pub sts: PointOfInteractionComponentStatus3,

    #[yaserde(rename = "StdCmplc")]
    #[cfg_attr(feature = "serde", serde(rename = "StdCmplc"))]
    pub std_cmplc: Vec<GenericIdentification48>,

    #[yaserde(rename = "Chrtcs")]
    #[cfg_attr(feature = "serde", serde(rename = "Chrtcs"))]
    pub chrtcs: PointOfInteractionComponentCharacteristics4,

    #[yaserde(rename = "Assmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "Assmnt"))]
    pub assmnt: Vec<PointOfInteractionComponentAssessment1>,
}

impl Validate for PointOfInteractionComponent8 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct PointOfInteractionComponentAssessment1 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: PoicomponentAssessment1Code,

    #[yaserde(rename = "Assgnr")]
    #[cfg_attr(feature = "serde", serde(rename = "Assgnr"))]
    pub assgnr: Vec<Max35Text>,

    #[yaserde(rename = "DlvryDt")]
    #[cfg_attr(feature = "serde", serde(rename = "DlvryDt"))]
    pub dlvry_dt: IsodateTime,

    #[yaserde(rename = "XprtnDt")]
    #[cfg_attr(feature = "serde", serde(rename = "XprtnDt"))]
    pub xprtn_dt: IsodateTime,

    #[yaserde(rename = "Nb")]
    #[cfg_attr(feature = "serde", serde(rename = "Nb"))]
    pub nb: Max35Text,
}

impl Validate for PointOfInteractionComponentAssessment1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct PointOfInteractionComponentCharacteristics4 {
    #[yaserde(rename = "Mmry")]
    #[cfg_attr(feature = "serde", serde(rename = "Mmry"))]
    pub mmry: Vec<MemoryCharacteristics1>,

    #[yaserde(rename = "Com")]
    #[cfg_attr(feature = "serde", serde(rename = "Com"))]
    pub com: Vec<CommunicationCharacteristics3>,

    #[yaserde(rename = "SctyAccsMdls")]
    #[cfg_attr(feature = "serde", serde(rename = "SctyAccsMdls"))]
    pub scty_accs_mdls: Number,

    #[yaserde(rename = "SbcbrIdntyMdls")]
    #[cfg_attr(feature = "serde", serde(rename = "SbcbrIdntyMdls"))]
    pub sbcbr_idnty_mdls: Number,

    #[yaserde(rename = "SctyElmt")]
    #[cfg_attr(feature = "serde", serde(rename = "SctyElmt"))]
    pub scty_elmt: Vec<CryptographicKey13>,
}

impl Validate for PointOfInteractionComponentCharacteristics4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct PointOfInteractionComponentIdentification1 {
    #[yaserde(rename = "ItmNb")]
    #[cfg_attr(feature = "serde", serde(rename = "ItmNb"))]
    pub itm_nb: Max35Text,

    #[yaserde(rename = "PrvdrId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvdrId"))]
    pub prvdr_id: Max35Text,

    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

    #[yaserde(rename = "SrlNb")]
    #[cfg_attr(feature = "serde", serde(rename = "SrlNb"))]
    pub srl_nb: Max35Text,
}

impl Validate for PointOfInteractionComponentIdentification1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct PointOfInteractionComponentStatus3 {
    #[yaserde(rename = "VrsnNb")]
    #[cfg_attr(feature = "serde", serde(rename = "VrsnNb"))]
    pub vrsn_nb: Max256Text,

    #[yaserde(rename = "Sts")]
    #[cfg_attr(feature = "serde", serde(rename = "Sts"))]
    pub sts: PoicomponentStatus1Code,

    #[yaserde(rename = "XpryDt")]
    #[cfg_attr(feature = "serde", serde(rename = "XpryDt"))]
    pub xpry_dt: Isodate,
}

impl Validate for PointOfInteractionComponentStatus3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct PointOfServiceContext1 {
    #[yaserde(rename = "CardPres")]
    #[cfg_attr(feature = "serde", serde(rename = "CardPres"))]
    pub card_pres: TrueFalseIndicator,

    #[yaserde(rename = "CrdhldrPres")]
    #[cfg_attr(feature = "serde", serde(rename = "CrdhldrPres"))]
    pub crdhldr_pres: TrueFalseIndicator,

    #[yaserde(rename = "CrdhldrActvtd")]
    #[cfg_attr(feature = "serde", serde(rename = "CrdhldrActvtd"))]
    pub crdhldr_actvtd: TrueFalseIndicator,

    #[yaserde(rename = "TrnspndrInittd")]
    #[cfg_attr(feature = "serde", serde(rename = "TrnspndrInittd"))]
    pub trnspndr_inittd: TrueFalseIndicator,

    #[yaserde(rename = "AttnddInd")]
    #[cfg_attr(feature = "serde", serde(rename = "AttnddInd"))]
    pub attndd_ind: TrueFalseIndicator,

    #[yaserde(rename = "UattnddLvlCtgy")]
    #[cfg_attr(feature = "serde", serde(rename = "UattnddLvlCtgy"))]
    pub uattndd_lvl_ctgy: Max35NumericText,

    #[yaserde(rename = "EComrcInd")]
    #[cfg_attr(feature = "serde", serde(rename = "EComrcInd"))]
    pub e_comrc_ind: TrueFalseIndicator,

    #[yaserde(rename = "EComrcData")]
    #[cfg_attr(feature = "serde", serde(rename = "EComrcData"))]
    pub e_comrc_data: Vec<EcommerceData1>,

    #[yaserde(rename = "MOTOInd")]
    #[cfg_attr(feature = "serde", serde(rename = "MOTOInd"))]
    pub moto_ind: TrueFalseIndicator,

    #[yaserde(rename = "PrtlApprvlSpprtd")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtlApprvlSpprtd"))]
    pub prtl_apprvl_spprtd: TrueFalseIndicator,

    #[yaserde(rename = "DelydAuthstnInd")]
    #[cfg_attr(feature = "serde", serde(rename = "DelydAuthstnInd"))]
    pub delyd_authstn_ind: TrueFalseIndicator,

    #[yaserde(rename = "SctyChrtcs")]
    #[cfg_attr(feature = "serde", serde(rename = "SctyChrtcs"))]
    pub scty_chrtcs: Vec<SecurityCharacteristics1Code>,

    #[yaserde(rename = "OthrSctyChrtcs")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrSctyChrtcs"))]
    pub othr_scty_chrtcs: Max35Text,

    #[yaserde(rename = "CardDataNtryMd")]
    #[cfg_attr(feature = "serde", serde(rename = "CardDataNtryMd"))]
    pub card_data_ntry_md: CardDataReading7Code,

    #[yaserde(rename = "OthrCardDataNtryMd")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrCardDataNtryMd"))]
    pub othr_card_data_ntry_md: Max35Text,

    #[yaserde(rename = "StorgLctn")]
    #[cfg_attr(feature = "serde", serde(rename = "StorgLctn"))]
    pub storg_lctn: Max35Text,

    #[yaserde(rename = "SpclConds")]
    #[cfg_attr(feature = "serde", serde(rename = "SpclConds"))]
    pub spcl_conds: Vec<SpecialConditions1>,
}

impl Validate for PointOfServiceContext1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum PresentationMedium2Code {
    #[yaserde(rename = "BIOM")]
    #[cfg_attr(feature = "serde", serde(rename = "BIOM"))]
    Biom,
    #[yaserde(rename = "ELEC")]
    #[cfg_attr(feature = "serde", serde(rename = "ELEC"))]
    Elec,
    #[yaserde(rename = "PAPR")]
    #[cfg_attr(feature = "serde", serde(rename = "PAPR"))]
    Papr,
    #[yaserde(rename = "BOTH")]
    #[cfg_attr(feature = "serde", serde(rename = "BOTH"))]
    Both,
    __Unknown__(String),
}

impl Default for PresentationMedium2Code {
    fn default() -> PresentationMedium2Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for PresentationMedium2Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum Priority3Code {
    #[yaserde(rename = "URGT")]
    #[cfg_attr(feature = "serde", serde(rename = "URGT"))]
    Urgt,
    #[yaserde(rename = "HIGH")]
    #[cfg_attr(feature = "serde", serde(rename = "HIGH"))]
    High,
    #[yaserde(rename = "NORM")]
    #[cfg_attr(feature = "serde", serde(rename = "NORM"))]
    Norm,
    __Unknown__(String),
}

impl Default for Priority3Code {
    fn default() -> Priority3Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for Priority3Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct ProcessingResult1 {
    #[yaserde(rename = "ApprvlData")]
    #[cfg_attr(feature = "serde", serde(rename = "ApprvlData"))]
    pub apprvl_data: ApprovalData1,

    #[yaserde(rename = "RsltData")]
    #[cfg_attr(feature = "serde", serde(rename = "RsltData"))]
    pub rslt_data: ResultData1,

    #[yaserde(rename = "OrgnlRsltData")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlRsltData"))]
    pub orgnl_rslt_data: ResultData1,

    #[yaserde(rename = "ActnReqrd")]
    #[cfg_attr(feature = "serde", serde(rename = "ActnReqrd"))]
    pub actn_reqrd: YesNoIndicator,

    #[yaserde(rename = "Actn")]
    #[cfg_attr(feature = "serde", serde(rename = "Actn"))]
    pub actn: Vec<Action9>,

    #[yaserde(rename = "AddtlActn")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlActn"))]
    pub addtl_actn: Vec<AdditionalAction1>,

    #[yaserde(rename = "AddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
    pub addtl_inf: Vec<AdditionalInformation20>,
}

impl Validate for ProcessingResult1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct Product7 {
    #[yaserde(rename = "PdctCd")]
    #[cfg_attr(feature = "serde", serde(rename = "PdctCd"))]
    pub pdct_cd: Max70Text,

    #[yaserde(rename = "SummryCmmdtyId")]
    #[cfg_attr(feature = "serde", serde(rename = "SummryCmmdtyId"))]
    pub summry_cmmdty_id: Max35Text,
}

impl Validate for Product7 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum ProductCodeType1Code {
    #[yaserde(rename = "EA13")]
    #[cfg_attr(feature = "serde", serde(rename = "EA13"))]
    Ea13,
    #[yaserde(rename = "EAN8")]
    #[cfg_attr(feature = "serde", serde(rename = "EAN8"))]
    Ean8,
    #[yaserde(rename = "GTIN")]
    #[cfg_attr(feature = "serde", serde(rename = "GTIN"))]
    Gtin,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "PLUP")]
    #[cfg_attr(feature = "serde", serde(rename = "PLUP"))]
    Plup,
    #[yaserde(rename = "RS14")]
    #[cfg_attr(feature = "serde", serde(rename = "RS14"))]
    Rs14,
    #[yaserde(rename = "UPCA")]
    #[cfg_attr(feature = "serde", serde(rename = "UPCA"))]
    Upca,
    #[yaserde(rename = "UPCE")]
    #[cfg_attr(feature = "serde", serde(rename = "UPCE"))]
    Upce,
    __Unknown__(String),
}

impl Default for ProductCodeType1Code {
    fn default() -> ProductCodeType1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for ProductCodeType1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct ProtectedData1 {
    #[yaserde(rename = "CnttTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CnttTp"))]
    pub cntt_tp: ContentType3Code,

    #[yaserde(rename = "EnvlpdData")]
    #[cfg_attr(feature = "serde", serde(rename = "EnvlpdData"))]
    pub envlpd_data: EnvelopedData6,

    #[yaserde(rename = "NcrptdData")]
    #[cfg_attr(feature = "serde", serde(rename = "NcrptdData"))]
    pub ncrptd_data: EncryptedData1,
}

impl Validate for ProtectedData1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum PurchaseIdentifierType1Code {
    #[yaserde(rename = "CONU")]
    #[cfg_attr(feature = "serde", serde(rename = "CONU"))]
    Conu,
    #[yaserde(rename = "CUOR")]
    #[cfg_attr(feature = "serde", serde(rename = "CUOR"))]
    Cuor,
    #[yaserde(rename = "CUPO")]
    #[cfg_attr(feature = "serde", serde(rename = "CUPO"))]
    Cupo,
    #[yaserde(rename = "FONU")]
    #[cfg_attr(feature = "serde", serde(rename = "FONU"))]
    Fonu,
    #[yaserde(rename = "INNU")]
    #[cfg_attr(feature = "serde", serde(rename = "INNU"))]
    Innu,
    #[yaserde(rename = "ORNU")]
    #[cfg_attr(feature = "serde", serde(rename = "ORNU"))]
    Ornu,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "PRNU")]
    #[cfg_attr(feature = "serde", serde(rename = "PRNU"))]
    Prnu,
    #[yaserde(rename = "PUID")]
    #[cfg_attr(feature = "serde", serde(rename = "PUID"))]
    Puid,
    #[yaserde(rename = "RELO")]
    #[cfg_attr(feature = "serde", serde(rename = "RELO"))]
    Relo,
    #[yaserde(rename = "REAG")]
    #[cfg_attr(feature = "serde", serde(rename = "REAG"))]
    Reag,
    #[yaserde(rename = "RENU")]
    #[cfg_attr(feature = "serde", serde(rename = "RENU"))]
    Renu,
    #[yaserde(rename = "RSNU")]
    #[cfg_attr(feature = "serde", serde(rename = "RSNU"))]
    Rsnu,
    #[yaserde(rename = "SUOR")]
    #[cfg_attr(feature = "serde", serde(rename = "SUOR"))]
    Suor,
    #[yaserde(rename = "TINU")]
    #[cfg_attr(feature = "serde", serde(rename = "TINU"))]
    Tinu,
    #[yaserde(rename = "TRNU")]
    #[cfg_attr(feature = "serde", serde(rename = "TRNU"))]
    Trnu,
    #[yaserde(rename = "SUIN")]
    #[cfg_attr(feature = "serde", serde(rename = "SUIN"))]
    Suin,
    #[yaserde(rename = "TNID")]
    #[cfg_attr(feature = "serde", serde(rename = "TNID"))]
    Tnid,
    __Unknown__(String),
}

impl Default for PurchaseIdentifierType1Code {
    fn default() -> PurchaseIdentifierType1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for PurchaseIdentifierType1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum ReceiptType1Code {
    #[yaserde(rename = "EMAL")]
    #[cfg_attr(feature = "serde", serde(rename = "EMAL"))]
    Emal,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "PAPR")]
    #[cfg_attr(feature = "serde", serde(rename = "PAPR"))]
    Papr,
    #[yaserde(rename = "SMSM")]
    #[cfg_attr(feature = "serde", serde(rename = "SMSM"))]
    Smsm,
    #[yaserde(rename = "URID")]
    #[cfg_attr(feature = "serde", serde(rename = "URID"))]
    Urid,
    __Unknown__(String),
}

impl Default for ReceiptType1Code {
    fn default() -> ReceiptType1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for ReceiptType1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct Recipient5Choice {
    #[yaserde(rename = "IssrAndSrlNb")]
    #[cfg_attr(feature = "serde", serde(rename = "IssrAndSrlNb"))]
    pub issr_and_srl_nb: Option<IssuerAndSerialNumber1>,
    #[yaserde(rename = "KeyIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyIdr"))]
    pub key_idr: Option<Kekidentifier2>,
}

impl Validate for Recipient5Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct Recipient6Choice {
    #[yaserde(rename = "KeyTrnsprt")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyTrnsprt"))]
    pub key_trnsprt: Option<KeyTransport5>,
    #[yaserde(rename = "KEK")]
    #[cfg_attr(feature = "serde", serde(rename = "KEK"))]
    pub kek: Option<Kek5>,
    #[yaserde(rename = "KeyIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyIdr"))]
    pub key_idr: Option<Kekidentifier2>,
}

impl Validate for Recipient6Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct Recipient7Choice {
    #[yaserde(rename = "KeyTrnsprt")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyTrnsprt"))]
    pub key_trnsprt: Option<KeyTransport6>,
    #[yaserde(rename = "KEK")]
    #[cfg_attr(feature = "serde", serde(rename = "KEK"))]
    pub kek: Option<Kek6>,
    #[yaserde(rename = "KeyIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "KeyIdr"))]
    pub key_idr: Option<Kekidentifier6>,
}

impl Validate for Recipient7Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct Reconciliation3 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Isodate,

    #[yaserde(rename = "ChckptRef")]
    #[cfg_attr(feature = "serde", serde(rename = "ChckptRef"))]
    pub chckpt_ref: Max35Text,
}

impl Validate for Reconciliation3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
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:cain.001.001.02")]
pub struct RentalDetails1 {
    #[yaserde(rename = "RntlId")]
    #[cfg_attr(feature = "serde", serde(rename = "RntlId"))]
    pub rntl_id: Max70Text,

    #[yaserde(rename = "RntlDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "RntlDtTm"))]
    pub rntl_dt_tm: IsodateTime,

    #[yaserde(rename = "RntlStart")]
    #[cfg_attr(feature = "serde", serde(rename = "RntlStart"))]
    pub rntl_start: ServiceStartEnd1,

    #[yaserde(rename = "RntlRtr")]
    #[cfg_attr(feature = "serde", serde(rename = "RntlRtr"))]
    pub rntl_rtr: ServiceStartEnd1,

    #[yaserde(rename = "RntlTmPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "RntlTmPrd"))]
    pub rntl_tm_prd: Vec<PeriodUnit2Code>,

    #[yaserde(rename = "TmPrdUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "TmPrdUnit"))]
    pub tm_prd_unit: Max4NumericText,

    #[yaserde(rename = "TmPrdRate")]
    #[cfg_attr(feature = "serde", serde(rename = "TmPrdRate"))]
    pub tm_prd_rate: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "Ccy")]
    #[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
    pub ccy: Iso3NumericCurrencyCode,
}

impl Validate for RentalDetails1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct RentalRate1 {
    #[yaserde(rename = "Prd")]
    #[cfg_attr(feature = "serde", serde(rename = "Prd"))]
    pub prd: PeriodUnit3Code,

    #[yaserde(rename = "OthrPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrPrd"))]
    pub othr_prd: Max35Text,

    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "PrdCnt")]
    #[cfg_attr(feature = "serde", serde(rename = "PrdCnt"))]
    pub prd_cnt: Max4NumericText,
}

impl Validate for RentalRate1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct ReservationDetails3 {
    #[yaserde(rename = "Sys")]
    #[cfg_attr(feature = "serde", serde(rename = "Sys"))]
    pub sys: Max4Text,

    #[yaserde(rename = "RsvatnNb")]
    #[cfg_attr(feature = "serde", serde(rename = "RsvatnNb"))]
    pub rsvatn_nb: Max35Text,

    #[yaserde(rename = "OrgnlSys")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlSys"))]
    pub orgnl_sys: Max4Text,

    #[yaserde(rename = "OrgnlRsvatnNb")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlRsvatnNb"))]
    pub orgnl_rsvatn_nb: Max35Text,
}

impl Validate for ReservationDetails3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum Response8Code {
    #[yaserde(rename = "PRCS")]
    #[cfg_attr(feature = "serde", serde(rename = "PRCS"))]
    Prcs,
    #[yaserde(rename = "UNPR")]
    #[cfg_attr(feature = "serde", serde(rename = "UNPR"))]
    Unpr,
    #[yaserde(rename = "UNRV")]
    #[cfg_attr(feature = "serde", serde(rename = "UNRV"))]
    Unrv,
    #[yaserde(rename = "REJT")]
    #[cfg_attr(feature = "serde", serde(rename = "REJT"))]
    Rejt,
    #[yaserde(rename = "TECH")]
    #[cfg_attr(feature = "serde", serde(rename = "TECH"))]
    Tech,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    __Unknown__(String),
}

impl Default for Response8Code {
    fn default() -> Response8Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for Response8Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct ResultData1 {
    #[yaserde(rename = "Rslt")]
    #[cfg_attr(feature = "serde", serde(rename = "Rslt"))]
    pub rslt: Response8Code,

    #[yaserde(rename = "OthrRslt")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrRslt"))]
    pub othr_rslt: Max35Text,

    #[yaserde(rename = "RsltDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "RsltDtls"))]
    pub rslt_dtls: Exact2AlphaNumericText,

    #[yaserde(rename = "OthrRsltDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrRsltDtls"))]
    pub othr_rslt_dtls: Max35Text,

    #[yaserde(rename = "AddtlRsltInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlRsltInf"))]
    pub addtl_rslt_inf: Vec<AdditionalData1>,
}

impl Validate for ResultData1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct RiskAssessment1 {
    #[yaserde(rename = "RskAssmntNtty")]
    #[cfg_attr(feature = "serde", serde(rename = "RskAssmntNtty"))]
    pub rsk_assmnt_ntty: PartyIdentification200,

    #[yaserde(rename = "RskAssmntTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RskAssmntTp"))]
    pub rsk_assmnt_tp: Max35Text,

    #[yaserde(rename = "Rsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
    pub rsn: Vec<Max35Text>,

    #[yaserde(rename = "Rslt")]
    #[cfg_attr(feature = "serde", serde(rename = "Rslt"))]
    pub rslt: Max35Text,

    #[yaserde(rename = "AddtlRskData")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlRskData"))]
    pub addtl_rsk_data: Vec<AdditionalRiskData1>,

    #[yaserde(rename = "RcmmnddActn")]
    #[cfg_attr(feature = "serde", serde(rename = "RcmmnddActn"))]
    pub rcmmndd_actn: Vec<ActionType8Code>,

    #[yaserde(rename = "OthrRcmmnddActn")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrRcmmnddActn"))]
    pub othr_rcmmndd_actn: Max35Text,

    #[yaserde(rename = "RcmmnddActnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "RcmmnddActnDtls"))]
    pub rcmmndd_actn_dtls: Max256Text,
}

impl Validate for RiskAssessment1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct RiskAssessmentDataEntityProvider1 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: PartyType28Code,

    #[yaserde(rename = "OthrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrTp"))]
    pub othr_tp: Max35Text,
}

impl Validate for RiskAssessmentDataEntityProvider1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct RiskContext1 {
    #[yaserde(rename = "RskInptData")]
    #[cfg_attr(feature = "serde", serde(rename = "RskInptData"))]
    pub rsk_inpt_data: Vec<RiskInputData1>,

    #[yaserde(rename = "RskAssmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "RskAssmnt"))]
    pub rsk_assmnt: Vec<RiskAssessment1>,
}

impl Validate for RiskContext1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct RiskInputData1 {
    #[yaserde(rename = "Ntty")]
    #[cfg_attr(feature = "serde", serde(rename = "Ntty"))]
    pub ntty: RiskAssessmentDataEntityProvider1,

    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: Max35Text,

    #[yaserde(rename = "Val")]
    #[cfg_attr(feature = "serde", serde(rename = "Val"))]
    pub val: Max10KText,
}

impl Validate for RiskInputData1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct Sale1 {
    #[yaserde(rename = "Summry")]
    #[cfg_attr(feature = "serde", serde(rename = "Summry"))]
    pub summry: SaleSummary1,

    #[yaserde(rename = "LineItm")]
    #[cfg_attr(feature = "serde", serde(rename = "LineItm"))]
    pub line_itm: Vec<SaleItem2>,
}

impl Validate for Sale1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct SaleContext7 {
    #[yaserde(rename = "SaleId")]
    #[cfg_attr(feature = "serde", serde(rename = "SaleId"))]
    pub sale_id: Max35Text,

    #[yaserde(rename = "SaleRefId")]
    #[cfg_attr(feature = "serde", serde(rename = "SaleRefId"))]
    pub sale_ref_id: Max35Text,

    #[yaserde(rename = "SaleRefNb")]
    #[cfg_attr(feature = "serde", serde(rename = "SaleRefNb"))]
    pub sale_ref_nb: Max35Text,

    #[yaserde(rename = "GoodsAndSvcsTp")]
    #[cfg_attr(feature = "serde", serde(rename = "GoodsAndSvcsTp"))]
    pub goods_and_svcs_tp: GoodsAndServices1Code,

    #[yaserde(rename = "GoodAndSvcsSubTp")]
    #[cfg_attr(feature = "serde", serde(rename = "GoodAndSvcsSubTp"))]
    pub good_and_svcs_sub_tp: GoodsAndServicesSubType1Code,

    #[yaserde(rename = "GoodAndSvcsOthrSubTp")]
    #[cfg_attr(feature = "serde", serde(rename = "GoodAndSvcsOthrSubTp"))]
    pub good_and_svcs_othr_sub_tp: Max35Text,

    #[yaserde(rename = "SpltPmtInd")]
    #[cfg_attr(feature = "serde", serde(rename = "SpltPmtInd"))]
    pub splt_pmt_ind: TrueFalseIndicator,

    #[yaserde(rename = "RctReqInd")]
    #[cfg_attr(feature = "serde", serde(rename = "RctReqInd"))]
    pub rct_req_ind: TrueFalseIndicator,

    #[yaserde(rename = "RctTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RctTp"))]
    pub rct_tp: Vec<ReceiptType1Code>,

    #[yaserde(rename = "RctDstn")]
    #[cfg_attr(feature = "serde", serde(rename = "RctDstn"))]
    pub rct_dstn: Max70Text,
}

impl Validate for SaleContext7 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct SaleItem2 {
    #[yaserde(rename = "PdctTp")]
    #[cfg_attr(feature = "serde", serde(rename = "PdctTp"))]
    pub pdct_tp: Max35Text,

    #[yaserde(rename = "PdctCd")]
    #[cfg_attr(feature = "serde", serde(rename = "PdctCd"))]
    pub pdct_cd: Max70Text,

    #[yaserde(rename = "PdctCdTp")]
    #[cfg_attr(feature = "serde", serde(rename = "PdctCdTp"))]
    pub pdct_cd_tp: ProductCodeType1Code,

    #[yaserde(rename = "AddtlPdctCd")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlPdctCd"))]
    pub addtl_pdct_cd: Max70Text,

    #[yaserde(rename = "AddtlPdctCdTp")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlPdctCdTp"))]
    pub addtl_pdct_cd_tp: Max35Text,

    #[yaserde(rename = "PdctCdModfr")]
    #[cfg_attr(feature = "serde", serde(rename = "PdctCdModfr"))]
    pub pdct_cd_modfr: DecimalNumber,

    #[yaserde(rename = "PdctDesc")]
    #[cfg_attr(feature = "serde", serde(rename = "PdctDesc"))]
    pub pdct_desc: Max140Text,

    #[yaserde(rename = "UnitOfMeasr")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitOfMeasr"))]
    pub unit_of_measr: UnitOfMeasure1Code,

    #[yaserde(rename = "OthrUnitOfMeasr")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrUnitOfMeasr"))]
    pub othr_unit_of_measr: Max35Text,

    #[yaserde(rename = "PdctQty")]
    #[cfg_attr(feature = "serde", serde(rename = "PdctQty"))]
    pub pdct_qty: DecimalNumber,

    #[yaserde(rename = "NonAdjstdUnitPric")]
    #[cfg_attr(feature = "serde", serde(rename = "NonAdjstdUnitPric"))]
    pub non_adjstd_unit_pric: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "NonAdjstdTtlAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "NonAdjstdTtlAmt"))]
    pub non_adjstd_ttl_amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "Adjstmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "Adjstmnt"))]
    pub adjstmnt: Vec<Adjustment10>,

    #[yaserde(rename = "AdjstdAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "AdjstdAmt"))]
    pub adjstd_amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "InsrncInd")]
    #[cfg_attr(feature = "serde", serde(rename = "InsrncInd"))]
    pub insrnc_ind: TrueFalseIndicator,

    #[yaserde(rename = "InsrncAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "InsrncAmt"))]
    pub insrnc_amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "Tax")]
    #[cfg_attr(feature = "serde", serde(rename = "Tax"))]
    pub tax: Vec<Tax33>,

    #[yaserde(rename = "TtlAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlAmt"))]
    pub ttl_amt: ImpliedCurrencyAndAmount,
}

impl Validate for SaleItem2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct SaleSummary1 {
    #[yaserde(rename = "SummryCmmdtyId")]
    #[cfg_attr(feature = "serde", serde(rename = "SummryCmmdtyId"))]
    pub summry_cmmdty_id: Max35Text,

    #[yaserde(rename = "LltyPrgrmm")]
    #[cfg_attr(feature = "serde", serde(rename = "LltyPrgrmm"))]
    pub llty_prgrmm: LoyaltyProgramme2,

    #[yaserde(rename = "Adjstmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "Adjstmnt"))]
    pub adjstmnt: Vec<Adjustment9>,
}

impl Validate for SaleSummary1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum SecurityCharacteristics1Code {
    #[yaserde(rename = "CETE")]
    #[cfg_attr(feature = "serde", serde(rename = "CETE"))]
    Cete,
    #[yaserde(rename = "CPTE")]
    #[cfg_attr(feature = "serde", serde(rename = "CPTE"))]
    Cpte,
    #[yaserde(rename = "CENC")]
    #[cfg_attr(feature = "serde", serde(rename = "CENC"))]
    Cenc,
    #[yaserde(rename = "CMAC")]
    #[cfg_attr(feature = "serde", serde(rename = "CMAC"))]
    Cmac,
    #[yaserde(rename = "ETEE")]
    #[cfg_attr(feature = "serde", serde(rename = "ETEE"))]
    Etee,
    #[yaserde(rename = "METE")]
    #[cfg_attr(feature = "serde", serde(rename = "METE"))]
    Mete,
    #[yaserde(rename = "MPTE")]
    #[cfg_attr(feature = "serde", serde(rename = "MPTE"))]
    Mpte,
    #[yaserde(rename = "OPNN")]
    #[cfg_attr(feature = "serde", serde(rename = "OPNN"))]
    Opnn,
    #[yaserde(rename = "PMAC")]
    #[cfg_attr(feature = "serde", serde(rename = "PMAC"))]
    Pmac,
    #[yaserde(rename = "PKIE")]
    #[cfg_attr(feature = "serde", serde(rename = "PKIE"))]
    Pkie,
    #[yaserde(rename = "PRAE")]
    #[cfg_attr(feature = "serde", serde(rename = "PRAE"))]
    Prae,
    #[yaserde(rename = "PRAM")]
    #[cfg_attr(feature = "serde", serde(rename = "PRAM"))]
    Pram,
    #[yaserde(rename = "PRVN")]
    #[cfg_attr(feature = "serde", serde(rename = "PRVN"))]
    Prvn,
    #[yaserde(rename = "STAM")]
    #[cfg_attr(feature = "serde", serde(rename = "STAM"))]
    Stam,
    #[yaserde(rename = "APTE")]
    #[cfg_attr(feature = "serde", serde(rename = "APTE"))]
    Apte,
    #[yaserde(rename = "AETE")]
    #[cfg_attr(feature = "serde", serde(rename = "AETE"))]
    Aete,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    __Unknown__(String),
}

impl Default for SecurityCharacteristics1Code {
    fn default() -> SecurityCharacteristics1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for SecurityCharacteristics1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct ServiceStartEnd1 {
    #[yaserde(rename = "Lctn")]
    #[cfg_attr(feature = "serde", serde(rename = "Lctn"))]
    pub lctn: Max35Text,

    #[yaserde(rename = "LctnCd")]
    #[cfg_attr(feature = "serde", serde(rename = "LctnCd"))]
    pub lctn_cd: Max35Text,

    #[yaserde(rename = "Adr")]
    #[cfg_attr(feature = "serde", serde(rename = "Adr"))]
    pub adr: Address1,

    #[yaserde(rename = "Ctct")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctct"))]
    pub ctct: Contact2,

    #[yaserde(rename = "DtAndTm")]
    #[cfg_attr(feature = "serde", serde(rename = "DtAndTm"))]
    pub dt_and_tm: IsodateTime,

    #[yaserde(rename = "TmSgmt")]
    #[cfg_attr(feature = "serde", serde(rename = "TmSgmt"))]
    pub tm_sgmt: TimeSegment1Code,

    #[yaserde(rename = "JrnyInf")]
    #[cfg_attr(feature = "serde", serde(rename = "JrnyInf"))]
    pub jrny_inf: JourneyInformation1,
}

impl Validate for ServiceStartEnd1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct SettlementReportingEntity1 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: Max35Text,

    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,
}

impl Validate for SettlementReportingEntity1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct SettlementService1 {
    #[yaserde(rename = "SttlmSvcPropsd")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmSvcPropsd"))]
    pub sttlm_svc_propsd: SettlementServiceMode1,

    #[yaserde(rename = "SttlmSvcApld")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmSvcApld"))]
    pub sttlm_svc_apld: SettlementServiceMode1,

    #[yaserde(rename = "SttlmSvcDts")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmSvcDts"))]
    pub sttlm_svc_dts: SettlementServiceDate1,

    #[yaserde(rename = "SttlmRptgNtty")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmRptgNtty"))]
    pub sttlm_rptg_ntty: SettlementReportingEntity1,
}

impl Validate for SettlementService1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct SettlementServiceDate1 {
    #[yaserde(rename = "ReqdSttlmDt")]
    #[cfg_attr(feature = "serde", serde(rename = "ReqdSttlmDt"))]
    pub reqd_sttlm_dt: Isodate,

    #[yaserde(rename = "SttlmDt")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmDt"))]
    pub sttlm_dt: Isodate,

    #[yaserde(rename = "SttlmTm")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmTm"))]
    pub sttlm_tm: Isotime,

    #[yaserde(rename = "SttlmPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmPrd"))]
    pub sttlm_prd: Max35Text,

    #[yaserde(rename = "SttlmCutOffTm")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmCutOffTm"))]
    pub sttlm_cut_off_tm: IsodateTime,
}

impl Validate for SettlementServiceDate1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct SettlementServiceMode1 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: Max35Text,

    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

    #[yaserde(rename = "ShrtNm")]
    #[cfg_attr(feature = "serde", serde(rename = "ShrtNm"))]
    pub shrt_nm: Max35Text,

    #[yaserde(rename = "SttlmPrty")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmPrty"))]
    pub sttlm_prty: Priority3Code,
}

impl Validate for SettlementServiceMode1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct ShippingData1 {
    #[yaserde(rename = "InvcNb")]
    #[cfg_attr(feature = "serde", serde(rename = "InvcNb"))]
    pub invc_nb: Max70Text,

    #[yaserde(rename = "InvcCreDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "InvcCreDtTm"))]
    pub invc_cre_dt_tm: IsodateTime,

    #[yaserde(rename = "SvcDscrptrCd")]
    #[cfg_attr(feature = "serde", serde(rename = "SvcDscrptrCd"))]
    pub svc_dscrptr_cd: Max40Text,

    #[yaserde(rename = "IncntivAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "IncntivAmt"))]
    pub incntiv_amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "MiscExpnss")]
    #[cfg_attr(feature = "serde", serde(rename = "MiscExpnss"))]
    pub misc_expnss: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "InsrncInd")]
    #[cfg_attr(feature = "serde", serde(rename = "InsrncInd"))]
    pub insrnc_ind: TrueFalseIndicator,

    #[yaserde(rename = "InsrncAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "InsrncAmt"))]
    pub insrnc_amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "NetAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "NetAmt"))]
    pub net_amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "Tax")]
    #[cfg_attr(feature = "serde", serde(rename = "Tax"))]
    pub tax: Vec<Tax33>,

    #[yaserde(rename = "SummryCmmdtyId")]
    #[cfg_attr(feature = "serde", serde(rename = "SummryCmmdtyId"))]
    pub summry_cmmdty_id: Max35Text,

    #[yaserde(rename = "NbOfPackgs")]
    #[cfg_attr(feature = "serde", serde(rename = "NbOfPackgs"))]
    pub nb_of_packgs: Max6NumericText,

    #[yaserde(rename = "Packg")]
    #[cfg_attr(feature = "serde", serde(rename = "Packg"))]
    pub packg: Vec<ShippingPackage1>,

    #[yaserde(rename = "AddtlData")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlData"))]
    pub addtl_data: Max350Text,
}

impl Validate for ShippingData1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct ShippingPackage1 {
    #[yaserde(rename = "TrckgNb")]
    #[cfg_attr(feature = "serde", serde(rename = "TrckgNb"))]
    pub trckg_nb: Max70Text,

    #[yaserde(rename = "Spplr")]
    #[cfg_attr(feature = "serde", serde(rename = "Spplr"))]
    pub spplr: PartyIdentification209,

    #[yaserde(rename = "PckpTm")]
    #[cfg_attr(feature = "serde", serde(rename = "PckpTm"))]
    pub pckp_tm: Isotime,

    #[yaserde(rename = "Dlvry")]
    #[cfg_attr(feature = "serde", serde(rename = "Dlvry"))]
    pub dlvry: DeliveryInformation3,

    #[yaserde(rename = "Wght")]
    #[cfg_attr(feature = "serde", serde(rename = "Wght"))]
    pub wght: UnitOfMeasure1,

    #[yaserde(rename = "Pdct")]
    #[cfg_attr(feature = "serde", serde(rename = "Pdct"))]
    pub pdct: Vec<Product7>,

    #[yaserde(rename = "InsrncInd")]
    #[cfg_attr(feature = "serde", serde(rename = "InsrncInd"))]
    pub insrnc_ind: TrueFalseIndicator,

    #[yaserde(rename = "InsrncAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "InsrncAmt"))]
    pub insrnc_amt: ImpliedCurrencyAndAmount,
}

impl Validate for ShippingPackage1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct SignedData5 {
    #[yaserde(rename = "Vrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Vrsn"))]
    pub vrsn: Number,

    #[yaserde(rename = "DgstAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "DgstAlgo"))]
    pub dgst_algo: Vec<AlgorithmIdentification21>,

    #[yaserde(rename = "NcpsltdCntt")]
    #[cfg_attr(feature = "serde", serde(rename = "NcpsltdCntt"))]
    pub ncpsltd_cntt: EncapsulatedContent3,

    #[yaserde(rename = "Cert")]
    #[cfg_attr(feature = "serde", serde(rename = "Cert"))]
    pub cert: Vec<Max5000Binary>,

    #[yaserde(rename = "Sgnr")]
    #[cfg_attr(feature = "serde", serde(rename = "Sgnr"))]
    pub sgnr: Vec<Signer4>,
}

impl Validate for SignedData5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct Signer4 {
    #[yaserde(rename = "Vrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Vrsn"))]
    pub vrsn: Number,

    #[yaserde(rename = "SgnrId")]
    #[cfg_attr(feature = "serde", serde(rename = "SgnrId"))]
    pub sgnr_id: Recipient5Choice,

    #[yaserde(rename = "DgstAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "DgstAlgo"))]
    pub dgst_algo: AlgorithmIdentification21,

    #[yaserde(rename = "SgndAttrbts")]
    #[cfg_attr(feature = "serde", serde(rename = "SgndAttrbts"))]
    pub sgnd_attrbts: Vec<GenericInformation1>,

    #[yaserde(rename = "SgntrAlgo")]
    #[cfg_attr(feature = "serde", serde(rename = "SgntrAlgo"))]
    pub sgntr_algo: AlgorithmIdentification20,

    #[yaserde(rename = "Sgntr")]
    #[cfg_attr(feature = "serde", serde(rename = "Sgntr"))]
    pub sgntr: Max3000Binary,
}

impl Validate for Signer4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct SpecialConditions1 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

    #[yaserde(rename = "Val")]
    #[cfg_attr(feature = "serde", serde(rename = "Val"))]
    pub val: Max35Text,
}

impl Validate for SpecialConditions1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct SpecialProgrammeDetails1 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max35Text,

    #[yaserde(rename = "Val")]
    #[cfg_attr(feature = "serde", serde(rename = "Val"))]
    pub val: Max35Text,
}

impl Validate for SpecialProgrammeDetails1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct SpecialProgrammeQualification1 {
    #[yaserde(rename = "Prgrmm")]
    #[cfg_attr(feature = "serde", serde(rename = "Prgrmm"))]
    pub prgrmm: Max35Text,

    #[yaserde(rename = "Dtl")]
    #[cfg_attr(feature = "serde", serde(rename = "Dtl"))]
    pub dtl: Vec<SpecialProgrammeDetails1>,
}

impl Validate for SpecialProgrammeQualification1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct SponsoredMerchant1 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: PartyIdentification197,

    #[yaserde(rename = "AddtlId")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlId"))]
    pub addtl_id: Max35Text,

    #[yaserde(rename = "CmonNm")]
    #[cfg_attr(feature = "serde", serde(rename = "CmonNm"))]
    pub cmon_nm: Max140Text,

    #[yaserde(rename = "Adr")]
    #[cfg_attr(feature = "serde", serde(rename = "Adr"))]
    pub adr: Address1,
}

impl Validate for SponsoredMerchant1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct SupplementaryData1 {
    #[yaserde(rename = "PlcAndNm")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcAndNm"))]
    pub plc_and_nm: Max350Text,

    #[yaserde(rename = "Envlp")]
    #[cfg_attr(feature = "serde", serde(rename = "Envlp"))]
    pub envlp: SupplementaryDataEnvelope1,
}

impl Validate for SupplementaryData1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct SupplementaryDataEnvelope1 {}

impl Validate for SupplementaryDataEnvelope1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct Tax33 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: AddendumTaxType1Code,

    #[yaserde(rename = "OthrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrTp"))]
    pub othr_tp: Max35Text,

    #[yaserde(rename = "Desc")]
    #[cfg_attr(feature = "serde", serde(rename = "Desc"))]
    pub desc: Max35Text,

    #[yaserde(rename = "TaxXmptn")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxXmptn"))]
    pub tax_xmptn: TrueFalseIndicator,

    #[yaserde(rename = "TaxXmptRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxXmptRsn"))]
    pub tax_xmpt_rsn: Max35Text,

    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: PercentageRate,
}

impl Validate for Tax33 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum TaxReclaimMethod1Code {
    #[yaserde(rename = "INPP")]
    #[cfg_attr(feature = "serde", serde(rename = "INPP"))]
    Inpp,
    #[yaserde(rename = "INPS")]
    #[cfg_attr(feature = "serde", serde(rename = "INPS"))]
    Inps,
    #[yaserde(rename = "INSU")]
    #[cfg_attr(feature = "serde", serde(rename = "INSU"))]
    Insu,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    __Unknown__(String),
}

impl Default for TaxReclaimMethod1Code {
    fn default() -> TaxReclaimMethod1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for TaxReclaimMethod1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct TelecomCallDetails1 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: TelephonyCallType1Code,

    #[yaserde(rename = "OthrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrTp"))]
    pub othr_tp: Max70Text,

    #[yaserde(rename = "PhneNb")]
    #[cfg_attr(feature = "serde", serde(rename = "PhneNb"))]
    pub phne_nb: PhoneNumber,

    #[yaserde(rename = "City")]
    #[cfg_attr(feature = "serde", serde(rename = "City"))]
    pub city: Max35Text,

    #[yaserde(rename = "Stat")]
    #[cfg_attr(feature = "serde", serde(rename = "Stat"))]
    pub stat: Max16Text,

    #[yaserde(rename = "Prvc")]
    #[cfg_attr(feature = "serde", serde(rename = "Prvc"))]
    pub prvc: Max35Text,

    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: Min2Max3AlphaText,
}

impl Validate for TelecomCallDetails1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct TelecomServices1 {
    #[yaserde(rename = "Summry")]
    #[cfg_attr(feature = "serde", serde(rename = "Summry"))]
    pub summry: TelecomServicesSummary1,

    #[yaserde(rename = "LineItm")]
    #[cfg_attr(feature = "serde", serde(rename = "LineItm"))]
    pub line_itm: Vec<TelecomServicesLineItem1>,
}

impl Validate for TelecomServices1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct TelecomServicesLineItem1 {
    #[yaserde(rename = "StartDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "StartDtTm"))]
    pub start_dt_tm: Isodate,

    #[yaserde(rename = "TmPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "TmPrd"))]
    pub tm_prd: Max35Text,

    #[yaserde(rename = "Drtn")]
    #[cfg_attr(feature = "serde", serde(rename = "Drtn"))]
    pub drtn: Isotime,

    #[yaserde(rename = "CallFr")]
    #[cfg_attr(feature = "serde", serde(rename = "CallFr"))]
    pub call_fr: TelecomCallDetails1,

    #[yaserde(rename = "CallTo")]
    #[cfg_attr(feature = "serde", serde(rename = "CallTo"))]
    pub call_to: TelecomCallDetails1,

    #[yaserde(rename = "Chrg")]
    #[cfg_attr(feature = "serde", serde(rename = "Chrg"))]
    pub chrg: Vec<Amount11>,

    #[yaserde(rename = "TtlTax")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlTax"))]
    pub ttl_tax: Vec<Tax33>,

    #[yaserde(rename = "TtlAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlAmt"))]
    pub ttl_amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "Desc")]
    #[cfg_attr(feature = "serde", serde(rename = "Desc"))]
    pub desc: Max256Text,

    #[yaserde(rename = "AddtlData")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlData"))]
    pub addtl_data: Max350Text,
}

impl Validate for TelecomServicesLineItem1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct TelecomServicesSummary1 {
    #[yaserde(rename = "Cstmr")]
    #[cfg_attr(feature = "serde", serde(rename = "Cstmr"))]
    pub cstmr: Customer6,

    #[yaserde(rename = "BllgStmtPrdStart")]
    #[cfg_attr(feature = "serde", serde(rename = "BllgStmtPrdStart"))]
    pub bllg_stmt_prd_start: Isodate,

    #[yaserde(rename = "BllgStmtPrdEnd")]
    #[cfg_attr(feature = "serde", serde(rename = "BllgStmtPrdEnd"))]
    pub bllg_stmt_prd_end: Isodate,

    #[yaserde(rename = "BllgEvt")]
    #[cfg_attr(feature = "serde", serde(rename = "BllgEvt"))]
    pub bllg_evt: Vec<Amount10>,

    #[yaserde(rename = "TtlTax")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlTax"))]
    pub ttl_tax: Vec<Tax33>,

    #[yaserde(rename = "AddtlData")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlData"))]
    pub addtl_data: Max350Text,
}

impl Validate for TelecomServicesSummary1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum TelephonyCallType1Code {
    #[yaserde(rename = "VCML")]
    #[cfg_attr(feature = "serde", serde(rename = "VCML"))]
    Vcml,
    #[yaserde(rename = "TFPC")]
    #[cfg_attr(feature = "serde", serde(rename = "TFPC"))]
    Tfpc,
    #[yaserde(rename = "PAGE")]
    #[cfg_attr(feature = "serde", serde(rename = "PAGE"))]
    Page,
    #[yaserde(rename = "OGPC")]
    #[cfg_attr(feature = "serde", serde(rename = "OGPC"))]
    Ogpc,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTCL")]
    #[cfg_attr(feature = "serde", serde(rename = "OTCL"))]
    Otcl,
    #[yaserde(rename = "ICPC")]
    #[cfg_attr(feature = "serde", serde(rename = "ICPC"))]
    Icpc,
    __Unknown__(String),
}

impl Default for TelephonyCallType1Code {
    fn default() -> TelephonyCallType1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for TelephonyCallType1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct TemporaryServices1 {
    #[yaserde(rename = "CtrctgCpny")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrctgCpny"))]
    pub ctrctg_cpny: TemporaryServicesCompany1,

    #[yaserde(rename = "TempMplyee")]
    #[cfg_attr(feature = "serde", serde(rename = "TempMplyee"))]
    pub temp_mplyee: PartyIdentification210,

    #[yaserde(rename = "Job")]
    #[cfg_attr(feature = "serde", serde(rename = "Job"))]
    pub job: TemporaryServicesJob1,

    #[yaserde(rename = "FlatRateInd")]
    #[cfg_attr(feature = "serde", serde(rename = "FlatRateInd"))]
    pub flat_rate_ind: TrueFalseIndicator,

    #[yaserde(rename = "DscntAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "DscntAmt"))]
    pub dscnt_amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "SummryCmmdtyId")]
    #[cfg_attr(feature = "serde", serde(rename = "SummryCmmdtyId"))]
    pub summry_cmmdty_id: Max35Text,

    #[yaserde(rename = "Labr")]
    #[cfg_attr(feature = "serde", serde(rename = "Labr"))]
    pub labr: TemporaryServicesLabor1,

    #[yaserde(rename = "MiscExpnss")]
    #[cfg_attr(feature = "serde", serde(rename = "MiscExpnss"))]
    pub misc_expnss: Vec<Amount13>,

    #[yaserde(rename = "SbttlAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "SbttlAmt"))]
    pub sbttl_amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "Tax")]
    #[cfg_attr(feature = "serde", serde(rename = "Tax"))]
    pub tax: Vec<Tax33>,

    #[yaserde(rename = "AddtlData")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlData"))]
    pub addtl_data: Max350Text,
}

impl Validate for TemporaryServices1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum TemporaryServicesCharge1Code {
    #[yaserde(rename = "WKND")]
    #[cfg_attr(feature = "serde", serde(rename = "WKND"))]
    Wknd,
    #[yaserde(rename = "REGL")]
    #[cfg_attr(feature = "serde", serde(rename = "REGL"))]
    Regl,
    #[yaserde(rename = "OVRT")]
    #[cfg_attr(feature = "serde", serde(rename = "OVRT"))]
    Ovrt,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "ONCL")]
    #[cfg_attr(feature = "serde", serde(rename = "ONCL"))]
    Oncl,
    #[yaserde(rename = "NITE")]
    #[cfg_attr(feature = "serde", serde(rename = "NITE"))]
    Nite,
    #[yaserde(rename = "HOLI")]
    #[cfg_attr(feature = "serde", serde(rename = "HOLI"))]
    Holi,
    #[yaserde(rename = "HAZD")]
    #[cfg_attr(feature = "serde", serde(rename = "HAZD"))]
    Hazd,
    __Unknown__(String),
}

impl Default for TemporaryServicesCharge1Code {
    fn default() -> TemporaryServicesCharge1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for TemporaryServicesCharge1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct TemporaryServicesCompany1 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max70Text,

    #[yaserde(rename = "Dept")]
    #[cfg_attr(feature = "serde", serde(rename = "Dept"))]
    pub dept: Max70Text,

    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: PartyIdentification197,

    #[yaserde(rename = "Sprvsr")]
    #[cfg_attr(feature = "serde", serde(rename = "Sprvsr"))]
    pub sprvsr: Max70Text,
}

impl Validate for TemporaryServicesCompany1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct TemporaryServicesJob1 {
    #[yaserde(rename = "JobCd")]
    #[cfg_attr(feature = "serde", serde(rename = "JobCd"))]
    pub job_cd: Max35Text,

    #[yaserde(rename = "Desc")]
    #[cfg_attr(feature = "serde", serde(rename = "Desc"))]
    pub desc: Max256Text,

    #[yaserde(rename = "StartDt")]
    #[cfg_attr(feature = "serde", serde(rename = "StartDt"))]
    pub start_dt: Isodate,

    #[yaserde(rename = "Drtn")]
    #[cfg_attr(feature = "serde", serde(rename = "Drtn"))]
    pub drtn: Max5NumericText,

    #[yaserde(rename = "EndDt")]
    #[cfg_attr(feature = "serde", serde(rename = "EndDt"))]
    pub end_dt: Isodate,
}

impl Validate for TemporaryServicesJob1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct TemporaryServicesLabor1 {
    #[yaserde(rename = "TmSheetNb")]
    #[cfg_attr(feature = "serde", serde(rename = "TmSheetNb"))]
    pub tm_sheet_nb: Max35Text,

    #[yaserde(rename = "WkEndg")]
    #[cfg_attr(feature = "serde", serde(rename = "WkEndg"))]
    pub wk_endg: Max10NumericText,

    #[yaserde(rename = "Chrg")]
    #[cfg_attr(feature = "serde", serde(rename = "Chrg"))]
    pub chrg: Vec<Amount12>,
}

impl Validate for TemporaryServicesLabor1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct Terminal1 {
    #[yaserde(rename = "TermnlId")]
    #[cfg_attr(feature = "serde", serde(rename = "TermnlId"))]
    pub termnl_id: TerminalIdentification1,

    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: TerminalType1Code,

    #[yaserde(rename = "OthrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrTp"))]
    pub othr_tp: Max35Text,

    #[yaserde(rename = "Cpblties")]
    #[cfg_attr(feature = "serde", serde(rename = "Cpblties"))]
    pub cpblties: Capabilities1,

    #[yaserde(rename = "TermnlIntgtn")]
    #[cfg_attr(feature = "serde", serde(rename = "TermnlIntgtn"))]
    pub termnl_intgtn: TerminalIntegrationCategory1Code,

    #[yaserde(rename = "OutdrInd")]
    #[cfg_attr(feature = "serde", serde(rename = "OutdrInd"))]
    pub outdr_ind: TrueFalseIndicator,

    #[yaserde(rename = "OffPrmissInd")]
    #[cfg_attr(feature = "serde", serde(rename = "OffPrmissInd"))]
    pub off_prmiss_ind: TrueFalseIndicator,

    #[yaserde(rename = "OnBrdInd")]
    #[cfg_attr(feature = "serde", serde(rename = "OnBrdInd"))]
    pub on_brd_ind: TrueFalseIndicator,

    #[yaserde(rename = "POICmpnt")]
    #[cfg_attr(feature = "serde", serde(rename = "POICmpnt"))]
    pub poi_cmpnt: Vec<PointOfInteractionComponent8>,
}

impl Validate for Terminal1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct TerminalIdentification1 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max16Text,

    #[yaserde(rename = "Assgnr")]
    #[cfg_attr(feature = "serde", serde(rename = "Assgnr"))]
    pub assgnr: Max35Text,

    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: Min2Max3AlphaText,

    #[yaserde(rename = "ShrtNm")]
    #[cfg_attr(feature = "serde", serde(rename = "ShrtNm"))]
    pub shrt_nm: Max35Text,
}

impl Validate for TerminalIdentification1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum TerminalIntegrationCategory1Code {
    #[yaserde(rename = "MPOI")]
    #[cfg_attr(feature = "serde", serde(rename = "MPOI"))]
    Mpoi,
    #[yaserde(rename = "MSLE")]
    #[cfg_attr(feature = "serde", serde(rename = "MSLE"))]
    Msle,
    #[yaserde(rename = "SSLE")]
    #[cfg_attr(feature = "serde", serde(rename = "SSLE"))]
    Ssle,
    __Unknown__(String),
}

impl Default for TerminalIntegrationCategory1Code {
    fn default() -> TerminalIntegrationCategory1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for TerminalIntegrationCategory1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum TerminalType1Code {
    #[yaserde(rename = "ATMT")]
    #[cfg_attr(feature = "serde", serde(rename = "ATMT"))]
    Atmt,
    #[yaserde(rename = "MPOS")]
    #[cfg_attr(feature = "serde", serde(rename = "MPOS"))]
    Mpos,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "POST")]
    #[cfg_attr(feature = "serde", serde(rename = "POST"))]
    Post,
    __Unknown__(String),
}

impl Default for TerminalType1Code {
    fn default() -> TerminalType1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for TerminalType1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct Ticket1 {
    #[yaserde(rename = "TcktNb")]
    #[cfg_attr(feature = "serde", serde(rename = "TcktNb"))]
    pub tckt_nb: Max35Text,

    #[yaserde(rename = "TcktIssr")]
    #[cfg_attr(feature = "serde", serde(rename = "TcktIssr"))]
    pub tckt_issr: PartyIdentification197,

    #[yaserde(rename = "TcktIsseDt")]
    #[cfg_attr(feature = "serde", serde(rename = "TcktIsseDt"))]
    pub tckt_isse_dt: Isodate,

    #[yaserde(rename = "TcktIsseLctn")]
    #[cfg_attr(feature = "serde", serde(rename = "TcktIsseLctn"))]
    pub tckt_isse_lctn: Max140Text,

    #[yaserde(rename = "CnjnctnTcktNb")]
    #[cfg_attr(feature = "serde", serde(rename = "CnjnctnTcktNb"))]
    pub cnjnctn_tckt_nb: Max35Text,

    #[yaserde(rename = "RstrctdTcktInd")]
    #[cfg_attr(feature = "serde", serde(rename = "RstrctdTcktInd"))]
    pub rstrctd_tckt_ind: TrueFalseIndicator,

    #[yaserde(rename = "OpnTcktInd")]
    #[cfg_attr(feature = "serde", serde(rename = "OpnTcktInd"))]
    pub opn_tckt_ind: TrueFalseIndicator,

    #[yaserde(rename = "Rstrctns")]
    #[cfg_attr(feature = "serde", serde(rename = "Rstrctns"))]
    pub rstrctns: Max70Text,

    #[yaserde(rename = "XchgdTcktInd")]
    #[cfg_attr(feature = "serde", serde(rename = "XchgdTcktInd"))]
    pub xchgd_tckt_ind: TrueFalseIndicator,

    #[yaserde(rename = "XchgdTcktNb")]
    #[cfg_attr(feature = "serde", serde(rename = "XchgdTcktNb"))]
    pub xchgd_tckt_nb: Max35Text,

    #[yaserde(rename = "RcrdLctrNb")]
    #[cfg_attr(feature = "serde", serde(rename = "RcrdLctrNb"))]
    pub rcrd_lctr_nb: Max35Text,

    #[yaserde(rename = "Rsvatn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rsvatn"))]
    pub rsvatn: ReservationDetails3,
}

impl Validate for Ticket1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum TimeSegment1Code {
    #[yaserde(rename = "AMBN")]
    #[cfg_attr(feature = "serde", serde(rename = "AMBN"))]
    Ambn,
    #[yaserde(rename = "PMAN")]
    #[cfg_attr(feature = "serde", serde(rename = "PMAN"))]
    Pman,
    __Unknown__(String),
}

impl Default for TimeSegment1Code {
    fn default() -> TimeSegment1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for TimeSegment1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct Token1 {
    #[yaserde(rename = "PmtTkn")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtTkn"))]
    pub pmt_tkn: Max19NumericText,

    #[yaserde(rename = "TknXpryDt")]
    #[cfg_attr(feature = "serde", serde(rename = "TknXpryDt"))]
    pub tkn_xpry_dt: Exact4NumericText,

    #[yaserde(rename = "TknRqstrId")]
    #[cfg_attr(feature = "serde", serde(rename = "TknRqstrId"))]
    pub tkn_rqstr_id: Max11NumericText,

    #[yaserde(rename = "TknAssrncData")]
    #[cfg_attr(feature = "serde", serde(rename = "TknAssrncData"))]
    pub tkn_assrnc_data: Max140Text,

    #[yaserde(rename = "TknAssrncMtd")]
    #[cfg_attr(feature = "serde", serde(rename = "TknAssrncMtd"))]
    pub tkn_assrnc_mtd: Max2NumericText,

    #[yaserde(rename = "TknInittdInd")]
    #[cfg_attr(feature = "serde", serde(rename = "TknInittdInd"))]
    pub tkn_inittd_ind: TrueFalseIndicator,
}

impl Validate for Token1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct Traceability7 {
    #[yaserde(rename = "RlayId")]
    #[cfg_attr(feature = "serde", serde(rename = "RlayId"))]
    pub rlay_id: GenericIdentification172,

    #[yaserde(rename = "TracDtTmIn")]
    #[cfg_attr(feature = "serde", serde(rename = "TracDtTmIn"))]
    pub trac_dt_tm_in: IsodateTime,

    #[yaserde(rename = "TracDtTmOut")]
    #[cfg_attr(feature = "serde", serde(rename = "TracDtTmOut"))]
    pub trac_dt_tm_out: IsodateTime,
}

impl Validate for Traceability7 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct Track2Data1Choice {
    #[yaserde(rename = "TxtVal")]
    #[cfg_attr(feature = "serde", serde(rename = "TxtVal"))]
    pub txt_val: Option<Max37Text>,
    #[yaserde(rename = "HexBinryVal")]
    #[cfg_attr(feature = "serde", serde(rename = "HexBinryVal"))]
    pub hex_binry_val: Option<Max19HexBinaryText>,
}

impl Validate for Track2Data1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct Transaction77 {
    #[yaserde(rename = "TxTp")]
    #[cfg_attr(feature = "serde", serde(rename = "TxTp"))]
    pub tx_tp: Exact2AlphaNumericText,

    #[yaserde(rename = "TxSubTp")]
    #[cfg_attr(feature = "serde", serde(rename = "TxSubTp"))]
    pub tx_sub_tp: Max35Text,

    #[yaserde(rename = "AddtlSvc")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlSvc"))]
    pub addtl_svc: Vec<AdditionalService1>,

    #[yaserde(rename = "TxAttr")]
    #[cfg_attr(feature = "serde", serde(rename = "TxAttr"))]
    pub tx_attr: TransactionAttribute1Code,

    #[yaserde(rename = "OthrTxAttr")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrTxAttr"))]
    pub othr_tx_attr: Max35Text,

    #[yaserde(rename = "MsgRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgRsn"))]
    pub msg_rsn: Vec<Exact4NumericText>,

    #[yaserde(rename = "AltrnMsgRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "AltrnMsgRsn"))]
    pub altrn_msg_rsn: Vec<Max35Text>,

    #[yaserde(rename = "PreAuthstnTmLmt")]
    #[cfg_attr(feature = "serde", serde(rename = "PreAuthstnTmLmt"))]
    pub pre_authstn_tm_lmt: Max6NumericText,

    #[yaserde(rename = "AssoctdDataInd")]
    #[cfg_attr(feature = "serde", serde(rename = "AssoctdDataInd"))]
    pub assoctd_data_ind: TrueFalseIndicator,

    #[yaserde(rename = "AssoctdDataRef")]
    #[cfg_attr(feature = "serde", serde(rename = "AssoctdDataRef"))]
    pub assoctd_data_ref: Max70Text,

    #[yaserde(rename = "AssoctdDataDstn")]
    #[cfg_attr(feature = "serde", serde(rename = "AssoctdDataDstn"))]
    pub assoctd_data_dstn: Max35Text,

    #[yaserde(rename = "SpclPrgrmmQlfctn")]
    #[cfg_attr(feature = "serde", serde(rename = "SpclPrgrmmQlfctn"))]
    pub spcl_prgrmm_qlfctn: Vec<SpecialProgrammeQualification1>,

    #[yaserde(rename = "TxId")]
    #[cfg_attr(feature = "serde", serde(rename = "TxId"))]
    pub tx_id: TransactionIdentification8,

    #[yaserde(rename = "DsptData")]
    #[cfg_attr(feature = "serde", serde(rename = "DsptData"))]
    pub dspt_data: Vec<DisputeData1>,

    #[yaserde(rename = "TxAmts")]
    #[cfg_attr(feature = "serde", serde(rename = "TxAmts"))]
    pub tx_amts: TransactionAmounts1,

    #[yaserde(rename = "AddtlAmts")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlAmts"))]
    pub addtl_amts: Vec<AdditionalAmounts1>,

    #[yaserde(rename = "AddtlFees")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlFees"))]
    pub addtl_fees: Vec<AdditionalFee1>,

    #[yaserde(rename = "OrgnlAddtlFees")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlAddtlFees"))]
    pub orgnl_addtl_fees: Vec<AdditionalFee1>,

    #[yaserde(rename = "DpstDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "DpstDtls"))]
    pub dpst_dtls: Vec<DepositDetails1>,

    #[yaserde(rename = "FndsSvcs")]
    #[cfg_attr(feature = "serde", serde(rename = "FndsSvcs"))]
    pub fnds_svcs: FundingService1,

    #[yaserde(rename = "AcctFr")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctFr"))]
    pub acct_fr: AccountDetails2,

    #[yaserde(rename = "AcctTo")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctTo"))]
    pub acct_to: AccountDetails2,

    #[yaserde(rename = "TxDesc")]
    #[cfg_attr(feature = "serde", serde(rename = "TxDesc"))]
    pub tx_desc: Max1000Text,

    #[yaserde(rename = "AddtlData")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlData"))]
    pub addtl_data: Vec<AdditionalData1>,
}

impl Validate for Transaction77 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct TransactionAmount1 {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "Ccy")]
    #[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
    pub ccy: Iso3NumericCurrencyCode,
}

impl Validate for TransactionAmount1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct TransactionAmounts1 {
    #[yaserde(rename = "AmtQlfr")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtQlfr"))]
    pub amt_qlfr: TypeOfAmount11Code,

    #[yaserde(rename = "TxAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "TxAmt"))]
    pub tx_amt: TransactionAmount1,

    #[yaserde(rename = "CrdhldrBllgAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "CrdhldrBllgAmt"))]
    pub crdhldr_bllg_amt: Amount4,

    #[yaserde(rename = "RcncltnAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "RcncltnAmt"))]
    pub rcncltn_amt: Amount4,

    #[yaserde(rename = "DtldAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "DtldAmt"))]
    pub dtld_amt: Vec<DetailedAmount19>,

    #[yaserde(rename = "OrgnlTxAmts")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlTxAmts"))]
    pub orgnl_tx_amts: OriginalTransactionAmount1,
}

impl Validate for TransactionAmounts1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum TransactionAttribute1Code {
    #[yaserde(rename = "AGGR")]
    #[cfg_attr(feature = "serde", serde(rename = "AGGR"))]
    Aggr,
    #[yaserde(rename = "CADB")]
    #[cfg_attr(feature = "serde", serde(rename = "CADB"))]
    Cadb,
    #[yaserde(rename = "DBRP")]
    #[cfg_attr(feature = "serde", serde(rename = "DBRP"))]
    Dbrp,
    #[yaserde(rename = "DFRD")]
    #[cfg_attr(feature = "serde", serde(rename = "DFRD"))]
    Dfrd,
    #[yaserde(rename = "INST")]
    #[cfg_attr(feature = "serde", serde(rename = "INST"))]
    Inst,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "RCPT")]
    #[cfg_attr(feature = "serde", serde(rename = "RCPT"))]
    Rcpt,
    #[yaserde(rename = "TPUP")]
    #[cfg_attr(feature = "serde", serde(rename = "TPUP"))]
    Tpup,
    #[yaserde(rename = "PPYT")]
    #[cfg_attr(feature = "serde", serde(rename = "PPYT"))]
    Ppyt,
    #[yaserde(rename = "INCR")]
    #[cfg_attr(feature = "serde", serde(rename = "INCR"))]
    Incr,
    #[yaserde(rename = "PAUT")]
    #[cfg_attr(feature = "serde", serde(rename = "PAUT"))]
    Paut,
    #[yaserde(rename = "PACP")]
    #[cfg_attr(feature = "serde", serde(rename = "PACP"))]
    Pacp,
    #[yaserde(rename = "SUBR")]
    #[cfg_attr(feature = "serde", serde(rename = "SUBR"))]
    Subr,
    #[yaserde(rename = "FRCP")]
    #[cfg_attr(feature = "serde", serde(rename = "FRCP"))]
    Frcp,
    #[yaserde(rename = "CPLT")]
    #[cfg_attr(feature = "serde", serde(rename = "CPLT"))]
    Cplt,
    __Unknown__(String),
}

impl Default for TransactionAttribute1Code {
    fn default() -> TransactionAttribute1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for TransactionAttribute1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct TransactionContext1 {
    #[yaserde(rename = "MrchntCtgyCd")]
    #[cfg_attr(feature = "serde", serde(rename = "MrchntCtgyCd"))]
    pub mrchnt_ctgy_cd: Exact4NumericText,

    #[yaserde(rename = "MrchntCtgySpcfcData")]
    #[cfg_attr(feature = "serde", serde(rename = "MrchntCtgySpcfcData"))]
    pub mrchnt_ctgy_spcfc_data: Max35Text,

    #[yaserde(rename = "CstmrCnsnt")]
    #[cfg_attr(feature = "serde", serde(rename = "CstmrCnsnt"))]
    pub cstmr_cnsnt: TrueFalseIndicator,

    #[yaserde(rename = "ICCFllbckInd")]
    #[cfg_attr(feature = "serde", serde(rename = "ICCFllbckInd"))]
    pub icc_fllbck_ind: TrueFalseIndicator,

    #[yaserde(rename = "MgntcStrpFllbckInd")]
    #[cfg_attr(feature = "serde", serde(rename = "MgntcStrpFllbckInd"))]
    pub mgntc_strp_fllbck_ind: TrueFalseIndicator,

    #[yaserde(rename = "LatePresntmntInd")]
    #[cfg_attr(feature = "serde", serde(rename = "LatePresntmntInd"))]
    pub late_presntmnt_ind: TrueFalseIndicator,

    #[yaserde(rename = "FnlAuthstnInd")]
    #[cfg_attr(feature = "serde", serde(rename = "FnlAuthstnInd"))]
    pub fnl_authstn_ind: TrueFalseIndicator,

    #[yaserde(rename = "DfrrdDlvryInd")]
    #[cfg_attr(feature = "serde", serde(rename = "DfrrdDlvryInd"))]
    pub dfrrd_dlvry_ind: TrueFalseIndicator,

    #[yaserde(rename = "TxInitr")]
    #[cfg_attr(feature = "serde", serde(rename = "TxInitr"))]
    pub tx_initr: TransactionInitiator1Code,

    #[yaserde(rename = "CardPrgrmm")]
    #[cfg_attr(feature = "serde", serde(rename = "CardPrgrmm"))]
    pub card_prgrmm: CardProgramme1,

    #[yaserde(rename = "SttlmSvc")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmSvc"))]
    pub sttlm_svc: SettlementService1,

    #[yaserde(rename = "Rcncltn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rcncltn"))]
    pub rcncltn: Reconciliation3,

    #[yaserde(rename = "CaptrDt")]
    #[cfg_attr(feature = "serde", serde(rename = "CaptrDt"))]
    pub captr_dt: Isodate,
}

impl Validate for TransactionContext1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct TransactionIdentification8 {
    #[yaserde(rename = "LclDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "LclDtTm"))]
    pub lcl_dt_tm: IsodateTime,

    #[yaserde(rename = "TmZone")]
    #[cfg_attr(feature = "serde", serde(rename = "TmZone"))]
    pub tm_zone: Max70Text,

    #[yaserde(rename = "TxRef")]
    #[cfg_attr(feature = "serde", serde(rename = "TxRef"))]
    pub tx_ref: Max35Text,

    #[yaserde(rename = "TrnsmssnDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "TrnsmssnDtTm"))]
    pub trnsmssn_dt_tm: IsodateTime,

    #[yaserde(rename = "SysTracAudtNb")]
    #[cfg_attr(feature = "serde", serde(rename = "SysTracAudtNb"))]
    pub sys_trac_audt_nb: Max12NumericText,

    #[yaserde(rename = "RtrvlRefNb")]
    #[cfg_attr(feature = "serde", serde(rename = "RtrvlRefNb"))]
    pub rtrvl_ref_nb: Exact12Text,

    #[yaserde(rename = "LifeCyclSpprt")]
    #[cfg_attr(feature = "serde", serde(rename = "LifeCyclSpprt"))]
    pub life_cycl_spprt: LifeCycleSupport1Code,

    #[yaserde(rename = "LifeCyclTracIdData")]
    #[cfg_attr(feature = "serde", serde(rename = "LifeCyclTracIdData"))]
    pub life_cycl_trac_id_data: TransactionLifeCycleIdentification1,

    #[yaserde(rename = "LifeCyclTracIdMssng")]
    #[cfg_attr(feature = "serde", serde(rename = "LifeCyclTracIdMssng"))]
    pub life_cycl_trac_id_mssng: Max70Text,

    #[yaserde(rename = "AcqrrRefData")]
    #[cfg_attr(feature = "serde", serde(rename = "AcqrrRefData"))]
    pub acqrr_ref_data: Max140Text,

    #[yaserde(rename = "AcqrrRefNb")]
    #[cfg_attr(feature = "serde", serde(rename = "AcqrrRefNb"))]
    pub acqrr_ref_nb: Max23NumericText,

    #[yaserde(rename = "CardIssrRefData")]
    #[cfg_attr(feature = "serde", serde(rename = "CardIssrRefData"))]
    pub card_issr_ref_data: Max1000Text,

    #[yaserde(rename = "OrgnlDataElmts")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlDataElmts"))]
    pub orgnl_data_elmts: OriginalDataElements1,
}

impl Validate for TransactionIdentification8 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum TransactionInitiator1Code {
    #[yaserde(rename = "MERC")]
    #[cfg_attr(feature = "serde", serde(rename = "MERC"))]
    Merc,
    #[yaserde(rename = "CUST")]
    #[cfg_attr(feature = "serde", serde(rename = "CUST"))]
    Cust,
    __Unknown__(String),
}

impl Default for TransactionInitiator1Code {
    fn default() -> TransactionInitiator1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for TransactionInitiator1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct TransactionLifeCycleIdentification1 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Exact15Text,

    #[yaserde(rename = "AuthstnSeqNb")]
    #[cfg_attr(feature = "serde", serde(rename = "AuthstnSeqNb"))]
    pub authstn_seq_nb: Exact2NumericText,

    #[yaserde(rename = "PresntmntSeqNb")]
    #[cfg_attr(feature = "serde", serde(rename = "PresntmntSeqNb"))]
    pub presntmnt_seq_nb: Exact2NumericText,

    #[yaserde(rename = "PresntmntSeqCnt")]
    #[cfg_attr(feature = "serde", serde(rename = "PresntmntSeqCnt"))]
    pub presntmnt_seq_cnt: Exact2NumericText,

    #[yaserde(rename = "AuthntcnTkn")]
    #[cfg_attr(feature = "serde", serde(rename = "AuthntcnTkn"))]
    pub authntcn_tkn: Max35Text,
}

impl Validate for TransactionLifeCycleIdentification1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct TransferService1 {
    #[yaserde(rename = "SvcPrvdr")]
    #[cfg_attr(feature = "serde", serde(rename = "SvcPrvdr"))]
    pub svc_prvdr: Max35Text,

    #[yaserde(rename = "SvcNm")]
    #[cfg_attr(feature = "serde", serde(rename = "SvcNm"))]
    pub svc_nm: Max35Text,

    #[yaserde(rename = "Ref")]
    #[cfg_attr(feature = "serde", serde(rename = "Ref"))]
    pub _ref: Max35Text,

    #[yaserde(rename = "BizPurp")]
    #[cfg_attr(feature = "serde", serde(rename = "BizPurp"))]
    pub biz_purp: Max35Text,

    #[yaserde(rename = "Desc")]
    #[cfg_attr(feature = "serde", serde(rename = "Desc"))]
    pub desc: Max256Text,
}

impl Validate for TransferService1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum TransportType1Code {
    #[yaserde(rename = "AIRR")]
    #[cfg_attr(feature = "serde", serde(rename = "AIRR"))]
    Airr,
    #[yaserde(rename = "BUSS")]
    #[cfg_attr(feature = "serde", serde(rename = "BUSS"))]
    Buss,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "RAIL")]
    #[cfg_attr(feature = "serde", serde(rename = "RAIL"))]
    Rail,
    #[yaserde(rename = "SHIP")]
    #[cfg_attr(feature = "serde", serde(rename = "SHIP"))]
    Ship,
    __Unknown__(String),
}

impl Default for TransportType1Code {
    fn default() -> TransportType1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for TransportType1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct TravelAgency2 {
    #[yaserde(rename = "Cpny")]
    #[cfg_attr(feature = "serde", serde(rename = "Cpny"))]
    pub cpny: PartyIdentification207,

    #[yaserde(rename = "TrvlPackg")]
    #[cfg_attr(feature = "serde", serde(rename = "TrvlPackg"))]
    pub trvl_packg: Vec<TravelAgencyPackage1>,

    #[yaserde(rename = "AddtlData")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlData"))]
    pub addtl_data: Max350Text,
}

impl Validate for TravelAgency2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct TravelAgencyPackage1 {
    #[yaserde(rename = "RsvatnNb")]
    #[cfg_attr(feature = "serde", serde(rename = "RsvatnNb"))]
    pub rsvatn_nb: Max35Text,

    #[yaserde(rename = "TrvlPackgTp")]
    #[cfg_attr(feature = "serde", serde(rename = "TrvlPackgTp"))]
    pub trvl_packg_tp: Max70Text,

    #[yaserde(rename = "NbInPty")]
    #[cfg_attr(feature = "serde", serde(rename = "NbInPty"))]
    pub nb_in_pty: Max10NumericText,

    #[yaserde(rename = "CstmrRef")]
    #[cfg_attr(feature = "serde", serde(rename = "CstmrRef"))]
    pub cstmr_ref: Vec<CustomerReference1>,

    #[yaserde(rename = "DataSrc")]
    #[cfg_attr(feature = "serde", serde(rename = "DataSrc"))]
    pub data_src: Max35Text,

    #[yaserde(rename = "DlvryOrdrNb")]
    #[cfg_attr(feature = "serde", serde(rename = "DlvryOrdrNb"))]
    pub dlvry_ordr_nb: Max35Text,

    #[yaserde(rename = "CdtCardSlipNb")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtCardSlipNb"))]
    pub cdt_card_slip_nb: Max35Text,

    #[yaserde(rename = "InsrncInd")]
    #[cfg_attr(feature = "serde", serde(rename = "InsrncInd"))]
    pub insrnc_ind: TrueFalseIndicator,

    #[yaserde(rename = "InsrncAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "InsrncAmt"))]
    pub insrnc_amt: ImpliedCurrencyAndAmount,

    #[yaserde(rename = "Fee")]
    #[cfg_attr(feature = "serde", serde(rename = "Fee"))]
    pub fee: ImpliedCurrencyAndAmount,
}

impl Validate for TravelAgencyPackage1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct TravelDocument1 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: OfficialDocumentType1Code,

    #[yaserde(rename = "Form")]
    #[cfg_attr(feature = "serde", serde(rename = "Form"))]
    pub form: PresentationMedium2Code,

    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max70Text,

    #[yaserde(rename = "Assgnr")]
    #[cfg_attr(feature = "serde", serde(rename = "Assgnr"))]
    pub assgnr: Max70Text,

    #[yaserde(rename = "IssncDt")]
    #[cfg_attr(feature = "serde", serde(rename = "IssncDt"))]
    pub issnc_dt: Isodate,

    #[yaserde(rename = "XprtnDt")]
    #[cfg_attr(feature = "serde", serde(rename = "XprtnDt"))]
    pub xprtn_dt: Isodate,

    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: Min2Max3AlphaText,
}

impl Validate for TravelDocument1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct TripInformation1 {
    #[yaserde(rename = "TripNb")]
    #[cfg_attr(feature = "serde", serde(rename = "TripNb"))]
    pub trip_nb: Max35Text,

    #[yaserde(rename = "JobNb")]
    #[cfg_attr(feature = "serde", serde(rename = "JobNb"))]
    pub job_nb: Max10Text,

    #[yaserde(rename = "WorkOrdr")]
    #[cfg_attr(feature = "serde", serde(rename = "WorkOrdr"))]
    pub work_ordr: Max70Text,

    #[yaserde(rename = "InvcNb")]
    #[cfg_attr(feature = "serde", serde(rename = "InvcNb"))]
    pub invc_nb: Max70Text,

    #[yaserde(rename = "BllgId")]
    #[cfg_attr(feature = "serde", serde(rename = "BllgId"))]
    pub bllg_id: Max70Text,

    #[yaserde(rename = "CtrlNb")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrlNb"))]
    pub ctrl_nb: Max35Text,

    #[yaserde(rename = "DlvryTcktNb")]
    #[cfg_attr(feature = "serde", serde(rename = "DlvryTcktNb"))]
    pub dlvry_tckt_nb: Max35Text,
}

impl Validate for TripInformation1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct TripLeg1 {
    #[yaserde(rename = "SeqNb")]
    #[cfg_attr(feature = "serde", serde(rename = "SeqNb"))]
    pub seq_nb: Max35NumericText,

    #[yaserde(rename = "Tckt")]
    #[cfg_attr(feature = "serde", serde(rename = "Tckt"))]
    pub tckt: Ticket1,

    #[yaserde(rename = "Doc")]
    #[cfg_attr(feature = "serde", serde(rename = "Doc"))]
    pub doc: Vec<DocumentReference1>,

    #[yaserde(rename = "PrcdrRef")]
    #[cfg_attr(feature = "serde", serde(rename = "PrcdrRef"))]
    pub prcdr_ref: Max35Text,

    #[yaserde(rename = "TrnsprtTp")]
    #[cfg_attr(feature = "serde", serde(rename = "TrnsprtTp"))]
    pub trnsprt_tp: TransportType1Code,

    #[yaserde(rename = "OthrTrnsprtTp")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrTrnsprtTp"))]
    pub othr_trnsprt_tp: Max35Text,

    #[yaserde(rename = "CmmdtyCd")]
    #[cfg_attr(feature = "serde", serde(rename = "CmmdtyCd"))]
    pub cmmdty_cd: Max4Text,

    #[yaserde(rename = "Crrier")]
    #[cfg_attr(feature = "serde", serde(rename = "Crrier"))]
    pub crrier: CarrierIdentification1,

    #[yaserde(rename = "RouteNb")]
    #[cfg_attr(feature = "serde", serde(rename = "RouteNb"))]
    pub route_nb: Max35Text,

    #[yaserde(rename = "SvcClss")]
    #[cfg_attr(feature = "serde", serde(rename = "SvcClss"))]
    pub svc_clss: Max35Text,

    #[yaserde(rename = "Dprture")]
    #[cfg_attr(feature = "serde", serde(rename = "Dprture"))]
    pub dprture: DepartureOrArrival1,

    #[yaserde(rename = "Arrvl")]
    #[cfg_attr(feature = "serde", serde(rename = "Arrvl"))]
    pub arrvl: DepartureOrArrival1,

    #[yaserde(rename = "Drtn")]
    #[cfg_attr(feature = "serde", serde(rename = "Drtn"))]
    pub drtn: Max4NumericText,

    #[yaserde(rename = "StopOverInd")]
    #[cfg_attr(feature = "serde", serde(rename = "StopOverInd"))]
    pub stop_over_ind: TrueFalseIndicator,

    #[yaserde(rename = "NonDrctRouteCd")]
    #[cfg_attr(feature = "serde", serde(rename = "NonDrctRouteCd"))]
    pub non_drct_route_cd: Max35Text,

    #[yaserde(rename = "FairBsisCd")]
    #[cfg_attr(feature = "serde", serde(rename = "FairBsisCd"))]
    pub fair_bsis_cd: Max35Text,

    #[yaserde(rename = "InsrncInd")]
    #[cfg_attr(feature = "serde", serde(rename = "InsrncInd"))]
    pub insrnc_ind: TrueFalseIndicator,

    #[yaserde(rename = "TripLegAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "TripLegAmt"))]
    pub trip_leg_amt: Vec<AmountDetails1>,

    #[yaserde(rename = "CdtRsnCd")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtRsnCd"))]
    pub cdt_rsn_cd: Max35Text,

    #[yaserde(rename = "PrcdrId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrcdrId"))]
    pub prcdr_id: Max35Text,

    #[yaserde(rename = "LltyPrgrmm")]
    #[cfg_attr(feature = "serde", serde(rename = "LltyPrgrmm"))]
    pub llty_prgrmm: LoyaltyProgramme2,

    #[yaserde(rename = "AddtlData")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlData"))]
    pub addtl_data: Max350Text,
}

impl Validate for TripLeg1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct TrueFalseIndicator (pub bool);
crate::simple_type!(TrueFalseIndicator);

impl Validate for TrueFalseIndicator {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum TypeOfAmount10Code {
    #[yaserde(rename = "INTC")]
    #[cfg_attr(feature = "serde", serde(rename = "INTC"))]
    Intc,
    #[yaserde(rename = "FEEP")]
    #[cfg_attr(feature = "serde", serde(rename = "FEEP"))]
    Feep,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "FEEA")]
    #[cfg_attr(feature = "serde", serde(rename = "FEEA"))]
    Feea,
    __Unknown__(String),
}

impl Default for TypeOfAmount10Code {
    fn default() -> TypeOfAmount10Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for TypeOfAmount10Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum TypeOfAmount11Code {
    #[yaserde(rename = "ACTL")]
    #[cfg_attr(feature = "serde", serde(rename = "ACTL"))]
    Actl,
    #[yaserde(rename = "DFLT")]
    #[cfg_attr(feature = "serde", serde(rename = "DFLT"))]
    Dflt,
    #[yaserde(rename = "ESTM")]
    #[cfg_attr(feature = "serde", serde(rename = "ESTM"))]
    Estm,
    #[yaserde(rename = "MAXI")]
    #[cfg_attr(feature = "serde", serde(rename = "MAXI"))]
    Maxi,
    #[yaserde(rename = "RESD")]
    #[cfg_attr(feature = "serde", serde(rename = "RESD"))]
    Resd,
    #[yaserde(rename = "PRXY")]
    #[cfg_attr(feature = "serde", serde(rename = "PRXY"))]
    Prxy,
    #[yaserde(rename = "DPST")]
    #[cfg_attr(feature = "serde", serde(rename = "DPST"))]
    Dpst,
    __Unknown__(String),
}

impl Default for TypeOfAmount11Code {
    fn default() -> TypeOfAmount11Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for TypeOfAmount11Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum TypeOfAmount12Code {
    #[yaserde(rename = "AMTH")]
    #[cfg_attr(feature = "serde", serde(rename = "AMTH"))]
    Amth,
    #[yaserde(rename = "DCNT")]
    #[cfg_attr(feature = "serde", serde(rename = "DCNT"))]
    Dcnt,
    #[yaserde(rename = "ISCF")]
    #[cfg_attr(feature = "serde", serde(rename = "ISCF"))]
    Iscf,
    #[yaserde(rename = "CUAT")]
    #[cfg_attr(feature = "serde", serde(rename = "CUAT"))]
    Cuat,
    #[yaserde(rename = "MAXI")]
    #[cfg_attr(feature = "serde", serde(rename = "MAXI"))]
    Maxi,
    #[yaserde(rename = "AMTX")]
    #[cfg_attr(feature = "serde", serde(rename = "AMTX"))]
    Amtx,
    #[yaserde(rename = "AMTN")]
    #[cfg_attr(feature = "serde", serde(rename = "AMTN"))]
    Amtn,
    #[yaserde(rename = "AMTQ")]
    #[cfg_attr(feature = "serde", serde(rename = "AMTQ"))]
    Amtq,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "RQCH")]
    #[cfg_attr(feature = "serde", serde(rename = "RQCH"))]
    Rqch,
    #[yaserde(rename = "ANTA")]
    #[cfg_attr(feature = "serde", serde(rename = "ANTA"))]
    Anta,
    #[yaserde(rename = "PDCC")]
    #[cfg_attr(feature = "serde", serde(rename = "PDCC"))]
    Pdcc,
    __Unknown__(String),
}

impl Default for TypeOfAmount12Code {
    fn default() -> TypeOfAmount12Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for TypeOfAmount12Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum TypeOfAmount18Code {
    #[yaserde(rename = "AMTH")]
    #[cfg_attr(feature = "serde", serde(rename = "AMTH"))]
    Amth,
    #[yaserde(rename = "BAGG")]
    #[cfg_attr(feature = "serde", serde(rename = "BAGG"))]
    Bagg,
    #[yaserde(rename = "CHTC")]
    #[cfg_attr(feature = "serde", serde(rename = "CHTC"))]
    Chtc,
    #[yaserde(rename = "DATA")]
    #[cfg_attr(feature = "serde", serde(rename = "DATA"))]
    Data,
    #[yaserde(rename = "EXTK")]
    #[cfg_attr(feature = "serde", serde(rename = "EXTK"))]
    Extk,
    #[yaserde(rename = "EXTR")]
    #[cfg_attr(feature = "serde", serde(rename = "EXTR"))]
    Extr,
    #[yaserde(rename = "FARE")]
    #[cfg_attr(feature = "serde", serde(rename = "FARE"))]
    Fare,
    #[yaserde(rename = "INSU")]
    #[cfg_attr(feature = "serde", serde(rename = "INSU"))]
    Insu,
    #[yaserde(rename = "FDBV")]
    #[cfg_attr(feature = "serde", serde(rename = "FDBV"))]
    Fdbv,
    #[yaserde(rename = "MISC")]
    #[cfg_attr(feature = "serde", serde(rename = "MISC"))]
    Misc,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "PHNE")]
    #[cfg_attr(feature = "serde", serde(rename = "PHNE"))]
    Phne,
    #[yaserde(rename = "PRPY")]
    #[cfg_attr(feature = "serde", serde(rename = "PRPY"))]
    Prpy,
    #[yaserde(rename = "TOTL")]
    #[cfg_attr(feature = "serde", serde(rename = "TOTL"))]
    Totl,
    #[yaserde(rename = "EXTF")]
    #[cfg_attr(feature = "serde", serde(rename = "EXTF"))]
    Extf,
    __Unknown__(String),
}

impl Default for TypeOfAmount18Code {
    fn default() -> TypeOfAmount18Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for TypeOfAmount18Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum TypeOfAmount19Code {
    #[yaserde(rename = "CONN")]
    #[cfg_attr(feature = "serde", serde(rename = "CONN"))]
    Conn,
    #[yaserde(rename = "INSU")]
    #[cfg_attr(feature = "serde", serde(rename = "INSU"))]
    Insu,
    #[yaserde(rename = "LNDS")]
    #[cfg_attr(feature = "serde", serde(rename = "LNDS"))]
    Lnds,
    #[yaserde(rename = "MISC")]
    #[cfg_attr(feature = "serde", serde(rename = "MISC"))]
    Misc,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "USGE")]
    #[cfg_attr(feature = "serde", serde(rename = "USGE"))]
    Usge,
    __Unknown__(String),
}

impl Default for TypeOfAmount19Code {
    fn default() -> TypeOfAmount19Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for TypeOfAmount19Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct UnitOfMeasure1 {
    #[yaserde(rename = "UnitOfMeasr")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitOfMeasr"))]
    pub unit_of_measr: UnitOfMeasure1Code,

    #[yaserde(rename = "OthrUnitOfMeasr")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrUnitOfMeasr"))]
    pub othr_unit_of_measr: Max35Text,

    #[yaserde(rename = "NbOfUnits")]
    #[cfg_attr(feature = "serde", serde(rename = "NbOfUnits"))]
    pub nb_of_units: ImpliedCurrencyAndAmount,
}

impl Validate for UnitOfMeasure1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum UnitOfMeasure10Code {
    #[yaserde(rename = "KMET")]
    #[cfg_attr(feature = "serde", serde(rename = "KMET"))]
    Kmet,
    #[yaserde(rename = "MILE")]
    #[cfg_attr(feature = "serde", serde(rename = "MILE"))]
    Mile,
    __Unknown__(String),
}

impl Default for UnitOfMeasure10Code {
    fn default() -> UnitOfMeasure10Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for UnitOfMeasure10Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum UnitOfMeasure1Code {
    #[yaserde(rename = "PIEC")]
    #[cfg_attr(feature = "serde", serde(rename = "PIEC"))]
    Piec,
    #[yaserde(rename = "TONS")]
    #[cfg_attr(feature = "serde", serde(rename = "TONS"))]
    Tons,
    #[yaserde(rename = "FOOT")]
    #[cfg_attr(feature = "serde", serde(rename = "FOOT"))]
    Foot,
    #[yaserde(rename = "GBGA")]
    #[cfg_attr(feature = "serde", serde(rename = "GBGA"))]
    Gbga,
    #[yaserde(rename = "USGA")]
    #[cfg_attr(feature = "serde", serde(rename = "USGA"))]
    Usga,
    #[yaserde(rename = "GRAM")]
    #[cfg_attr(feature = "serde", serde(rename = "GRAM"))]
    Gram,
    #[yaserde(rename = "INCH")]
    #[cfg_attr(feature = "serde", serde(rename = "INCH"))]
    Inch,
    #[yaserde(rename = "KILO")]
    #[cfg_attr(feature = "serde", serde(rename = "KILO"))]
    Kilo,
    #[yaserde(rename = "PUND")]
    #[cfg_attr(feature = "serde", serde(rename = "PUND"))]
    Pund,
    #[yaserde(rename = "METR")]
    #[cfg_attr(feature = "serde", serde(rename = "METR"))]
    Metr,
    #[yaserde(rename = "CMET")]
    #[cfg_attr(feature = "serde", serde(rename = "CMET"))]
    Cmet,
    #[yaserde(rename = "MMET")]
    #[cfg_attr(feature = "serde", serde(rename = "MMET"))]
    Mmet,
    #[yaserde(rename = "LITR")]
    #[cfg_attr(feature = "serde", serde(rename = "LITR"))]
    Litr,
    #[yaserde(rename = "CELI")]
    #[cfg_attr(feature = "serde", serde(rename = "CELI"))]
    Celi,
    #[yaserde(rename = "MILI")]
    #[cfg_attr(feature = "serde", serde(rename = "MILI"))]
    Mili,
    #[yaserde(rename = "GBOU")]
    #[cfg_attr(feature = "serde", serde(rename = "GBOU"))]
    Gbou,
    #[yaserde(rename = "USOU")]
    #[cfg_attr(feature = "serde", serde(rename = "USOU"))]
    Usou,
    #[yaserde(rename = "GBQA")]
    #[cfg_attr(feature = "serde", serde(rename = "GBQA"))]
    Gbqa,
    #[yaserde(rename = "USQA")]
    #[cfg_attr(feature = "serde", serde(rename = "USQA"))]
    Usqa,
    #[yaserde(rename = "GBPI")]
    #[cfg_attr(feature = "serde", serde(rename = "GBPI"))]
    Gbpi,
    #[yaserde(rename = "USPI")]
    #[cfg_attr(feature = "serde", serde(rename = "USPI"))]
    Uspi,
    #[yaserde(rename = "MILE")]
    #[cfg_attr(feature = "serde", serde(rename = "MILE"))]
    Mile,
    #[yaserde(rename = "KMET")]
    #[cfg_attr(feature = "serde", serde(rename = "KMET"))]
    Kmet,
    #[yaserde(rename = "YARD")]
    #[cfg_attr(feature = "serde", serde(rename = "YARD"))]
    Yard,
    #[yaserde(rename = "SQKI")]
    #[cfg_attr(feature = "serde", serde(rename = "SQKI"))]
    Sqki,
    #[yaserde(rename = "HECT")]
    #[cfg_attr(feature = "serde", serde(rename = "HECT"))]
    Hect,
    #[yaserde(rename = "ARES")]
    #[cfg_attr(feature = "serde", serde(rename = "ARES"))]
    Ares,
    #[yaserde(rename = "SMET")]
    #[cfg_attr(feature = "serde", serde(rename = "SMET"))]
    Smet,
    #[yaserde(rename = "SCMT")]
    #[cfg_attr(feature = "serde", serde(rename = "SCMT"))]
    Scmt,
    #[yaserde(rename = "SMIL")]
    #[cfg_attr(feature = "serde", serde(rename = "SMIL"))]
    Smil,
    #[yaserde(rename = "SQMI")]
    #[cfg_attr(feature = "serde", serde(rename = "SQMI"))]
    Sqmi,
    #[yaserde(rename = "SQYA")]
    #[cfg_attr(feature = "serde", serde(rename = "SQYA"))]
    Sqya,
    #[yaserde(rename = "SQFO")]
    #[cfg_attr(feature = "serde", serde(rename = "SQFO"))]
    Sqfo,
    #[yaserde(rename = "SQIN")]
    #[cfg_attr(feature = "serde", serde(rename = "SQIN"))]
    Sqin,
    #[yaserde(rename = "ACRE")]
    #[cfg_attr(feature = "serde", serde(rename = "ACRE"))]
    Acre,
    __Unknown__(String),
}

impl Default for UnitOfMeasure1Code {
    fn default() -> UnitOfMeasure1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for UnitOfMeasure1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum UserInterface1Code {
    #[yaserde(rename = "CDSP")]
    #[cfg_attr(feature = "serde", serde(rename = "CDSP"))]
    Cdsp,
    #[yaserde(rename = "CRCP")]
    #[cfg_attr(feature = "serde", serde(rename = "CRCP"))]
    Crcp,
    #[yaserde(rename = "MDSP")]
    #[cfg_attr(feature = "serde", serde(rename = "MDSP"))]
    Mdsp,
    #[yaserde(rename = "MRCP")]
    #[cfg_attr(feature = "serde", serde(rename = "MRCP"))]
    Mrcp,
    __Unknown__(String),
}

impl Default for UserInterface1Code {
    fn default() -> UserInterface1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for UserInterface1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum UserInterface6Code {
    #[yaserde(rename = "CDSP")]
    #[cfg_attr(feature = "serde", serde(rename = "CDSP"))]
    Cdsp,
    #[yaserde(rename = "CRCP")]
    #[cfg_attr(feature = "serde", serde(rename = "CRCP"))]
    Crcp,
    #[yaserde(rename = "MDSP")]
    #[cfg_attr(feature = "serde", serde(rename = "MDSP"))]
    Mdsp,
    #[yaserde(rename = "MRCP")]
    #[cfg_attr(feature = "serde", serde(rename = "MRCP"))]
    Mrcp,
    #[yaserde(rename = "CRDO")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDO"))]
    Crdo,
    #[yaserde(rename = "FILE")]
    #[cfg_attr(feature = "serde", serde(rename = "FILE"))]
    File,
    #[yaserde(rename = "CHAP")]
    #[cfg_attr(feature = "serde", serde(rename = "CHAP"))]
    Chap,
    #[yaserde(rename = "MRAP")]
    #[cfg_attr(feature = "serde", serde(rename = "MRAP"))]
    Mrap,
    #[yaserde(rename = "MRIN")]
    #[cfg_attr(feature = "serde", serde(rename = "MRIN"))]
    Mrin,
    __Unknown__(String),
}

impl Default for UserInterface6Code {
    fn default() -> UserInterface6Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for UserInterface6Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct Vehicle2 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: Max35Text,

    #[yaserde(rename = "NtryMd")]
    #[cfg_attr(feature = "serde", serde(rename = "NtryMd"))]
    pub ntry_md: CardDataReading5Code,

    #[yaserde(rename = "Data")]
    #[cfg_attr(feature = "serde", serde(rename = "Data"))]
    pub data: Max35Text,
}

impl Validate for Vehicle2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct Vehicle4 {
    #[yaserde(rename = "Clss")]
    #[cfg_attr(feature = "serde", serde(rename = "Clss"))]
    pub clss: Max35Text,

    #[yaserde(rename = "Make")]
    #[cfg_attr(feature = "serde", serde(rename = "Make"))]
    pub make: Max35NumericText,

    #[yaserde(rename = "Mdl")]
    #[cfg_attr(feature = "serde", serde(rename = "Mdl"))]
    pub mdl: Max35NumericText,

    #[yaserde(rename = "RegnNb")]
    #[cfg_attr(feature = "serde", serde(rename = "RegnNb"))]
    pub regn_nb: Max35Text,
}

impl Validate for Vehicle4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct Vehicle5 {
    #[yaserde(rename = "VhclNb")]
    #[cfg_attr(feature = "serde", serde(rename = "VhclNb"))]
    pub vhcl_nb: Max35NumericText,

    #[yaserde(rename = "VhclIdNb")]
    #[cfg_attr(feature = "serde", serde(rename = "VhclIdNb"))]
    pub vhcl_id_nb: Max35NumericText,

    #[yaserde(rename = "FleetNb")]
    #[cfg_attr(feature = "serde", serde(rename = "FleetNb"))]
    pub fleet_nb: Max10Text,

    #[yaserde(rename = "SubFleetNb")]
    #[cfg_attr(feature = "serde", serde(rename = "SubFleetNb"))]
    pub sub_fleet_nb: Max35Text,

    #[yaserde(rename = "UnitNb")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitNb"))]
    pub unit_nb: Max35NumericText,

    #[yaserde(rename = "TrlrNb")]
    #[cfg_attr(feature = "serde", serde(rename = "TrlrNb"))]
    pub trlr_nb: Max35NumericText,

    #[yaserde(rename = "VhclTag")]
    #[cfg_attr(feature = "serde", serde(rename = "VhclTag"))]
    pub vhcl_tag: Max35Text,

    #[yaserde(rename = "VhclTagNtryMd")]
    #[cfg_attr(feature = "serde", serde(rename = "VhclTagNtryMd"))]
    pub vhcl_tag_ntry_md: CardDataReading5Code,

    #[yaserde(rename = "RplcmntVhclInd")]
    #[cfg_attr(feature = "serde", serde(rename = "RplcmntVhclInd"))]
    pub rplcmnt_vhcl_ind: TrueFalseIndicator,

    #[yaserde(rename = "Odmtr")]
    #[cfg_attr(feature = "serde", serde(rename = "Odmtr"))]
    pub odmtr: DecimalNumber,

    #[yaserde(rename = "Hbmtr")]
    #[cfg_attr(feature = "serde", serde(rename = "Hbmtr"))]
    pub hbmtr: DecimalNumber,

    #[yaserde(rename = "MntncId")]
    #[cfg_attr(feature = "serde", serde(rename = "MntncId"))]
    pub mntnc_id: Max35Text,

    #[yaserde(rename = "OnBrdDgnstcs")]
    #[cfg_attr(feature = "serde", serde(rename = "OnBrdDgnstcs"))]
    pub on_brd_dgnstcs: OnBoardDiagnostics1,

    #[yaserde(rename = "AddtlVhclData")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlVhclData"))]
    pub addtl_vhcl_data: Vec<Vehicle2>,
}

impl Validate for Vehicle5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct VehicleRentalAgreement1 {
    #[yaserde(rename = "AgrmtNb")]
    #[cfg_attr(feature = "serde", serde(rename = "AgrmtNb"))]
    pub agrmt_nb: Max35Text,

    #[yaserde(rename = "AdjstdInd")]
    #[cfg_attr(feature = "serde", serde(rename = "AdjstdInd"))]
    pub adjstd_ind: TrueFalseIndicator,

    #[yaserde(rename = "RntlLctn")]
    #[cfg_attr(feature = "serde", serde(rename = "RntlLctn"))]
    pub rntl_lctn: Address1,

    #[yaserde(rename = "PckpLctn")]
    #[cfg_attr(feature = "serde", serde(rename = "PckpLctn"))]
    pub pckp_lctn: Vec<Address1>,

    #[yaserde(rename = "ChckOutDt")]
    #[cfg_attr(feature = "serde", serde(rename = "ChckOutDt"))]
    pub chck_out_dt: Isodate,

    #[yaserde(rename = "ChckOutTm")]
    #[cfg_attr(feature = "serde", serde(rename = "ChckOutTm"))]
    pub chck_out_tm: Isotime,

    #[yaserde(rename = "RtrLctn")]
    #[cfg_attr(feature = "serde", serde(rename = "RtrLctn"))]
    pub rtr_lctn: Address1,

    #[yaserde(rename = "ChckInDt")]
    #[cfg_attr(feature = "serde", serde(rename = "ChckInDt"))]
    pub chck_in_dt: Isodate,

    #[yaserde(rename = "ChckInTm")]
    #[cfg_attr(feature = "serde", serde(rename = "ChckInTm"))]
    pub chck_in_tm: Isotime,

    #[yaserde(rename = "Drtn")]
    #[cfg_attr(feature = "serde", serde(rename = "Drtn"))]
    pub drtn: Max4NumericText,

    #[yaserde(rename = "VhclClssDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "VhclClssDtls"))]
    pub vhcl_clss_dtls: Vehicle4,

    #[yaserde(rename = "TrvlDstnc")]
    #[cfg_attr(feature = "serde", serde(rename = "TrvlDstnc"))]
    pub trvl_dstnc: Distance1,

    #[yaserde(rename = "RntlRate")]
    #[cfg_attr(feature = "serde", serde(rename = "RntlRate"))]
    pub rntl_rate: Vec<RentalRate1>,

    #[yaserde(rename = "RntlDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "RntlDtls"))]
    pub rntl_dtls: RentalDetails1,

    #[yaserde(rename = "VhclRegnNb")]
    #[cfg_attr(feature = "serde", serde(rename = "VhclRegnNb"))]
    pub vhcl_regn_nb: Max70Text,

    #[yaserde(rename = "InsrncInd")]
    #[cfg_attr(feature = "serde", serde(rename = "InsrncInd"))]
    pub insrnc_ind: TrueFalseIndicator,

    #[yaserde(rename = "AddtlAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlAmt"))]
    pub addtl_amt: Vec<Amount9>,

    #[yaserde(rename = "EstmtdTax")]
    #[cfg_attr(feature = "serde", serde(rename = "EstmtdTax"))]
    pub estmtd_tax: Vec<Tax33>,

    #[yaserde(rename = "DscntPrgrmm")]
    #[cfg_attr(feature = "serde", serde(rename = "DscntPrgrmm"))]
    pub dscnt_prgrmm: Vec<Discount3>,

    #[yaserde(rename = "LltyPrgrmm")]
    #[cfg_attr(feature = "serde", serde(rename = "LltyPrgrmm"))]
    pub llty_prgrmm: Vec<LoyaltyProgramme1>,
}

impl Validate for VehicleRentalAgreement1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct VehicleRentalCompany1 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max70Text,

    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: PartyIdentification197,

    #[yaserde(rename = "Adr")]
    #[cfg_attr(feature = "serde", serde(rename = "Adr"))]
    pub adr: Address1,

    #[yaserde(rename = "Ctct")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctct"))]
    pub ctct: Contact3,

    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: Min2Max3AlphaText,

    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: CarRentalActivity1Code,

    #[yaserde(rename = "OthrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrTp"))]
    pub othr_tp: Max35Text,
}

impl Validate for VehicleRentalCompany1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct VehicleRentalCustomer1 {
    #[yaserde(rename = "RntrNm")]
    #[cfg_attr(feature = "serde", serde(rename = "RntrNm"))]
    pub rntr_nm: Max70Text,

    #[yaserde(rename = "CorpNm")]
    #[cfg_attr(feature = "serde", serde(rename = "CorpNm"))]
    pub corp_nm: Max70Text,

    #[yaserde(rename = "CorpIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "CorpIdr"))]
    pub corp_idr: Max35Text,

    #[yaserde(rename = "Assgnr")]
    #[cfg_attr(feature = "serde", serde(rename = "Assgnr"))]
    pub assgnr: CustomerAssigner1Code,

    #[yaserde(rename = "PmryDrvr")]
    #[cfg_attr(feature = "serde", serde(rename = "PmryDrvr"))]
    pub pmry_drvr: Vec<DriverInParty1>,

    #[yaserde(rename = "AddtlDrvr")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlDrvr"))]
    pub addtl_drvr: Vec<DriverInParty1>,

    #[yaserde(rename = "LltyPrgrmm")]
    #[cfg_attr(feature = "serde", serde(rename = "LltyPrgrmm"))]
    pub llty_prgrmm: LoyaltyProgramme2,
}

impl Validate for VehicleRentalCustomer1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct VehicleRentalInvoice1 {
    #[yaserde(rename = "NoShowInd")]
    #[cfg_attr(feature = "serde", serde(rename = "NoShowInd"))]
    pub no_show_ind: TrueFalseIndicator,

    #[yaserde(rename = "AdjstdInd")]
    #[cfg_attr(feature = "serde", serde(rename = "AdjstdInd"))]
    pub adjstd_ind: TrueFalseIndicator,

    #[yaserde(rename = "RtrLctn")]
    #[cfg_attr(feature = "serde", serde(rename = "RtrLctn"))]
    pub rtr_lctn: Address1,

    #[yaserde(rename = "ChckOutDt")]
    #[cfg_attr(feature = "serde", serde(rename = "ChckOutDt"))]
    pub chck_out_dt: Isodate,

    #[yaserde(rename = "ChckOutTm")]
    #[cfg_attr(feature = "serde", serde(rename = "ChckOutTm"))]
    pub chck_out_tm: Isotime,

    #[yaserde(rename = "ChckInDt")]
    #[cfg_attr(feature = "serde", serde(rename = "ChckInDt"))]
    pub chck_in_dt: Isodate,

    #[yaserde(rename = "ChckInTm")]
    #[cfg_attr(feature = "serde", serde(rename = "ChckInTm"))]
    pub chck_in_tm: Isotime,

    #[yaserde(rename = "Drtn")]
    #[cfg_attr(feature = "serde", serde(rename = "Drtn"))]
    pub drtn: Max4NumericText,

    #[yaserde(rename = "VhclClssInvcd")]
    #[cfg_attr(feature = "serde", serde(rename = "VhclClssInvcd"))]
    pub vhcl_clss_invcd: Vehicle4,

    #[yaserde(rename = "VhclClssPrvdd")]
    #[cfg_attr(feature = "serde", serde(rename = "VhclClssPrvdd"))]
    pub vhcl_clss_prvdd: Vehicle4,

    #[yaserde(rename = "TrvlDstnc")]
    #[cfg_attr(feature = "serde", serde(rename = "TrvlDstnc"))]
    pub trvl_dstnc: Distance1,

    #[yaserde(rename = "RntlChrg")]
    #[cfg_attr(feature = "serde", serde(rename = "RntlChrg"))]
    pub rntl_chrg: Vec<RentalRate1>,

    #[yaserde(rename = "SummryCmmdtyId")]
    #[cfg_attr(feature = "serde", serde(rename = "SummryCmmdtyId"))]
    pub summry_cmmdty_id: Max35Text,

    #[yaserde(rename = "InsrncInd")]
    #[cfg_attr(feature = "serde", serde(rename = "InsrncInd"))]
    pub insrnc_ind: TrueFalseIndicator,

    #[yaserde(rename = "AddtlAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlAmt"))]
    pub addtl_amt: Vec<Amount9>,

    #[yaserde(rename = "Tax")]
    #[cfg_attr(feature = "serde", serde(rename = "Tax"))]
    pub tax: Vec<Tax33>,
}

impl Validate for VehicleRentalInvoice1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct VehicleRentalService1 {
    #[yaserde(rename = "VhclRntlCpny")]
    #[cfg_attr(feature = "serde", serde(rename = "VhclRntlCpny"))]
    pub vhcl_rntl_cpny: VehicleRentalCompany1,

    #[yaserde(rename = "Cstmr")]
    #[cfg_attr(feature = "serde", serde(rename = "Cstmr"))]
    pub cstmr: VehicleRentalCustomer1,

    #[yaserde(rename = "SummryCmmdtyId")]
    #[cfg_attr(feature = "serde", serde(rename = "SummryCmmdtyId"))]
    pub summry_cmmdty_id: Max35Text,

    #[yaserde(rename = "RntlAgrmt")]
    #[cfg_attr(feature = "serde", serde(rename = "RntlAgrmt"))]
    pub rntl_agrmt: VehicleRentalAgreement1,

    #[yaserde(rename = "RntlInvc")]
    #[cfg_attr(feature = "serde", serde(rename = "RntlInvc"))]
    pub rntl_invc: VehicleRentalInvoice1,

    #[yaserde(rename = "AddtlData")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlData"))]
    pub addtl_data: Max350Text,
}

impl Validate for VehicleRentalService1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct Verification1 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: AuthenticationMethod11Code,

    #[yaserde(rename = "OthrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrTp"))]
    pub othr_tp: Max35Text,

    #[yaserde(rename = "SubTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SubTp"))]
    pub sub_tp: Max35Text,

    #[yaserde(rename = "VrfctnInf")]
    #[cfg_attr(feature = "serde", serde(rename = "VrfctnInf"))]
    pub vrfctn_inf: Vec<VerificationInformation1>,

    #[yaserde(rename = "VrfctnRslt")]
    #[cfg_attr(feature = "serde", serde(rename = "VrfctnRslt"))]
    pub vrfctn_rslt: Vec<VerificationResult1>,
}

impl Validate for Verification1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum Verification2Code {
    #[yaserde(rename = "FAIL")]
    #[cfg_attr(feature = "serde", serde(rename = "FAIL"))]
    Fail,
    #[yaserde(rename = "FUTA")]
    #[cfg_attr(feature = "serde", serde(rename = "FUTA"))]
    Futa,
    #[yaserde(rename = "MISS")]
    #[cfg_attr(feature = "serde", serde(rename = "MISS"))]
    Miss,
    #[yaserde(rename = "NOVF")]
    #[cfg_attr(feature = "serde", serde(rename = "NOVF"))]
    Novf,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "PART")]
    #[cfg_attr(feature = "serde", serde(rename = "PART"))]
    Part,
    #[yaserde(rename = "SUCC")]
    #[cfg_attr(feature = "serde", serde(rename = "SUCC"))]
    Succ,
    #[yaserde(rename = "ERRR")]
    #[cfg_attr(feature = "serde", serde(rename = "ERRR"))]
    Errr,
    __Unknown__(String),
}

impl Default for Verification2Code {
    fn default() -> Verification2Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for Verification2Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]

pub enum VerificationEntity1Code {
    #[yaserde(rename = "MERC")]
    #[cfg_attr(feature = "serde", serde(rename = "MERC"))]
    Merc,
    #[yaserde(rename = "ACQR")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
    Acqr,
    #[yaserde(rename = "AGNT")]
    #[cfg_attr(feature = "serde", serde(rename = "AGNT"))]
    Agnt,
    #[yaserde(rename = "ISSR")]
    #[cfg_attr(feature = "serde", serde(rename = "ISSR"))]
    Issr,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    __Unknown__(String),
}

impl Default for VerificationEntity1Code {
    fn default() -> VerificationEntity1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for VerificationEntity1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct VerificationInformation1 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: Max35Text,

    #[yaserde(rename = "Val")]
    #[cfg_attr(feature = "serde", serde(rename = "Val"))]
    pub val: VerificationValue1Choice,

    #[yaserde(rename = "Rsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
    pub rsn: Vec<Max35Text>,

    #[yaserde(rename = "DtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "DtTm"))]
    pub dt_tm: IsodateTime,

    #[yaserde(rename = "VldtyEndDt")]
    #[cfg_attr(feature = "serde", serde(rename = "VldtyEndDt"))]
    pub vldty_end_dt: Isodate,

    #[yaserde(rename = "VldtyEndTm")]
    #[cfg_attr(feature = "serde", serde(rename = "VldtyEndTm"))]
    pub vldty_end_tm: Isotime,
}

impl Validate for VerificationInformation1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct VerificationResult1 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: Max35Text,

    #[yaserde(rename = "Ntty")]
    #[cfg_attr(feature = "serde", serde(rename = "Ntty"))]
    pub ntty: VerificationEntity1Code,

    #[yaserde(rename = "OthrNtty")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrNtty"))]
    pub othr_ntty: Max35Text,

    #[yaserde(rename = "Rslt")]
    #[cfg_attr(feature = "serde", serde(rename = "Rslt"))]
    pub rslt: Verification2Code,

    #[yaserde(rename = "OthrRslt")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrRslt"))]
    pub othr_rslt: Max500Text,

    #[yaserde(rename = "RsltDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "RsltDtls"))]
    pub rslt_dtls: Vec<AdditionalData1>,
}

impl Validate for VerificationResult1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct VerificationValue1Choice {
    #[yaserde(rename = "TxtVal")]
    #[cfg_attr(feature = "serde", serde(rename = "TxtVal"))]
    pub txt_val: Option<Max2048Text>,
    #[yaserde(rename = "BinryVal")]
    #[cfg_attr(feature = "serde", serde(rename = "BinryVal"))]
    pub binry_val: Option<Max5000Binary>,
    #[yaserde(rename = "HexBinryVal")]
    #[cfg_attr(feature = "serde", serde(rename = "HexBinryVal"))]
    pub hex_binry_val: Option<Max9999HexBinaryText>,
    #[yaserde(rename = "PINData")]
    #[cfg_attr(feature = "serde", serde(rename = "PINData"))]
    pub pindata: Option<Pindata1>,
}

impl Validate for VerificationValue1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cain.001.001.02")]
pub struct Wallet1 {
    #[yaserde(rename = "Prvdr")]
    #[cfg_attr(feature = "serde", serde(rename = "Prvdr"))]
    pub prvdr: PartyIdentification197,

    #[yaserde(rename = "AddtlWlltData")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlWlltData"))]
    pub addtl_wllt_data: Max256Text,
}

impl Validate for Wallet1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct YesNoIndicator (pub bool);
crate::simple_type!(YesNoIndicator);

impl Validate for YesNoIndicator {}

impl crate::MxMessage for Document {
    const BUSINESS_AREA: crate::BusinessArea = crate::BusinessArea::cain;
    const FUNCTIONALITY: &'static str = "001";
    const VARIANT: &'static str = "001";
    const VERSION: &'static str = "02";
    const MESSAGE_NAME: &'static str = "cain.001.001.02";
    const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:cain.001.001.02";
}