rust_iso20022 0.1.1

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

// pub type Document = Document;
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
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.003.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.003.001.04")]
pub struct AggregatedIndependentAmount1 {
    #[yaserde(rename = "Trad")]
    #[cfg_attr(feature = "serde", serde(rename = "Trad"))]
    pub trad: IndependentAmount1,

    #[yaserde(rename = "ValAtRsk")]
    #[cfg_attr(feature = "serde", serde(rename = "ValAtRsk"))]
    pub val_at_rsk: IndependentAmount1,

    #[yaserde(rename = "NetOpnPos")]
    #[cfg_attr(feature = "serde", serde(rename = "NetOpnPos"))]
    pub net_opn_pos: IndependentAmount1,

    #[yaserde(rename = "OthrAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrAmt"))]
    pub othr_amt: Vec<IndependentAmount2>,
}

impl Validate for AggregatedIndependentAmount1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.003.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.003.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.003.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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:colr.003.001.04")]
pub struct Collateral1 {
    #[yaserde(rename = "VartnMrgn")]
    #[cfg_attr(feature = "serde", serde(rename = "VartnMrgn"))]
    pub vartn_mrgn: Vec<MarginCollateral1>,

    #[yaserde(rename = "SgrtdIndpdntAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "SgrtdIndpdntAmt"))]
    pub sgrtd_indpdnt_amt: Vec<MarginCollateral1>,
}

impl Validate for Collateral1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.003.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.003.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.003.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.003.001.04")]
pub struct CollateralBalance1Choice {
    #[yaserde(rename = "TtlColl")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlColl"))]
    pub ttl_coll: Option<ActiveCurrencyAndAmount>,
    #[yaserde(rename = "CollDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "CollDtls"))]
    pub coll_dtls: Option<Collateral1>,
    #[yaserde(rename = "SgrtdIndpdntAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "SgrtdIndpdntAmt"))]
    pub sgrtd_indpdnt_amt: Option<MarginCollateral1>,
}

impl Validate for CollateralBalance1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.003.001.04")]
pub struct CollateralMovement9 {
    #[yaserde(rename = "CollTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CollTp"))]
    pub coll_tp: CollateralType1Code,

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

impl Validate for CollateralMovement9 {}


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

pub enum CollateralType1Code {
    #[yaserde(rename = "CASH")]
    #[cfg_attr(feature = "serde", serde(rename = "CASH"))]
    Cash,
    #[yaserde(rename = "SECU")]
    #[cfg_attr(feature = "serde", serde(rename = "SECU"))]
    Secu,
    #[yaserde(rename = "LCRE")]
    #[cfg_attr(feature = "serde", serde(rename = "LCRE"))]
    Lcre,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    __Unknown__(String),
}

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

impl Validate for CollateralType1Code {}



#[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.003.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.003.001.04")]
pub struct Document {
    #[yaserde(rename = "MrgnCallReq")]
    #[cfg_attr(feature = "serde", serde(rename = "MrgnCallReq"))]
    pub mrgn_call_req: MarginCallRequestV04,
}

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

    #[yaserde(rename = "SgrtdIndpdntAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "SgrtdIndpdntAmt"))]
    pub sgrtd_indpdnt_amt: ExpectedCollateralMovement2,
}

impl Validate for ExpectedCollateral2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.003.001.04")]
pub struct ExpectedCollateral2Choice {
    #[yaserde(rename = "XpctdCollDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "XpctdCollDtls"))]
    pub xpctd_coll_dtls: Option<ExpectedCollateral2>,
    #[yaserde(rename = "SgrtdIndpdntAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "SgrtdIndpdntAmt"))]
    pub sgrtd_indpdnt_amt: Option<ExpectedCollateralMovement2>,
}

impl Validate for ExpectedCollateral2Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.003.001.04")]
pub struct ExpectedCollateralMovement2 {
    #[yaserde(rename = "Dlvry")]
    #[cfg_attr(feature = "serde", serde(rename = "Dlvry"))]
    pub dlvry: Vec<CollateralMovement9>,

    #[yaserde(rename = "Rtr")]
    #[cfg_attr(feature = "serde", serde(rename = "Rtr"))]
    pub rtr: Vec<CollateralMovement9>,
}

