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.016.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)]
pub struct ActiveOrHistoricCurrencyAnd13DecimalAmountSimpleType (pub String);
crate::simple_type!(ActiveOrHistoricCurrencyAnd13DecimalAmountSimpleType);

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

impl Validate for ActiveOrHistoricCurrencyAnd13DecimalAmount {}


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

impl Validate for ActiveOrHistoricCurrencyCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.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.016.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.016.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 AnyBICDec2014Identifier (pub String);
crate::simple_type!(AnyBICDec2014Identifier);

impl Validate for AnyBICDec2014Identifier {}
#[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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:colr.016.001.04")]

pub enum CcpmemberType1Code {
    #[yaserde(rename = "ACMB")]
    #[cfg_attr(feature = "serde", serde(rename = "ACMB"))]
    Acmb,
    #[yaserde(rename = "CCPX")]
    #[cfg_attr(feature = "serde", serde(rename = "CCPX"))]
    Ccpx,
    #[yaserde(rename = "DCMB")]
    #[cfg_attr(feature = "serde", serde(rename = "DCMB"))]
    Dcmb,
    #[yaserde(rename = "FCMC")]
    #[cfg_attr(feature = "serde", serde(rename = "FCMC"))]
    Fcmc,
    #[yaserde(rename = "GCMB")]
    #[cfg_attr(feature = "serde", serde(rename = "GCMB"))]
    Gcmb,
    #[yaserde(rename = "SCMB")]
    #[cfg_attr(feature = "serde", serde(rename = "SCMB"))]
    Scmb,
    __Unknown__(String),
}

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

impl Validate for CcpmemberType1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.04")]
pub struct CashCollateral4 {
    #[yaserde(rename = "AsstNb")]
    #[cfg_attr(feature = "serde", serde(rename = "AsstNb"))]
    pub asst_nb: Max35Text,

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

    #[yaserde(rename = "DpstTp")]
    #[cfg_attr(feature = "serde", serde(rename = "DpstTp"))]
    pub dpst_tp: DepositType1Code,

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

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

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

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

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

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

impl Validate for CashCollateral4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.04")]
pub struct Collateral43 {
    #[yaserde(rename = "AcctId")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctId"))]
    pub acct_id: CollateralAccount3,

    #[yaserde(rename = "RptSummry")]
    #[cfg_attr(feature = "serde", serde(rename = "RptSummry"))]
    pub rpt_summry: Summary2,

    #[yaserde(rename = "CollValtn")]
    #[cfg_attr(feature = "serde", serde(rename = "CollValtn"))]
    pub coll_valtn: Vec<CollateralValuation12>,
}

impl Validate for Collateral43 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.04")]
pub struct CollateralAccount3 {
    #[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: CollateralAccountIdentificationType3Choice,

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

impl Validate for CollateralAccount3 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.04")]
pub struct CollateralAccountIdentificationType3Choice {
    #[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 CollateralAccountIdentificationType3Choice {}




#[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.016.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.016.001.04")]
pub struct CollateralAmount1 {
    #[yaserde(rename = "CollAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "CollAmt"))]
    pub coll_amt: ActiveCurrencyAndAmount,

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

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

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

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

impl Validate for CollateralAmount1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.04")]
pub struct CollateralAndExposureReportV04 {
    #[yaserde(rename = "RptParams")]
    #[cfg_attr(feature = "serde", serde(rename = "RptParams"))]
    pub rpt_params: ReportParameters6,

    #[yaserde(rename = "Pgntn")]
    #[cfg_attr(feature = "serde", serde(rename = "Pgntn"))]
    pub pgntn: Pagination1,

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

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

