rust_iso20022 0.1.0

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

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

impl Validate for ActiveCurrencyAndAmountSimpleType {
    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:colr.013.001.04")]
pub struct ActiveCurrencyAndAmount {
    #[yaserde(text)]
    pub value: String,
    #[yaserde(attribute, rename = "Ccy")]
    #[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
    pub ccy: ActiveCurrencyCode,
}

impl Validate for ActiveCurrencyAndAmount {}


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

impl Validate for ActiveCurrencyCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:colr.013.001.04")]
pub struct Agreement4 {
    #[yaserde(rename = "AgrmtDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "AgrmtDtls"))]
    pub agrmt_dtls: Max140Text,

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

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

    #[yaserde(rename = "BaseCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "BaseCcy"))]
    pub base_ccy: ActiveCurrencyCode,

    #[yaserde(rename = "AgrmtFrmwk")]
    #[cfg_attr(feature = "serde", serde(rename = "AgrmtFrmwk"))]
    pub agrmt_frmwk: AgreementFramework1Choice,
}

impl Validate for Agreement4 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:colr.013.001.04")]
pub struct AgreementFramework1Choice {
    #[yaserde(rename = "AgrmtFrmwk")]
    #[cfg_attr(feature = "serde", serde(rename = "AgrmtFrmwk"))]
    pub agrmt_frmwk: Option<AgreementFramework1Code>,
    #[yaserde(rename = "PrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
    pub prtry_id: Option<GenericIdentification30>,
}

impl Validate for AgreementFramework1Choice {}




#[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:colr.013.001.04")]

pub enum AgreementFramework1Code {
    #[yaserde(rename = "FBAA")]
    #[cfg_attr(feature = "serde", serde(rename = "FBAA"))]
    Fbaa,
    #[yaserde(rename = "BBAA")]
    #[cfg_attr(feature = "serde", serde(rename = "BBAA"))]
    Bbaa,
    #[yaserde(rename = "DERV")]
    #[cfg_attr(feature = "serde", serde(rename = "DERV"))]
    Derv,
    #[yaserde(rename = "ISDA")]
    #[cfg_attr(feature = "serde", serde(rename = "ISDA"))]
    Isda,
    #[yaserde(rename = "NONR")]
    #[cfg_attr(feature = "serde", serde(rename = "NONR"))]
    Nonr,
    __Unknown__(String),
}

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

impl Validate for AgreementFramework1Code {}



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

impl Validate for AnyBICIdentifier {}
#[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:colr.013.001.04")]

pub enum CalculationMethod1Code {
    #[yaserde(rename = "SIMP")]
    #[cfg_attr(feature = "serde", serde(rename = "SIMP"))]
    Simp,
    #[yaserde(rename = "COMP")]
    #[cfg_attr(feature = "serde", serde(rename = "COMP"))]
    Comp,
    __Unknown__(String),
}

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

impl Validate for CalculationMethod1Code {}



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

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

impl Validate for CollateralAccount2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:colr.013.001.04")]
pub struct CollateralAccountIdentificationType2Choice {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: Option<CollateralAccountType1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification36>,
}

impl Validate for CollateralAccountIdentificationType2Choice {}




#[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:colr.013.001.04")]

pub enum CollateralAccountType1Code {
    #[yaserde(rename = "HOUS")]
    #[cfg_attr(feature = "serde", serde(rename = "HOUS"))]
    Hous,
    #[yaserde(rename = "CLIE")]
    #[cfg_attr(feature = "serde", serde(rename = "CLIE"))]
    Clie,
    #[yaserde(rename = "LIPR")]
    #[cfg_attr(feature = "serde", serde(rename = "LIPR"))]
    Lipr,
    #[yaserde(rename = "MGIN")]
    #[cfg_attr(feature = "serde", serde(rename = "MGIN"))]
    Mgin,
    #[yaserde(rename = "DFLT")]
    #[cfg_attr(feature = "serde", serde(rename = "DFLT"))]
    Dflt,
    __Unknown__(String),
}

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

impl Validate for CollateralAccountType1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:colr.013.001.04")]
pub struct CollateralBalance1 {
    #[yaserde(rename = "HeldByPtyA")]
    #[cfg_attr(feature = "serde", serde(rename = "HeldByPtyA"))]
    pub held_by_pty_a: ActiveCurrencyAndAmount,

