rust_iso20022 0.1.2

// @generated by rust_iso20022_codegen 0.1.0; do not edit.
// schema set: xsds/schema-set.json; schema manifest: xsds/schema-manifest.json
// generator config: tools/codegen/generator-config.toml; generator manifest: tools/codegen/generator-manifest.json
// source: xsds/auth.063.001.01.xsd; sha256: 438a3ee51d2196ed75f1a88ed0ee6d78646d08ac54dbf2bee8299011d1a778ac
#![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 crate::validate::Validate;
use std::str::FromStr;
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:auth.063.001.01"
)]
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:auth.063.001.01"
)]
pub struct AmountAndDirection102 {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: ActiveCurrencyAndAmount,

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

impl Validate for AmountAndDirection102 {}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(
    prefix = "n",
    default_namespace = "n",
    namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.063.001.01"
)]
pub struct CcpliquidityStressTestingResultReportV01 {
    #[yaserde(rename = "LqdtyStrssTstRslt")]
    #[cfg_attr(feature = "serde", serde(rename = "LqdtyStrssTstRslt"))]
    pub lqdty_strss_tst_rslt: Vec<LiquidityStressTestResult1>,

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

impl Validate for CcpliquidityStressTestingResultReportV01 {}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(
    prefix = "n",
    default_namespace = "n",
    namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.063.001.01"
)]
pub struct CoverTwoDefaulters1 {
    #[yaserde(rename = "Cover1Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Cover1Id"))]
    pub cover_1_id: Leiidentifier,

    #[yaserde(rename = "Cover2Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Cover2Id"))]
    pub cover_2_id: Leiidentifier,
}

impl Validate for CoverTwoDefaulters1 {}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(
    prefix = "n",
    default_namespace = "n",
    namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.063.001.01"
)]
pub struct Document {
    #[yaserde(rename = "CCPLqdtyStrssTstgRsltRpt")]
    #[cfg_attr(feature = "serde", serde(rename = "CCPLqdtyStrssTstgRsltRpt"))]
    pub ccp_lqdty_strss_tstg_rslt_rpt: CcpliquidityStressTestingResultReportV01,
}

impl Validate for Document {}

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

impl Validate for Leiidentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(
    prefix = "n",
    default_namespace = "n",
    namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.063.001.01"
)]
pub struct LiquidResourceInformation1 {
    #[yaserde(rename = "CntrPtyId")]
    #[cfg_attr(feature = "serde", serde(rename = "CntrPtyId"))]
    pub cntr_pty_id: Max35Text,

    #[yaserde(rename = "LqdRsrcVal")]
    #[cfg_attr(feature = "serde", serde(rename = "LqdRsrcVal"))]
    pub lqd_rsrc_val: AmountAndDirection102,

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

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

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

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

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

impl Validate for LiquidResourceInformation1 {}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(
    prefix = "n",
    default_namespace = "n",
    namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.063.001.01"
)]
pub struct LiquidResources1 {
    #[yaserde(rename = "CshDue")]
    #[cfg_attr(feature = "serde", serde(rename = "CshDue"))]
    pub csh_due: Vec<LiquidResourceInformation1>,

    #[yaserde(rename = "FcltiesCmmtdLinesOfCdt")]
    #[cfg_attr(feature = "serde", serde(rename = "FcltiesCmmtdLinesOfCdt"))]
    pub fclties_cmmtd_lines_of_cdt: Vec<LiquidResourceInformation1>,

    #[yaserde(rename = "FcltiesCmmtdRpAgrmts")]
    #[cfg_attr(feature = "serde", serde(rename = "FcltiesCmmtdRpAgrmts"))]
    pub fclties_cmmtd_rp_agrmts: Vec<LiquidResourceInformation1>,

    #[yaserde(rename = "FcltiesCmmtdFxSwps")]
    #[cfg_attr(feature = "serde", serde(rename = "FcltiesCmmtdFxSwps"))]
    pub fclties_cmmtd_fx_swps: Vec<LiquidResourceInformation1>,

    #[yaserde(rename = "FcltiesOthrCmmtd")]
    #[cfg_attr(feature = "serde", serde(rename = "FcltiesOthrCmmtd"))]
    pub fclties_othr_cmmtd: Vec<LiquidResourceInformation1>,

    #[yaserde(rename = "FcltiesUcmmtd")]
    #[cfg_attr(feature = "serde", serde(rename = "FcltiesUcmmtd"))]
    pub fclties_ucmmtd: Vec<LiquidResourceInformation1>,