    #[yaserde(rename = "CollRpt")]
    #[cfg_attr(feature = "serde", serde(rename = "CollRpt"))]
    pub coll_rpt: Vec<Collateral43>,

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

impl Validate for CollateralAndExposureReportV04 {}


#[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.016.001.04")]

pub enum CollateralAppliedExcess1Code {
    #[yaserde(rename = "APLD")]
    #[cfg_attr(feature = "serde", serde(rename = "APLD"))]
    Apld,
    #[yaserde(rename = "EXCS")]
    #[cfg_attr(feature = "serde", serde(rename = "EXCS"))]
    Excs,
    __Unknown__(String),
}

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

impl Validate for CollateralAppliedExcess1Code {}



#[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.016.001.04")]

pub enum CollateralDirection1Code {
    #[yaserde(rename = "CDPA")]
    #[cfg_attr(feature = "serde", serde(rename = "CDPA"))]
    Cdpa,
    #[yaserde(rename = "CDPB")]
    #[cfg_attr(feature = "serde", serde(rename = "CDPB"))]
    Cdpb,
    __Unknown__(String),
}

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

impl Validate for CollateralDirection1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.04")]
pub struct CollateralOwnership3 {
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: YesNoIndicator,

    #[yaserde(rename = "ClntNm")]
    #[cfg_attr(feature = "serde", serde(rename = "ClntNm"))]
    pub clnt_nm: PartyIdentification178Choice,
}

impl Validate for CollateralOwnership3 {}


#[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.016.001.04")]

pub enum CollateralType8Code {
    #[yaserde(rename = "COMO")]
    #[cfg_attr(feature = "serde", serde(rename = "COMO"))]
    Como,
    #[yaserde(rename = "CCCL")]
    #[cfg_attr(feature = "serde", serde(rename = "CCCL"))]
    Cccl,
    #[yaserde(rename = "CEMC")]
    #[cfg_attr(feature = "serde", serde(rename = "CEMC"))]
    Cemc,
    #[yaserde(rename = "CXCC")]
    #[cfg_attr(feature = "serde", serde(rename = "CXCC"))]
    Cxcc,
    #[yaserde(rename = "CFTD")]
    #[cfg_attr(feature = "serde", serde(rename = "CFTD"))]
    Cftd,
    #[yaserde(rename = "CFTI")]
    #[cfg_attr(feature = "serde", serde(rename = "CFTI"))]
    Cfti,
    #[yaserde(rename = "CTRC")]
    #[cfg_attr(feature = "serde", serde(rename = "CTRC"))]
    Ctrc,
    #[yaserde(rename = "CASH")]
    #[cfg_attr(feature = "serde", serde(rename = "CASH"))]
    Cash,
    #[yaserde(rename = "LCRE")]
    #[cfg_attr(feature = "serde", serde(rename = "LCRE"))]
    Lcre,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "SECU")]
    #[cfg_attr(feature = "serde", serde(rename = "SECU"))]
    Secu,
    #[yaserde(rename = "CTCO")]
    #[cfg_attr(feature = "serde", serde(rename = "CTCO"))]
    Ctco,
    #[yaserde(rename = "CCVR")]
    #[cfg_attr(feature = "serde", serde(rename = "CCVR"))]
    Ccvr,
    __Unknown__(String),
}

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

impl Validate for CollateralType8Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.04")]
pub struct CollateralValuation12 {
    #[yaserde(rename = "CollId")]
    #[cfg_attr(feature = "serde", serde(rename = "CollId"))]
    pub coll_id: Max35Text,

    #[yaserde(rename = "CollTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CollTp"))]
    pub coll_tp: CollateralType8Code,

    #[yaserde(rename = "CollDrctn")]
    #[cfg_attr(feature = "serde", serde(rename = "CollDrctn"))]
    pub coll_drctn: CollateralDirection1Code,

    #[yaserde(rename = "SttlmSts")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmSts"))]
    pub sttlm_sts: SettlementStatus3Code,

    #[yaserde(rename = "ApldXcssInd")]
    #[cfg_attr(feature = "serde", serde(rename = "ApldXcssInd"))]
    pub apld_xcss_ind: CollateralAppliedExcess1Code,

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

    #[yaserde(rename = "ValtnAmts")]
    #[cfg_attr(feature = "serde", serde(rename = "ValtnAmts"))]
    pub valtn_amts: CollateralAmount1,

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

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

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

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