impl Validate for ExpectedCollateralMovement2 {}


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

pub enum ExposureConventionType1Code {
    #[yaserde(rename = "GROS")]
    #[cfg_attr(feature = "serde", serde(rename = "GROS"))]
    Gros,
    #[yaserde(rename = "NET1")]
    #[cfg_attr(feature = "serde", serde(rename = "NET1"))]
    Net1,
    __Unknown__(String),
}

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

impl Validate for ExposureConventionType1Code {}



#[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.003.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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:colr.003.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.003.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.003.001.04")]
pub struct IndependentAmount1 {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "Cnvntn")]
    #[cfg_attr(feature = "serde", serde(rename = "Cnvntn"))]
    pub cnvntn: IndependentAmountConventionType1Code,
}

impl Validate for IndependentAmount1 {}


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

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

    #[yaserde(rename = "Cnvntn")]
    #[cfg_attr(feature = "serde", serde(rename = "Cnvntn"))]
    pub cnvntn: IndependentAmountConventionType1Code,
}

impl Validate for IndependentAmount2 {}


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

pub enum IndependentAmountConventionType1Code {
    #[yaserde(rename = "NBTR")]
    #[cfg_attr(feature = "serde", serde(rename = "NBTR"))]
    Nbtr,
    #[yaserde(rename = "NATR")]
    #[cfg_attr(feature = "serde", serde(rename = "NATR"))]
    Natr,
    #[yaserde(rename = "SEGR")]
    #[cfg_attr(feature = "serde", serde(rename = "SEGR"))]
    Segr,
    __Unknown__(String),
}

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

impl Validate for IndependentAmountConventionType1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.003.001.04")]
pub struct Margin1 {
    #[yaserde(rename = "VartnMrgn")]
    #[cfg_attr(feature = "serde", serde(rename = "VartnMrgn"))]
    pub vartn_mrgn: Vec<VariationMargin1>,

    #[yaserde(rename = "SgrtdIndpdntAmtMrgn")]
    #[cfg_attr(feature = "serde", serde(rename = "SgrtdIndpdntAmtMrgn"))]
    pub sgrtd_indpdnt_amt_mrgn: Vec<SegregatedIndependentAmountMargin1>,
}

impl Validate for Margin1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.003.001.04")]
pub struct MarginCall1 {
    #[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 = "XpsrCnvntn")]
    #[cfg_attr(feature = "serde", serde(rename = "XpsrCnvntn"))]
    pub xpsr_cnvntn: ExposureConventionType1Code,

    #[yaserde(rename = "IndpdntAmtPtyA")]
    #[cfg_attr(feature = "serde", serde(rename = "IndpdntAmtPtyA"))]
    pub indpdnt_amt_pty_a: AggregatedIndependentAmount1,

    #[yaserde(rename = "IndpdntAmtPtyB")]
    #[cfg_attr(feature = "serde", serde(rename = "IndpdntAmtPtyB"))]
    pub indpdnt_amt_pty_b: AggregatedIndependentAmount1,

    #[yaserde(rename = "MrgnTerms")]
    #[cfg_attr(feature = "serde", serde(rename = "MrgnTerms"))]
    pub mrgn_terms: MarginTerms1Choice,

    #[yaserde(rename = "CollBal")]
    #[cfg_attr(feature = "serde", serde(rename = "CollBal"))]
    pub coll_bal: CollateralBalance1Choice,
}

impl Validate for MarginCall1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.003.001.04")]
pub struct MarginCall2 {
    #[yaserde(rename = "CollAcctId")]
    #[cfg_attr(feature = "serde", serde(rename = "CollAcctId"))]
    pub coll_acct_id: CollateralAccount2,

    #[yaserde(rename = "MrgnCallRslt")]
    #[cfg_attr(feature = "serde", serde(rename = "MrgnCallRslt"))]
    pub mrgn_call_rslt: MarginCallResult3,

    #[yaserde(rename = "MrgnDtlDueToA")]
    #[cfg_attr(feature = "serde", serde(rename = "MrgnDtlDueToA"))]
    pub mrgn_dtl_due_to_a: MarginCall1,

