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

pub enum ActionTaken1Code {
    #[yaserde(rename = "ACCP")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCP"))]
    Accp,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "RJCT")]
    #[cfg_attr(feature = "serde", serde(rename = "RJCT"))]
    Rjct,
    #[yaserde(rename = "WARN")]
    #[cfg_attr(feature = "serde", serde(rename = "WARN"))]
    Warn,
    __Unknown__(String),
}

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

impl Validate for ActionTaken1Code {}



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

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

impl Validate for AdditionalData1 {}


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

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

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

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

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

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

impl Validate for AdditionalFee1 {}


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

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

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

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


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

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

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

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

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

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

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

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

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

impl Validate for Address1 {}


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

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

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

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

impl Validate for BatchManagementInformation1 {}


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

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

    #[yaserde(rename = "PANAcctRg")]
    #[cfg_attr(feature = "serde", serde(rename = "PANAcctRg"))]
    pub pan_acct_rg: Max19NumericText,

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


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

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

impl Validate for CardProgrammeMode1 {}


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

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

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

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

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

impl Validate for Cardholder15 {}


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

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

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

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

impl Validate for CardholderName1 {}


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

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

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

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

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

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

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

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

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

impl Validate for Contact1 {}


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

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

impl Validate for ContentInformationType20 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cafr.003.001.01")]
pub struct Context8 {
    #[yaserde(rename = "TxCntxt")]
    #[cfg_attr(feature = "serde", serde(rename = "TxCntxt"))]
    pub tx_cntxt: TransactionContext5,
}

impl Validate for Context8 {}


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

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

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

impl Validate for Credentials1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cafr.003.001.01")]
pub struct Document {
    #[yaserde(rename = "FrdDspstnInitn")]
    #[cfg_attr(feature = "serde", serde(rename = "FrdDspstnInitn"))]
    pub frd_dspstn_initn: FraudDispositionInitiationV01,
}

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:cafr.003.001.01")]
pub struct Environment10 {
    #[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 = "Card")]
    #[cfg_attr(feature = "serde", serde(rename = "Card"))]
    pub card: CardData3,

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

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

impl Validate for Environment10 {}


#[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 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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cafr.003.001.01")]
pub struct FeeAmount2 {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: ImpliedCurrencyAndAmount,

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

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

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

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

impl Validate for FeeAmount2 {}


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

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

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

    #[yaserde(rename = "FrdDspstnSts")]
    #[cfg_attr(feature = "serde", serde(rename = "FrdDspstnSts"))]
    pub frd_dspstn_sts: FraudDispositionStatus1,

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

impl Validate for FraudDispositionInitiation1 {}


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

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

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

impl Validate for FraudDispositionInitiationV01 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cafr.003.001.01")]
pub struct FraudDispositionStatus1 {
    #[yaserde(rename = "ActnTaken")]
    #[cfg_attr(feature = "serde", serde(rename = "ActnTaken"))]
    pub actn_taken: ActionTaken1Code,

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

    #[yaserde(rename = "ErrData")]
    #[cfg_attr(feature = "serde", serde(rename = "ErrData"))]
    pub err_data: Vec<Max256Text>,