    #[yaserde(rename = "SctiesColl")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesColl"))]
    pub scties_coll: SecuritiesCollateral9,

    #[yaserde(rename = "CshColl")]
    #[cfg_attr(feature = "serde", serde(rename = "CshColl"))]
    pub csh_coll: CashCollateral4,

    #[yaserde(rename = "OthrColl")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrColl"))]
    pub othr_coll: OtherCollateral8,
}

impl Validate for CollateralValuation12 {}


#[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.016.001.04")]
pub struct DateAndDateTime2Choice {
    #[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 DateAndDateTime2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.04")]
pub struct DateCode9Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<DateType2Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification30>,
}

impl Validate for DateCode9Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.04")]
pub struct DateFormat14Choice {
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Option<Isodate>,
    #[yaserde(rename = "DtCd")]
    #[cfg_attr(feature = "serde", serde(rename = "DtCd"))]
    pub dt_cd: Option<DateCode9Choice>,
}

impl Validate for DateFormat14Choice {}




#[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.016.001.04")]

pub enum DateType2Code {
    #[yaserde(rename = "OPEN")]
    #[cfg_attr(feature = "serde", serde(rename = "OPEN"))]
    Open,
    __Unknown__(String),
}

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

impl Validate for DateType2Code {}



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

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

pub enum DepositType1Code {
    #[yaserde(rename = "FITE")]
    #[cfg_attr(feature = "serde", serde(rename = "FITE"))]
    Fite,
    #[yaserde(rename = "CALL")]
    #[cfg_attr(feature = "serde", serde(rename = "CALL"))]
    Call,
    __Unknown__(String),
}

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

impl Validate for DepositType1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.04")]
pub struct Document {
    #[yaserde(rename = "CollAndXpsrRpt")]
    #[cfg_attr(feature = "serde", serde(rename = "CollAndXpsrRpt"))]
    pub coll_and_xpsr_rpt: CollateralAndExposureReportV04,
}

impl Validate for 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:colr.016.001.04")]

pub enum EventFrequency6Code {
    #[yaserde(rename = "DAIL")]
    #[cfg_attr(feature = "serde", serde(rename = "DAIL"))]
    Dail,
    #[yaserde(rename = "INDA")]
    #[cfg_attr(feature = "serde", serde(rename = "INDA"))]
    Inda,
    #[yaserde(rename = "ONDE")]
    #[cfg_attr(feature = "serde", serde(rename = "ONDE"))]
    Onde,
    __Unknown__(String),
}

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

impl Validate for EventFrequency6Code {}



#[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.016.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.016.001.04")]

pub enum ExposureType8Code {
    #[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 = "MGLD")]
    #[cfg_attr(feature = "serde", serde(rename = "MGLD"))]
    Mgld,
    #[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 = "ESCL")]
    #[cfg_attr(feature = "serde", serde(rename = "ESCL"))]
    Escl,
    #[yaserde(rename = "SWPT")]
    #[cfg_attr(feature = "serde", serde(rename = "SWPT"))]
    Swpt,
    #[yaserde(rename = "TBAS")]
    #[cfg_attr(feature = "serde", serde(rename = "TBAS"))]
    Tbas,
    #[yaserde(rename = "ECRT")]
    #[cfg_attr(feature = "serde", serde(rename = "ECRT"))]
    Ecrt,
    #[yaserde(rename = "ECFR")]
    #[cfg_attr(feature = "serde", serde(rename = "ECFR"))]
    Ecfr,
    #[yaserde(rename = "EMLO")]
    #[cfg_attr(feature = "serde", serde(rename = "EMLO"))]
    Emlo,
    #[yaserde(rename = "EMLI")]
    #[cfg_attr(feature = "serde", serde(rename = "EMLI"))]
    Emli,
    #[yaserde(rename = "EOIM")]
    #[cfg_attr(feature = "serde", serde(rename = "EOIM"))]
    Eoim,
    #[yaserde(rename = "EOMI")]
    #[cfg_attr(feature = "serde", serde(rename = "EOMI"))]
    Eomi,
    #[yaserde(rename = "TRCP")]
    #[cfg_attr(feature = "serde", serde(rename = "TRCP"))]
    Trcp,
    #[yaserde(rename = "TRBD")]
    #[cfg_attr(feature = "serde", serde(rename = "TRBD"))]
    Trbd,
    #[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 = "EOMO")]
    #[cfg_attr(feature = "serde", serde(rename = "EOMO"))]
    Eomo,
    __Unknown__(String),
}

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

impl Validate for ExposureType8Code {}



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

impl Validate for ExternalFinancialInstrumentIdentificationType1Code {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 4 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 4 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:colr.016.001.04")]
pub struct FinancialInstrumentQuantity1Choice {
    #[yaserde(rename = "Unit")]
    #[cfg_attr(feature = "serde", serde(rename = "Unit"))]
    pub unit: Option<DecimalNumber>,
    #[yaserde(rename = "FaceAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "FaceAmt"))]
    pub face_amt: Option<ImpliedCurrencyAndAmount>,
    #[yaserde(rename = "AmtsdVal")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtsdVal"))]
    pub amtsd_val: Option<ImpliedCurrencyAndAmount>,
}

impl Validate for FinancialInstrumentQuantity1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.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.016.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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:colr.016.001.04")]
pub struct GenericIdentification78 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: GenericIdentification30,

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

impl Validate for GenericIdentification78 {}


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

impl Validate for Isinoct2015Identifier {}
#[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.016.001.04")]
pub struct IdentificationSource3Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ExternalFinancialInstrumentIdentificationType1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max35Text>,
}

impl Validate for IdentificationSource3Choice {}




#[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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:colr.016.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(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 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 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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:colr.016.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.016.001.04")]
pub struct Obligation6 {
    #[yaserde(rename = "PtyA")]
    #[cfg_attr(feature = "serde", serde(rename = "PtyA"))]
    pub pty_a: PartyIdentification242,

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

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

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

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

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

impl Validate for Obligation6 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.04")]
pub struct OtherCollateral8 {
    #[yaserde(rename = "AsstNb")]
    #[cfg_attr(feature = "serde", serde(rename = "AsstNb"))]
    pub asst_nb: Max35Text,

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

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

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