    #[yaserde(rename = "MrgnDtlDueToB")]
    #[cfg_attr(feature = "serde", serde(rename = "MrgnDtlDueToB"))]
    pub mrgn_dtl_due_to_b: MarginCall1,

    #[yaserde(rename = "RqrmntDtlsDueToA")]
    #[cfg_attr(feature = "serde", serde(rename = "RqrmntDtlsDueToA"))]
    pub rqrmnt_dtls_due_to_a: MarginRequirement1Choice,

    #[yaserde(rename = "RqrmntDtlsDueToB")]
    #[cfg_attr(feature = "serde", serde(rename = "RqrmntDtlsDueToB"))]
    pub rqrmnt_dtls_due_to_b: MarginRequirement1Choice,

    #[yaserde(rename = "XpctdCollDueToA")]
    #[cfg_attr(feature = "serde", serde(rename = "XpctdCollDueToA"))]
    pub xpctd_coll_due_to_a: ExpectedCollateral2Choice,

    #[yaserde(rename = "XpctdCollDueToB")]
    #[cfg_attr(feature = "serde", serde(rename = "XpctdCollDueToB"))]
    pub xpctd_coll_due_to_b: ExpectedCollateral2Choice,
}

impl Validate for MarginCall2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.003.001.04")]
pub struct MarginCallRequestV04 {
    #[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 = "MrgnCallRslt")]
    #[cfg_attr(feature = "serde", serde(rename = "MrgnCallRslt"))]
    pub mrgn_call_rslt: MarginCallResult3,

    #[yaserde(rename = "MrgnDtlsDueToA")]
    #[cfg_attr(feature = "serde", serde(rename = "MrgnDtlsDueToA"))]
    pub mrgn_dtls_due_to_a: MarginCall1,

    #[yaserde(rename = "MrgnDtlsDueToB")]
    #[cfg_attr(feature = "serde", serde(rename = "MrgnDtlsDueToB"))]
    pub mrgn_dtls_due_to_b: MarginCall1,

    #[yaserde(rename = "RqrmntDtlsDueToA")]
    #[cfg_attr(feature = "serde", serde(rename = "RqrmntDtlsDueToA"))]
    pub rqrmnt_dtls_due_to_a: MarginRequirement1Choice,

    #[yaserde(rename = "RqrmntDtlsDueToB")]
    #[cfg_attr(feature = "serde", serde(rename = "RqrmntDtlsDueToB"))]
    pub rqrmnt_dtls_due_to_b: MarginRequirement1Choice,

    #[yaserde(rename = "XpctdCollDueToA")]
    #[cfg_attr(feature = "serde", serde(rename = "XpctdCollDueToA"))]
    pub xpctd_coll_due_to_a: ExpectedCollateral2Choice,

    #[yaserde(rename = "XpctdCollDueToB")]
    #[cfg_attr(feature = "serde", serde(rename = "XpctdCollDueToB"))]
    pub xpctd_coll_due_to_b: ExpectedCollateral2Choice,

    #[yaserde(rename = "MrgnCallDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "MrgnCallDtls"))]
    pub mrgn_call_dtls: Vec<MarginCall2>,

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

impl Validate for MarginCallRequestV04 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.003.001.04")]
pub struct MarginCallResult2 {
    #[yaserde(rename = "VartnMrgnRslt")]
    #[cfg_attr(feature = "serde", serde(rename = "VartnMrgnRslt"))]
    pub vartn_mrgn_rslt: Result1,

    #[yaserde(rename = "SgrtdIndpdntAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "SgrtdIndpdntAmt"))]
    pub sgrtd_indpdnt_amt: Result1,
}

impl Validate for MarginCallResult2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.003.001.04")]
pub struct MarginCallResult2Choice {
    #[yaserde(rename = "MrgnCallRsltDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "MrgnCallRsltDtls"))]
    pub mrgn_call_rslt_dtls: Option<MarginCallResult2>,
    #[yaserde(rename = "MrgnCallAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "MrgnCallAmt"))]
    pub mrgn_call_amt: Option<Result1>,
    #[yaserde(rename = "SgrtdIndpdntAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "SgrtdIndpdntAmt"))]
    pub sgrtd_indpdnt_amt: Option<Result1>,
}

impl Validate for MarginCallResult2Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.003.001.04")]
pub struct MarginCallResult3 {
    #[yaserde(rename = "DfltFndAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "DfltFndAmt"))]
    pub dflt_fnd_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "MrgnCallRslt")]
    #[cfg_attr(feature = "serde", serde(rename = "MrgnCallRslt"))]
    pub mrgn_call_rslt: MarginCallResult2Choice,
}