    #[yaserde(rename = "FinInstrmsCCP")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrmsCCP"))]
    pub fin_instrms_ccp: Vec<LiquidResourceInformation1>,

    #[yaserde(rename = "FinInstrmsTrsrInvstmts")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrmsTrsrInvstmts"))]
    pub fin_instrms_trsr_invstmts: Vec<LiquidResourceInformation1>,

    #[yaserde(rename = "FinInstrmsDfltrsSttlmColl")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrmsDfltrsSttlmColl"))]
    pub fin_instrms_dfltrs_sttlm_coll: Vec<LiquidResourceInformation1>,

    #[yaserde(rename = "FinInstrmsDfltrsNonCshColl")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrmsDfltrsNonCshColl"))]
    pub fin_instrms_dfltrs_non_csh_coll: Vec<LiquidResourceInformation1>,
}

impl Validate for LiquidResources1 {}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(
    prefix = "n",
    default_namespace = "n",
    namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.063.001.01"
)]
pub struct LiquidityRequiredAndAvailable1 {
    #[yaserde(rename = "LqdRsrcs")]
    #[cfg_attr(feature = "serde", serde(rename = "LqdRsrcs"))]
    pub lqd_rsrcs: LiquidResources1,

    #[yaserde(rename = "LqdtyHrzn")]
    #[cfg_attr(feature = "serde", serde(rename = "LqdtyHrzn"))]
    pub lqdty_hrzn: SettlementDate6Code,

    #[yaserde(rename = "StrssLqdRsrcRqrmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "StrssLqdRsrcRqrmnt"))]
    pub strss_lqd_rsrc_rqrmnt: StressLiquidResourceRequirement1,
}

impl Validate for LiquidityRequiredAndAvailable1 {}

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

    #[yaserde(rename = "ScnroDfltrs")]
    #[cfg_attr(feature = "serde", serde(rename = "ScnroDfltrs"))]
    pub scnro_dfltrs: CoverTwoDefaulters1,

    #[yaserde(rename = "LqdtyReqrdAndAvlbl")]
    #[cfg_attr(feature = "serde", serde(rename = "LqdtyReqrdAndAvlbl"))]
    pub lqdty_reqrd_and_avlbl: Vec<LiquidityRequiredAndAvailable1>,
}

impl Validate for LiquidityStressTestResult1 {}

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

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

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

impl Validate for PlusOrMinusIndicator {}
#[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:auth.063.001.01"
)]

pub enum SettlementDate6Code {
    #[yaserde(rename = "TFIV")]
    #[cfg_attr(feature = "serde", serde(rename = "TFIV"))]
    Tfiv,
    #[yaserde(rename = "TFOR")]
    #[cfg_attr(feature = "serde", serde(rename = "TFOR"))]
    Tfor,
    #[yaserde(rename = "TONE")]
    #[cfg_attr(feature = "serde", serde(rename = "TONE"))]
    Tone,
    #[yaserde(rename = "TTRE")]
    #[cfg_attr(feature = "serde", serde(rename = "TTRE"))]
    Ttre,
    #[yaserde(rename = "TTWO")]
    #[cfg_attr(feature = "serde", serde(rename = "TTWO"))]
    Ttwo,
    #[yaserde(rename = "SAMD")]
    #[cfg_attr(feature = "serde", serde(rename = "SAMD"))]
    Samd,
    __Unknown__(String),
}

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

impl Validate for SettlementDate6Code {}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(
    prefix = "n",
    default_namespace = "n",
    namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.063.001.01"
)]
pub struct StressLiquidResourceRequirement1 {
    #[yaserde(rename = "OprlOutflw")]
    #[cfg_attr(feature = "serde", serde(rename = "OprlOutflw"))]
    pub oprl_outflw: AmountAndDirection102,

    #[yaserde(rename = "VartnMrgnPmtOblgtn")]
    #[cfg_attr(feature = "serde", serde(rename = "VartnMrgnPmtOblgtn"))]
    pub vartn_mrgn_pmt_oblgtn: AmountAndDirection102,

    #[yaserde(rename = "SttlmOrDlvry")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmOrDlvry"))]
    pub sttlm_or_dlvry: AmountAndDirection102,

    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: AmountAndDirection102,
}

impl Validate for StressLiquidResourceRequirement1 {}

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

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

impl Validate for SupplementaryData1 {}

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

impl Validate for SupplementaryDataEnvelope1 {}

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

impl Validate for TrueFalseIndicator {}

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