    #[yaserde(rename = "OthrTpOfColl")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrTpOfColl"))]
    pub othr_tp_of_coll: OtherTypeOfCollateral2,

    #[yaserde(rename = "CollOwnrsh")]
    #[cfg_attr(feature = "serde", serde(rename = "CollOwnrsh"))]
    pub coll_ownrsh: CollateralOwnership3,

    #[yaserde(rename = "IsseDt")]
    #[cfg_attr(feature = "serde", serde(rename = "IsseDt"))]
    pub isse_dt: DateFormat14Choice,

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

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

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

    #[yaserde(rename = "BlckdQty")]
    #[cfg_attr(feature = "serde", serde(rename = "BlckdQty"))]
    pub blckd_qty: FinancialInstrumentQuantity1Choice,

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

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

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

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

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

    #[yaserde(rename = "SfkpgPlc")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgPlc"))]
    pub sfkpg_plc: SafekeepingPlaceFormat29Choice,

    #[yaserde(rename = "SfkpgAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgAcct"))]
    pub sfkpg_acct: SecuritiesAccount19,
}

impl Validate for OtherCollateral8 {}


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

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

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

impl Validate for OtherIdentification1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.04")]
pub struct OtherTypeOfCollateral2 {
    #[yaserde(rename = "Desc")]
    #[cfg_attr(feature = "serde", serde(rename = "Desc"))]
    pub desc: Max140Text,

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

impl Validate for OtherTypeOfCollateral2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.04")]
pub struct Pagination1 {
    #[yaserde(rename = "PgNb")]
    #[cfg_attr(feature = "serde", serde(rename = "PgNb"))]
    pub pg_nb: Max5NumericText,

    #[yaserde(rename = "LastPgInd")]
    #[cfg_attr(feature = "serde", serde(rename = "LastPgInd"))]
    pub last_pg_ind: YesNoIndicator,
}

impl Validate for Pagination1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.04")]
pub struct PartyIdentification178Choice {
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_b_i_c: Option<AnyBICDec2014Identifier>,
    #[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 PartyIdentification178Choice {}




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