    #[yaserde(rename = "HeldByPtyB")]
    #[cfg_attr(feature = "serde", serde(rename = "HeldByPtyB"))]
    pub held_by_pty_b: ActiveCurrencyAndAmount,
}

impl Validate for CollateralBalance1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:colr.013.001.04")]
pub struct CollateralPurpose1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<CollateralPurpose1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification30>,
}

impl Validate for CollateralPurpose1Choice {}




#[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:colr.013.001.04")]

pub enum CollateralPurpose1Code {
    #[yaserde(rename = "VAMA")]
    #[cfg_attr(feature = "serde", serde(rename = "VAMA"))]
    Vama,
    #[yaserde(rename = "SINA")]
    #[cfg_attr(feature = "serde", serde(rename = "SINA"))]
    Sina,
    __Unknown__(String),
}

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

impl Validate for CollateralPurpose1Code {}



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

impl Validate for CountryCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:colr.013.001.04")]
pub struct DateAndDateTimeChoice {
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Option<Isodate>,
    #[yaserde(rename = "DtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "DtTm"))]
    pub dt_tm: Option<IsodateTime>,
}

impl Validate for DateAndDateTimeChoice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:colr.013.001.04")]
pub struct DatePeriodDetails {
    #[yaserde(rename = "FrDt")]
    #[cfg_attr(feature = "serde", serde(rename = "FrDt"))]
    pub fr_dt: Isodate,

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

impl Validate for DatePeriodDetails {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:colr.013.001.04")]
pub struct Document {
    #[yaserde(rename = "IntrstPmtReq")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstPmtReq"))]
    pub intrst_pmt_req: InterestPaymentRequestV04,
}

impl Validate for Document {}


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

impl Validate for Exact4AlphaNumericText {}
#[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:colr.013.001.04")]

pub enum ExposureType5Code {
    #[yaserde(rename = "BFWD")]
    #[cfg_attr(feature = "serde", serde(rename = "BFWD"))]
    Bfwd,
    #[yaserde(rename = "PAYM")]
    #[cfg_attr(feature = "serde", serde(rename = "PAYM"))]
    Paym,
    #[yaserde(rename = "CCPC")]
    #[cfg_attr(feature = "serde", serde(rename = "CCPC"))]
    Ccpc,
    #[yaserde(rename = "COMM")]
    #[cfg_attr(feature = "serde", serde(rename = "COMM"))]
    Comm,
    #[yaserde(rename = "CRDS")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDS"))]
    Crds,
    #[yaserde(rename = "CRTL")]
    #[cfg_attr(feature = "serde", serde(rename = "CRTL"))]
    Crtl,
    #[yaserde(rename = "CRSP")]
    #[cfg_attr(feature = "serde", serde(rename = "CRSP"))]
    Crsp,
    #[yaserde(rename = "CCIR")]
    #[cfg_attr(feature = "serde", serde(rename = "CCIR"))]
    Ccir,
    #[yaserde(rename = "CRPR")]
    #[cfg_attr(feature = "serde", serde(rename = "CRPR"))]
    Crpr,
    #[yaserde(rename = "EQUI")]
    #[cfg_attr(feature = "serde", serde(rename = "EQUI"))]
    Equi,
    #[yaserde(rename = "EQPT")]
    #[cfg_attr(feature = "serde", serde(rename = "EQPT"))]
    Eqpt,
    #[yaserde(rename = "EQUS")]
    #[cfg_attr(feature = "serde", serde(rename = "EQUS"))]
    Equs,
    #[yaserde(rename = "EXTD")]
    #[cfg_attr(feature = "serde", serde(rename = "EXTD"))]
    Extd,
    #[yaserde(rename = "EXPT")]
    #[cfg_attr(feature = "serde", serde(rename = "EXPT"))]
    Expt,
    #[yaserde(rename = "FIXI")]
    #[cfg_attr(feature = "serde", serde(rename = "FIXI"))]
    Fixi,
    #[yaserde(rename = "FORX")]
    #[cfg_attr(feature = "serde", serde(rename = "FORX"))]
    Forx,
    #[yaserde(rename = "FORW")]
    #[cfg_attr(feature = "serde", serde(rename = "FORW"))]
    Forw,
    #[yaserde(rename = "FUTR")]
    #[cfg_attr(feature = "serde", serde(rename = "FUTR"))]
    Futr,
    #[yaserde(rename = "OPTN")]
    #[cfg_attr(feature = "serde", serde(rename = "OPTN"))]
    Optn,
    #[yaserde(rename = "LIQU")]
    #[cfg_attr(feature = "serde", serde(rename = "LIQU"))]
    Liqu,
    #[yaserde(rename = "OTCD")]
    #[cfg_attr(feature = "serde", serde(rename = "OTCD"))]
    Otcd,
    #[yaserde(rename = "REPO")]
    #[cfg_attr(feature = "serde", serde(rename = "REPO"))]
    Repo,
    #[yaserde(rename = "RVPO")]
    #[cfg_attr(feature = "serde", serde(rename = "RVPO"))]
    Rvpo,
    #[yaserde(rename = "SLOA")]
    #[cfg_attr(feature = "serde", serde(rename = "SLOA"))]
    Sloa,
    #[yaserde(rename = "SBSC")]
    #[cfg_attr(feature = "serde", serde(rename = "SBSC"))]
    Sbsc,
    #[yaserde(rename = "SCRP")]
    #[cfg_attr(feature = "serde", serde(rename = "SCRP"))]
    Scrp,
    #[yaserde(rename = "SLEB")]
    #[cfg_attr(feature = "serde", serde(rename = "SLEB"))]
    Sleb,
    #[yaserde(rename = "SHSL")]
    #[cfg_attr(feature = "serde", serde(rename = "SHSL"))]
    Shsl,
    #[yaserde(rename = "SCIR")]
    #[cfg_attr(feature = "serde", serde(rename = "SCIR"))]
    Scir,
    #[yaserde(rename = "SCIE")]
    #[cfg_attr(feature = "serde", serde(rename = "SCIE"))]
    Scie,
    #[yaserde(rename = "SWPT")]
    #[cfg_attr(feature = "serde", serde(rename = "SWPT"))]
    Swpt,
    #[yaserde(rename = "TBAS")]
    #[cfg_attr(feature = "serde", serde(rename = "TBAS"))]
    Tbas,
    #[yaserde(rename = "TRBD")]
    #[cfg_attr(feature = "serde", serde(rename = "TRBD"))]
    Trbd,
    #[yaserde(rename = "TRCP")]
    #[cfg_attr(feature = "serde", serde(rename = "TRCP"))]
    Trcp,
    __Unknown__(String),
}

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

impl Validate for ExposureType5Code {}



#[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:colr.013.001.04")]

pub enum Frequency1Code {
    #[yaserde(rename = "YEAR")]
    #[cfg_attr(feature = "serde", serde(rename = "YEAR"))]
    Year,
    #[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 = "WEEK")]
    #[cfg_attr(feature = "serde", serde(rename = "WEEK"))]
    Week,
    #[yaserde(rename = "DAIL")]
    #[cfg_attr(feature = "serde", serde(rename = "DAIL"))]
    Dail,
    #[yaserde(rename = "ADHO")]
    #[cfg_attr(feature = "serde", serde(rename = "ADHO"))]
    Adho,
    #[yaserde(rename = "INDA")]
    #[cfg_attr(feature = "serde", serde(rename = "INDA"))]
    Inda,
    __Unknown__(String),
}

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

impl Validate for Frequency1Code {}



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

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

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

impl Validate for GenericIdentification30 {}


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

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

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

impl Validate for GenericIdentification36 {}


#[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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:colr.013.001.04")]
pub struct InterestAmount1 {
    #[yaserde(rename = "IntrstReqSeq")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstReqSeq"))]
    pub intrst_req_seq: InterestRequestSequence1Code,