    #[yaserde(rename = "WrngData")]
    #[cfg_attr(feature = "serde", serde(rename = "WrngData"))]
    pub wrng_data: Vec<Max256Text>,

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

impl Validate for FraudDispositionStatus1 {}


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

pub enum FraudReportingAction1Code {
    #[yaserde(rename = "DUPL")]
    #[cfg_attr(feature = "serde", serde(rename = "DUPL"))]
    Dupl,
    #[yaserde(rename = "CLSE")]
    #[cfg_attr(feature = "serde", serde(rename = "CLSE"))]
    Clse,
    #[yaserde(rename = "NEWF")]
    #[cfg_attr(feature = "serde", serde(rename = "NEWF"))]
    Newf,
    #[yaserde(rename = "OTHN")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHN"))]
    Othn,
    #[yaserde(rename = "OTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHP"))]
    Othp,
    #[yaserde(rename = "REOP")]
    #[cfg_attr(feature = "serde", serde(rename = "REOP"))]
    Reop,
    #[yaserde(rename = "UPDT")]
    #[cfg_attr(feature = "serde", serde(rename = "UPDT"))]
    Updt,
    __Unknown__(String),
}

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

impl Validate for FraudReportingAction1Code {}



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

pub enum FraudType1Code {
    #[yaserde(rename = "ACTO")]
    #[cfg_attr(feature = "serde", serde(rename = "ACTO"))]
    Acto,
    #[yaserde(rename = "CWUI")]
    #[cfg_attr(feature = "serde", serde(rename = "CWUI"))]
    Cwui,
    #[yaserde(rename = "CRNT")]
    #[cfg_attr(feature = "serde", serde(rename = "CRNT"))]
    Crnt,
    #[yaserde(rename = "FRAC")]
    #[cfg_attr(feature = "serde", serde(rename = "FRAC"))]
    Frac,
    #[yaserde(rename = "FRAP")]
    #[cfg_attr(feature = "serde", serde(rename = "FRAP"))]
    Frap,
    #[yaserde(rename = "CWKA")]
    #[cfg_attr(feature = "serde", serde(rename = "CWKA"))]
    Cwka,
    #[yaserde(rename = "CRDL")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDL"))]
    Crdl,
    #[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 = "CRDS")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDS"))]
    Crds,
    #[yaserde(rename = "CNPA")]
    #[cfg_attr(feature = "serde", serde(rename = "CNPA"))]
    Cnpa,
    #[yaserde(rename = "MUFD")]
    #[cfg_attr(feature = "serde", serde(rename = "MUFD"))]
    Mufd,
    #[yaserde(rename = "COSN")]
    #[cfg_attr(feature = "serde", serde(rename = "COSN"))]
    Cosn,
    __Unknown__(String),
}

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

impl Validate for FraudType1Code {}



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

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

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

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

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

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

impl Validate for GenericIdentification172 {}


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

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


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

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

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

impl Validate for Identification2Code {}



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

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

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

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

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

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

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

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

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

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

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

impl Validate for Macdata1 {}


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Validate for MessageFunction29Code {}



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

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

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

impl Validate for OutputFormat4Code {}



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

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

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

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

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

impl Validate for PartyIdentification197 {}


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

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

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

impl Validate for PartyType17Code {}



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

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

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

impl Validate for PartyType18Code {}



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

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

impl Validate for PartyType19Code {}



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

pub enum PartyType25Code {
    #[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,
    #[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 PartyType25Code {
    fn default() -> PartyType25Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for PartyType25Code {}



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

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

impl Validate for PlusOrMinusIndicator {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cafr.003.001.01")]
pub struct ReportedFraud2 {
    #[yaserde(rename = "FrdTp")]
    #[cfg_attr(feature = "serde", serde(rename = "FrdTp"))]
    pub frd_tp: FraudType1Code,

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

    #[yaserde(rename = "FrdRptgActn")]
    #[cfg_attr(feature = "serde", serde(rename = "FrdRptgActn"))]
    pub frd_rptg_actn: FraudReportingAction1Code,

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

    #[yaserde(rename = "RptgNtty")]
    #[cfg_attr(feature = "serde", serde(rename = "RptgNtty"))]
    pub rptg_ntty: PartyType25Code,

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

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

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

impl Validate for ReportedFraud2 {}


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

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

impl Validate for SupplementaryData1 {}


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

impl Validate for SupplementaryDataEnvelope1 {}


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

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

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

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

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

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

impl Validate for Token1 {}


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

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

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

impl Validate for Traceability7 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cafr.003.001.01")]
pub struct Transaction80 {
    #[yaserde(rename = "FrdTxId")]
    #[cfg_attr(feature = "serde", serde(rename = "FrdTxId"))]
    pub frd_tx_id: Max70Text,

    #[yaserde(rename = "RptdFrd")]
    #[cfg_attr(feature = "serde", serde(rename = "RptdFrd"))]
    pub rptd_frd: ReportedFraud2,

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

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

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

impl Validate for Transaction80 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:cafr.003.001.01")]
pub struct TransactionContext5 {
    #[yaserde(rename = "CardPrgrmmApld")]
    #[cfg_attr(feature = "serde", serde(rename = "CardPrgrmmApld"))]
    pub card_prgrmm_apld: CardProgrammeMode1,
}

impl Validate for TransactionContext5 {}


#[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:cafr.003.001.01")]

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

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

impl Validate for TypeOfAmount10Code {}



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

pub enum UserInterface8Code {
    #[yaserde(rename = "DSPU")]
    #[cfg_attr(feature = "serde", serde(rename = "DSPU"))]
    Dspu,
    #[yaserde(rename = "FILE")]
    #[cfg_attr(feature = "serde", serde(rename = "FILE"))]
    File,
    #[yaserde(rename = "LOGF")]
    #[cfg_attr(feature = "serde", serde(rename = "LOGF"))]
    Logf,
    #[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 UserInterface8Code {
    fn default() -> UserInterface8Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for UserInterface8Code {}

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