    #[yaserde(rename = "CCPMmbTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CCPMmbTp"))]
    pub ccp_mmb_tp: CcpmemberType1Code,
}

impl Validate for PartyIdentification242 {}


#[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.016.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.016.001.04")]
pub struct Price7 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: YieldedOrValueType1Choice,

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

impl Validate for Price7 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.04")]
pub struct PriceRateOrAmount3Choice {
    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: Option<PercentageRate>,
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<ActiveOrHistoricCurrencyAnd13DecimalAmount>,
}

impl Validate for PriceRateOrAmount3Choice {}




#[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.016.001.04")]

pub enum PriceValueType1Code {
    #[yaserde(rename = "DISC")]
    #[cfg_attr(feature = "serde", serde(rename = "DISC"))]
    Disc,
    #[yaserde(rename = "PREM")]
    #[cfg_attr(feature = "serde", serde(rename = "PREM"))]
    Prem,
    #[yaserde(rename = "PARV")]
    #[cfg_attr(feature = "serde", serde(rename = "PARV"))]
    Parv,
    __Unknown__(String),
}

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

impl Validate for PriceValueType1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.04")]
pub struct ReportParameters6 {
    #[yaserde(rename = "RptId")]
    #[cfg_attr(feature = "serde", serde(rename = "RptId"))]
    pub rpt_id: Max35Text,

    #[yaserde(rename = "RptDtAndTm")]
    #[cfg_attr(feature = "serde", serde(rename = "RptDtAndTm"))]
    pub rpt_dt_and_tm: DateAndDateTime2Choice,

    #[yaserde(rename = "Frqcy")]
    #[cfg_attr(feature = "serde", serde(rename = "Frqcy"))]
    pub frqcy: EventFrequency6Code,

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

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

impl Validate for ReportParameters6 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.04")]
pub struct ReturnExcessCash1 {
    #[yaserde(rename = "RtrXcssCshTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RtrXcssCshTp"))]
    pub rtr_xcss_csh_tp: ReturnExcessCash1Choice,

    #[yaserde(rename = "CshCollCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "CshCollCcy"))]
    pub csh_coll_ccy: ActiveOrHistoricCurrencyCode,
}

impl Validate for ReturnExcessCash1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.04")]
pub struct ReturnExcessCash1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ReturnExcessCash1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification30>,
}

impl Validate for ReturnExcessCash1Choice {}




#[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.016.001.04")]

pub enum ReturnExcessCash1Code {
    #[yaserde(rename = "RTND")]
    #[cfg_attr(feature = "serde", serde(rename = "RTND"))]
    Rtnd,
    #[yaserde(rename = "RTDN")]
    #[cfg_attr(feature = "serde", serde(rename = "RTDN"))]
    Rtdn,
    #[yaserde(rename = "SSPD")]
    #[cfg_attr(feature = "serde", serde(rename = "SSPD"))]
    Sspd,
    __Unknown__(String),
}

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

impl Validate for ReturnExcessCash1Code {}



#[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.016.001.04")]

pub enum SafekeepingPlace1Code {
    #[yaserde(rename = "CUST")]
    #[cfg_attr(feature = "serde", serde(rename = "CUST"))]
    Cust,
    #[yaserde(rename = "ICSD")]
    #[cfg_attr(feature = "serde", serde(rename = "ICSD"))]
    Icsd,
    #[yaserde(rename = "NCSD")]
    #[cfg_attr(feature = "serde", serde(rename = "NCSD"))]
    Ncsd,
    #[yaserde(rename = "SHHE")]
    #[cfg_attr(feature = "serde", serde(rename = "SHHE"))]
    Shhe,
    __Unknown__(String),
}

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

impl Validate for SafekeepingPlace1Code {}



#[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.016.001.04")]

pub enum SafekeepingPlace3Code {
    #[yaserde(rename = "SHHE")]
    #[cfg_attr(feature = "serde", serde(rename = "SHHE"))]
    Shhe,
    __Unknown__(String),
}

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

impl Validate for SafekeepingPlace3Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.04")]
pub struct SafekeepingPlaceFormat29Choice {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Option<SafekeepingPlaceTypeAndText8>,
    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: Option<CountryCode>,
    #[yaserde(rename = "TpAndId")]
    #[cfg_attr(feature = "serde", serde(rename = "TpAndId"))]
    pub tp_and_id: Option<SafekeepingPlaceTypeAndIdentification1>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification78>,
}

impl Validate for SafekeepingPlaceFormat29Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.04")]
pub struct SafekeepingPlaceTypeAndIdentification1 {
    #[yaserde(rename = "SfkpgPlcTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgPlcTp"))]
    pub sfkpg_plc_tp: SafekeepingPlace1Code,

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

impl Validate for SafekeepingPlaceTypeAndIdentification1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.04")]
pub struct SafekeepingPlaceTypeAndText8 {
    #[yaserde(rename = "SfkpgPlcTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgPlcTp"))]
    pub sfkpg_plc_tp: SafekeepingPlace3Code,

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

impl Validate for SafekeepingPlaceTypeAndText8 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.04")]
pub struct SecuritiesAccount19 {
    #[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: GenericIdentification30,

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

impl Validate for SecuritiesAccount19 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.04")]
pub struct SecuritiesCollateral9 {
    #[yaserde(rename = "AsstNb")]
    #[cfg_attr(feature = "serde", serde(rename = "AsstNb"))]
    pub asst_nb: Max35Text,