    #[yaserde(rename = "IntrstPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstPrd"))]
    pub intrst_prd: DatePeriodDetails,

    #[yaserde(rename = "AcrdIntrstAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "AcrdIntrstAmt"))]
    pub acrd_intrst_amt: ActiveCurrencyAndAmount,

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

    #[yaserde(rename = "IntrstMtd")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstMtd"))]
    pub intrst_mtd: InterestMethod1Code,

    #[yaserde(rename = "IntrstRate")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstRate"))]
    pub intrst_rate: InterestRate1Choice,

    #[yaserde(rename = "DayCntBsis")]
    #[cfg_attr(feature = "serde", serde(rename = "DayCntBsis"))]
    pub day_cnt_bsis: InterestComputationMethod2Code,

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

    #[yaserde(rename = "ClctnMtd")]
    #[cfg_attr(feature = "serde", serde(rename = "ClctnMtd"))]
    pub clctn_mtd: CalculationMethod1Code,

    #[yaserde(rename = "ClctnFrqcy")]
    #[cfg_attr(feature = "serde", serde(rename = "ClctnFrqcy"))]
    pub clctn_frqcy: Frequency1Code,

    #[yaserde(rename = "CollPurp")]
    #[cfg_attr(feature = "serde", serde(rename = "CollPurp"))]
    pub coll_purp: CollateralPurpose1Choice,