impl Validate for MarginCallResult3 {}


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

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

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

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

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

impl Validate for MarginCollateral1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.003.001.04")]
pub struct MarginRequirement1 {
    #[yaserde(rename = "DlvrMrgnAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "DlvrMrgnAmt"))]
    pub dlvr_mrgn_amt: ActiveCurrencyAndAmount,

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

impl Validate for MarginRequirement1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.003.001.04")]
pub struct MarginRequirement1Choice {
    #[yaserde(rename = "MrgnRqrmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "MrgnRqrmnt"))]
    pub mrgn_rqrmnt: Option<Requirement1>,
    #[yaserde(rename = "SgrtdIndpdntAmtRqrmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "SgrtdIndpdntAmtRqrmnt"))]
    pub sgrtd_indpdnt_amt_rqrmnt: Option<MarginRequirement1>,
}

impl Validate for MarginRequirement1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.003.001.04")]
pub struct MarginTerms1Choice {
    #[yaserde(rename = "MrgnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "MrgnDtls"))]
    pub mrgn_dtls: Option<Margin1>,
    #[yaserde(rename = "SgrtdIndpdntAmtMrgn")]
    #[cfg_attr(feature = "serde", serde(rename = "SgrtdIndpdntAmtMrgn"))]
    pub sgrtd_indpdnt_amt_mrgn: Option<SegregatedIndependentAmountMargin1>,
}

impl Validate for MarginTerms1Choice {}




#[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.003.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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:colr.003.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.003.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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:colr.003.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.003.001.04")]
pub struct Requirement1 {
    #[yaserde(rename = "VartnMrgnRqrmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "VartnMrgnRqrmnt"))]
    pub vartn_mrgn_rqrmnt: Vec<MarginRequirement1>,

    #[yaserde(rename = "SgrtdIndpdntAmtRqrmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "SgrtdIndpdntAmtRqrmnt"))]
    pub sgrtd_indpdnt_amt_rqrmnt: Vec<MarginRequirement1>,
}

impl Validate for Requirement1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.003.001.04")]
pub struct Result1 {
    #[yaserde(rename = "DueToPtyA")]
    #[cfg_attr(feature = "serde", serde(rename = "DueToPtyA"))]
    pub due_to_pty_a: ActiveCurrencyAndAmount,

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

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

impl Validate for Result1 {}


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

pub enum RoundingMethod1Code {
    #[yaserde(rename = "DRDW")]
    #[cfg_attr(feature = "serde", serde(rename = "DRDW"))]
    Drdw,
    #[yaserde(rename = "DRUP")]
    #[cfg_attr(feature = "serde", serde(rename = "DRUP"))]
    Drup,
    #[yaserde(rename = "NONE")]
    #[cfg_attr(feature = "serde", serde(rename = "NONE"))]
    None,
    #[yaserde(rename = "CLSR")]
    #[cfg_attr(feature = "serde", serde(rename = "CLSR"))]
    Clsr,
    __Unknown__(String),
}

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

impl Validate for RoundingMethod1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.003.001.04")]
pub struct SegregatedIndependentAmountMargin1 {
    #[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 = "RndgMtd")]
    #[cfg_attr(feature = "serde", serde(rename = "RndgMtd"))]
    pub rndg_mtd: RoundingMethod1Code,
}

impl Validate for SegregatedIndependentAmountMargin1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.003.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.003.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.003.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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:colr.003.001.04")]
pub struct VariationMargin1 {
    #[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 = "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 = "RndgMtd")]
    #[cfg_attr(feature = "serde", serde(rename = "RndgMtd"))]
    pub rndg_mtd: RoundingMethod1Code,
}

impl Validate for VariationMargin1 {}

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