    #[yaserde(rename = "SctyId")]
    #[cfg_attr(feature = "serde", serde(rename = "SctyId"))]
    pub scty_id: SecurityIdentification19,

    #[yaserde(rename = "MtrtyDt")]
    #[cfg_attr(feature = "serde", serde(rename = "MtrtyDt"))]
    pub mtrty_dt: DateAndDateTime2Choice,

    #[yaserde(rename = "CollOwnrsh")]
    #[cfg_attr(feature = "serde", serde(rename = "CollOwnrsh"))]
    pub coll_ownrsh: CollateralOwnership3,

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

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

    #[yaserde(rename = "BlckdQty")]
    #[cfg_attr(feature = "serde", serde(rename = "BlckdQty"))]
    pub blckd_qty: FinancialInstrumentQuantity1Choice,

    #[yaserde(rename = "Pric")]
    #[cfg_attr(feature = "serde", serde(rename = "Pric"))]
    pub pric: Price7,

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

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

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

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

    #[yaserde(rename = "SfkpgAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgAcct"))]
    pub sfkpg_acct: SecuritiesAccount19,

    #[yaserde(rename = "SfkpgPlc")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgPlc"))]
    pub sfkpg_plc: SafekeepingPlaceFormat29Choice,
}

impl Validate for SecuritiesCollateral9 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.04")]
pub struct SecurityIdentification19 {
    #[yaserde(rename = "ISIN")]
    #[cfg_attr(feature = "serde", serde(rename = "ISIN"))]
    pub isin: Isinoct2015Identifier,