    #[yaserde(rename = "OpngCollBal")]
    #[cfg_attr(feature = "serde", serde(rename = "OpngCollBal"))]
    pub opng_coll_bal: CollateralBalance1,

    #[yaserde(rename = "ClsgCollBal")]
    #[cfg_attr(feature = "serde", serde(rename = "ClsgCollBal"))]
    pub clsg_coll_bal: CollateralBalance1,

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

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

    #[yaserde(rename = "RefDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "RefDtls"))]
    pub ref_dtls: Reference20,
}

impl Validate for InterestAmount1 {}


#[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:colr.013.001.04")]

pub enum InterestComputationMethod2Code {
    A001,
    A002,
    A003,
    A004,
    A005,
    A006,
    A007,
    A008,
    A009,
    A010,
    A011,
    A012,
    A013,
    A014,
    #[yaserde(rename = "NARR")]
    #[cfg_attr(feature = "serde", serde(rename = "NARR"))]
    Narr,
    __Unknown__(String),
}

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

impl Validate for InterestComputationMethod2Code {}



#[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:colr.013.001.04")]

pub enum InterestMethod1Code {
    #[yaserde(rename = "PHYS")]
    #[cfg_attr(feature = "serde", serde(rename = "PHYS"))]
    Phys,
    #[yaserde(rename = "ROLL")]
    #[cfg_attr(feature = "serde", serde(rename = "ROLL"))]
    Roll,
    __Unknown__(String),
}

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

impl Validate for InterestMethod1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:colr.013.001.04")]
pub struct InterestPaymentRequestV04 {
    #[yaserde(rename = "TxId")]
    #[cfg_attr(feature = "serde", serde(rename = "TxId"))]
    pub tx_id: Max35Text,

    #[yaserde(rename = "Oblgtn")]
    #[cfg_attr(feature = "serde", serde(rename = "Oblgtn"))]
    pub oblgtn: Obligation4,

    #[yaserde(rename = "Agrmt")]
    #[cfg_attr(feature = "serde", serde(rename = "Agrmt"))]
    pub agrmt: Agreement4,

    #[yaserde(rename = "IntrstDueToA")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstDueToA"))]
    pub intrst_due_to_a: InterestAmount1,

    #[yaserde(rename = "IntrstDueToB")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstDueToB"))]
    pub intrst_due_to_b: InterestAmount1,

    #[yaserde(rename = "NetAmtDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "NetAmtDtls"))]
    pub net_amt_dtls: InterestResult1,

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

impl Validate for InterestPaymentRequestV04 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:colr.013.001.04")]
pub struct InterestRate1Choice {
    #[yaserde(rename = "FxdIntrstRate")]
    #[cfg_attr(feature = "serde", serde(rename = "FxdIntrstRate"))]
    pub fxd_intrst_rate: Option<PercentageRate>,
    #[yaserde(rename = "VarblIntrstRate")]
    #[cfg_attr(feature = "serde", serde(rename = "VarblIntrstRate"))]
    pub varbl_intrst_rate: Option<VariableInterest1Rate>,
}

impl Validate for InterestRate1Choice {}




#[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:colr.013.001.04")]

pub enum InterestRequestSequence1Code {
    #[yaserde(rename = "INIT")]
    #[cfg_attr(feature = "serde", serde(rename = "INIT"))]
    Init,
    #[yaserde(rename = "UPDA")]
    #[cfg_attr(feature = "serde", serde(rename = "UPDA"))]
    Upda,
    __Unknown__(String),
}

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

impl Validate for InterestRequestSequence1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:colr.013.001.04")]
pub struct InterestResult1 {
    #[yaserde(rename = "IntrstDueToA")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstDueToA"))]
    pub intrst_due_to_a: ActiveCurrencyAndAmount,

    #[yaserde(rename = "IntrstDueToB")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstDueToB"))]
    pub intrst_due_to_b: ActiveCurrencyAndAmount,

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

    #[yaserde(rename = "IntrstMtd")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstMtd"))]
    pub intrst_mtd: InterestMethod1Code,

    #[yaserde(rename = "OpngCollBal")]
    #[cfg_attr(feature = "serde", serde(rename = "OpngCollBal"))]
    pub opng_coll_bal: CollateralBalance1,

    #[yaserde(rename = "ClsgCollBal")]
    #[cfg_attr(feature = "serde", serde(rename = "ClsgCollBal"))]
    pub clsg_coll_bal: CollateralBalance1,
}

impl Validate for InterestResult1 {}


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

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

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

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

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

impl Validate for NameAndAddress6 {}


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

impl Validate for Number {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:colr.013.001.04")]
pub struct Obligation4 {
    #[yaserde(rename = "PtyA")]
    #[cfg_attr(feature = "serde", serde(rename = "PtyA"))]
    pub pty_a: PartyIdentification100Choice,

    #[yaserde(rename = "SvcgPtyA")]
    #[cfg_attr(feature = "serde", serde(rename = "SvcgPtyA"))]
    pub svcg_pty_a: PartyIdentification100Choice,

    #[yaserde(rename = "PtyB")]
    #[cfg_attr(feature = "serde", serde(rename = "PtyB"))]
    pub pty_b: PartyIdentification100Choice,

    #[yaserde(rename = "SvcgPtyB")]
    #[cfg_attr(feature = "serde", serde(rename = "SvcgPtyB"))]
    pub svcg_pty_b: PartyIdentification100Choice,

    #[yaserde(rename = "CollAcctId")]
    #[cfg_attr(feature = "serde", serde(rename = "CollAcctId"))]
    pub coll_acct_id: CollateralAccount2,

    #[yaserde(rename = "XpsrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "XpsrTp"))]
    pub xpsr_tp: ExposureType5Code,

    #[yaserde(rename = "ValtnDt")]
    #[cfg_attr(feature = "serde", serde(rename = "ValtnDt"))]
    pub valtn_dt: DateAndDateTimeChoice,
}

impl Validate for Obligation4 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:colr.013.001.04")]
pub struct PartyIdentification100Choice {
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_b_i_c: Option<AnyBICIdentifier>,
    #[yaserde(rename = "PrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
    pub prtry_id: Option<GenericIdentification36>,
    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: Option<NameAndAddress6>,
}

impl Validate for PartyIdentification100Choice {}




#[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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:colr.013.001.04")]
pub struct PostalAddress2 {
    #[yaserde(rename = "StrtNm")]
    #[cfg_attr(feature = "serde", serde(rename = "StrtNm"))]
    pub strt_nm: Max70Text,

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

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

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

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

impl Validate for PostalAddress2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:colr.013.001.04")]
pub struct Reference20 {
    #[yaserde(rename = "IntrstPmtReqId")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstPmtReqId"))]
    pub intrst_pmt_req_id: Max35Text,

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

impl Validate for Reference20 {}


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

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

impl Validate for VariableInterest1Rate {}


#[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::colr;
    const FUNCTIONALITY: &'static str = "013";
    const VARIANT: &'static str = "001";
    const VERSION: &'static str = "04";
    const MESSAGE_NAME: &'static str = "colr.013.001.04";
    const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:colr.013.001.04";
}