    #[yaserde(rename = "OthrId")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrId"))]
    pub othr_id: Vec<OtherIdentification1>,

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

impl Validate for SecurityIdentification19 {}


#[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.016.001.04")]

pub enum SettlementStatus3Code {
    #[yaserde(rename = "ASTL")]
    #[cfg_attr(feature = "serde", serde(rename = "ASTL"))]
    Astl,
    #[yaserde(rename = "AAUT")]
    #[cfg_attr(feature = "serde", serde(rename = "AAUT"))]
    Aaut,
    #[yaserde(rename = "ACCF")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCF"))]
    Accf,
    #[yaserde(rename = "ARCF")]
    #[cfg_attr(feature = "serde", serde(rename = "ARCF"))]
    Arcf,
    #[yaserde(rename = "MTCH")]
    #[cfg_attr(feature = "serde", serde(rename = "MTCH"))]
    Mtch,
    #[yaserde(rename = "PSTL")]
    #[cfg_attr(feature = "serde", serde(rename = "PSTL"))]
    Pstl,
    #[yaserde(rename = "RJCT")]
    #[cfg_attr(feature = "serde", serde(rename = "RJCT"))]
    Rjct,
    #[yaserde(rename = "STLD")]
    #[cfg_attr(feature = "serde", serde(rename = "STLD"))]
    Stld,
    #[yaserde(rename = "STCR")]
    #[cfg_attr(feature = "serde", serde(rename = "STCR"))]
    Stcr,
    #[yaserde(rename = "SPLT")]
    #[cfg_attr(feature = "serde", serde(rename = "SPLT"))]
    Splt,
    #[yaserde(rename = "NMAT")]
    #[cfg_attr(feature = "serde", serde(rename = "NMAT"))]
    Nmat,
    __Unknown__(String),
}

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

impl Validate for SettlementStatus3Code {}



#[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.016.001.04")]

pub enum ShortLong1Code {
    #[yaserde(rename = "SHOR")]
    #[cfg_attr(feature = "serde", serde(rename = "SHOR"))]
    Shor,
    #[yaserde(rename = "LONG")]
    #[cfg_attr(feature = "serde", serde(rename = "LONG"))]
    Long,
    __Unknown__(String),
}

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

impl Validate for ShortLong1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.04")]
pub struct Summary2 {
    #[yaserde(rename = "XpsdAmtPtyA")]
    #[cfg_attr(feature = "serde", serde(rename = "XpsdAmtPtyA"))]
    pub xpsd_amt_pty_a: ActiveCurrencyAndAmount,

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

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

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

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

    #[yaserde(rename = "NetXcssDfcitInd")]
    #[cfg_attr(feature = "serde", serde(rename = "NetXcssDfcitInd"))]
    pub net_xcss_dfcit_ind: ShortLong1Code,

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

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

    #[yaserde(rename = "SummryDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "SummryDtls"))]
    pub summry_dtls: SummaryAmounts2,
}

impl Validate for Summary2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.04")]
pub struct SummaryAmounts2 {
    #[yaserde(rename = "ThrshldAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "ThrshldAmt"))]
    pub thrshld_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "ThrshldTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ThrshldTp"))]
    pub thrshld_tp: ThresholdType1Code,

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

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

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

    #[yaserde(rename = "RtrXcssCshAndCollCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "RtrXcssCshAndCollCcy"))]
    pub rtr_xcss_csh_and_coll_ccy: Vec<ReturnExcessCash1>,

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

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

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

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

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

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

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

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

impl Validate for SummaryAmounts2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.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.016.001.04")]
pub struct SupplementaryDataEnvelope1 {}

impl Validate for SupplementaryDataEnvelope1 {}


#[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.016.001.04")]

pub enum ThresholdType1Code {
    #[yaserde(rename = "SECU")]
    #[cfg_attr(feature = "serde", serde(rename = "SECU"))]
    Secu,
    #[yaserde(rename = "UNSE")]
    #[cfg_attr(feature = "serde", serde(rename = "UNSE"))]
    Unse,
    __Unknown__(String),
}

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

impl Validate for ThresholdType1Code {}



#[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 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.016.001.04")]
pub struct YieldedOrValueType1Choice {
    #[yaserde(rename = "Yldd")]
    #[cfg_attr(feature = "serde", serde(rename = "Yldd"))]
    pub yldd: Option<YesNoIndicator>,
    #[yaserde(rename = "ValTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ValTp"))]
    pub val_tp: Option<PriceValueType1Code>,
}

impl Validate for YieldedOrValueType1Choice {}

impl crate::MxMessage for Document {
    const BUSINESS_AREA: crate::BusinessArea = crate::BusinessArea::colr;
    const FUNCTIONALITY: &'static str = "016";
    const VARIANT: &'static str = "001";
    const VERSION: &'static str = "04";
    const MESSAGE_NAME: &'static str = "colr.016.001.04";
    const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:colr.016.001.04";
}