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

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

impl Validate for ActiveOrHistoricCurrencyAnd20DecimalAmount {}


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

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

impl Validate for ActiveOrHistoricCurrencyAndAmount {}


#[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:auth.105.001.01")]
pub struct AmountAndDirection107 {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: ActiveOrHistoricCurrencyAnd20DecimalAmount,

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

impl Validate for AmountAndDirection107 {}


#[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.105.001.01")]
pub struct AmountAndDirection53 {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: ActiveOrHistoricCurrencyAndAmount,

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

impl Validate for AmountAndDirection53 {}


#[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(Default, Clone, PartialEq, Debug)]
pub struct Cfioct2015Identifier (pub String);
crate::simple_type!(Cfioct2015Identifier);

impl Validate for Cfioct2015Identifier {}
#[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.105.001.01")]
pub struct CollateralData33 {
    #[yaserde(rename = "NetXpsrCollstnInd")]
    #[cfg_attr(feature = "serde", serde(rename = "NetXpsrCollstnInd"))]
    pub net_xpsr_collstn_ind: TrueFalseIndicator,

    #[yaserde(rename = "CmpntTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CmpntTp"))]
    pub cmpnt_tp: CollateralType6Code,

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

    #[yaserde(rename = "PricCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "PricCcy"))]
    pub pric_ccy: ActiveOrHistoricCurrencyCode,

    #[yaserde(rename = "Qlty")]
    #[cfg_attr(feature = "serde", serde(rename = "Qlty"))]
    pub qlty: CollateralQualityType1Code,

    #[yaserde(rename = "Mtrty")]
    #[cfg_attr(feature = "serde", serde(rename = "Mtrty"))]
    pub mtrty: ContractTerm6Choice,

    #[yaserde(rename = "IssrJursdctn")]
    #[cfg_attr(feature = "serde", serde(rename = "IssrJursdctn"))]
    pub issr_jursdctn: IssuerJurisdiction1Choice,

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

    #[yaserde(rename = "TradRpstry")]
    #[cfg_attr(feature = "serde", serde(rename = "TradRpstry"))]
    pub trad_rpstry: OrganisationIdentification15Choice,

    #[yaserde(rename = "RcncltnFlg")]
    #[cfg_attr(feature = "serde", serde(rename = "RcncltnFlg"))]
    pub rcncltn_flg: ReconciliationFlag2,

    #[yaserde(rename = "RinvstdCsh")]
    #[cfg_attr(feature = "serde", serde(rename = "RinvstdCsh"))]
    pub rinvstd_csh: ReinvestedCashTypeAndAmount2,
}

impl Validate for CollateralData33 {}


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

pub enum CollateralQualityType1Code {
    #[yaserde(rename = "INVG")]
    #[cfg_attr(feature = "serde", serde(rename = "INVG"))]
    Invg,
    #[yaserde(rename = "NIVG")]
    #[cfg_attr(feature = "serde", serde(rename = "NIVG"))]
    Nivg,
    #[yaserde(rename = "NOTR")]
    #[cfg_attr(feature = "serde", serde(rename = "NOTR"))]
    Notr,
    #[yaserde(rename = "NOAP")]
    #[cfg_attr(feature = "serde", serde(rename = "NOAP"))]
    Noap,
    __Unknown__(String),
}

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

impl Validate for CollateralQualityType1Code {}



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

pub enum CollateralRole1Code {
    #[yaserde(rename = "GIVE")]
    #[cfg_attr(feature = "serde", serde(rename = "GIVE"))]
    Give,
    #[yaserde(rename = "TAKE")]
    #[cfg_attr(feature = "serde", serde(rename = "TAKE"))]
    Take,
    __Unknown__(String),
}

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

impl Validate for CollateralRole1Code {}



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

pub enum CollateralType6Code {
    #[yaserde(rename = "GBBK")]
    #[cfg_attr(feature = "serde", serde(rename = "GBBK"))]
    Gbbk,
    #[yaserde(rename = "BOND")]
    #[cfg_attr(feature = "serde", serde(rename = "BOND"))]
    Bond,
    #[yaserde(rename = "CASH")]
    #[cfg_attr(feature = "serde", serde(rename = "CASH"))]
    Cash,
    #[yaserde(rename = "COMM")]
    #[cfg_attr(feature = "serde", serde(rename = "COMM"))]
    Comm,
    #[yaserde(rename = "INSU")]
    #[cfg_attr(feature = "serde", serde(rename = "INSU"))]
    Insu,
    #[yaserde(rename = "LCRE")]
    #[cfg_attr(feature = "serde", serde(rename = "LCRE"))]
    Lcre,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "PHYS")]
    #[cfg_attr(feature = "serde", serde(rename = "PHYS"))]
    Phys,
    #[yaserde(rename = "SECU")]
    #[cfg_attr(feature = "serde", serde(rename = "SECU"))]
    Secu,
    #[yaserde(rename = "STCF")]
    #[cfg_attr(feature = "serde", serde(rename = "STCF"))]
    Stcf,
    __Unknown__(String),
}

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

impl Validate for CollateralType6Code {}
#[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.105.001.01")]
pub struct ContractTerm6Choice {
    #[yaserde(rename = "Opn")]
    #[cfg_attr(feature = "serde", serde(rename = "Opn"))]
    pub opn: Option<TrueFalseIndicator>,
    #[yaserde(rename = "Fxd")]
    #[cfg_attr(feature = "serde", serde(rename = "Fxd"))]
    pub fxd: Option<TimeToMaturity2Choice>,
}

impl Validate for ContractTerm6Choice {}




#[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.105.001.01")]
pub struct CounterpartyData86 {
    #[yaserde(rename = "RptgCtrPty")]
    #[cfg_attr(feature = "serde", serde(rename = "RptgCtrPty"))]
    pub rptg_ctr_pty: CounterpartyIdentification10,

    #[yaserde(rename = "OthrCtrPty")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrCtrPty"))]
    pub othr_ctr_pty: OrganisationIdentification15Choice,

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

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

impl Validate for CounterpartyData86 {}


#[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.105.001.01")]
pub struct CounterpartyIdentification10 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: OrganisationIdentification15Choice,

    #[yaserde(rename = "Sd")]
    #[cfg_attr(feature = "serde", serde(rename = "Sd"))]
    pub sd: CollateralRole1Code,
}

impl Validate for CounterpartyIdentification10 {}


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

impl Validate for DecimalNumber {}
#[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.105.001.01")]
pub struct Document {
    #[yaserde(rename = "SctiesFincgRptgPosSetRpt")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesFincgRptgPosSetRpt"))]
    pub scties_fincg_rptg_pos_set_rpt: SecuritiesFinancingReportingPositionSetReportV01,
}

impl Validate for Document {}


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

    #[yaserde(rename = "LnVal")]
    #[cfg_attr(feature = "serde", serde(rename = "LnVal"))]
    pub ln_val: ActiveOrHistoricCurrencyAndAmount,

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

    #[yaserde(rename = "OutsdngMrgnLnAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "OutsdngMrgnLnAmt"))]
    pub outsdng_mrgn_ln_amt: ActiveOrHistoricCurrencyAndAmount,

    #[yaserde(rename = "ShrtMktValAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "ShrtMktValAmt"))]
    pub shrt_mkt_val_amt: ActiveOrHistoricCurrencyAndAmount,

    #[yaserde(rename = "MrgnLn")]
    #[cfg_attr(feature = "serde", serde(rename = "MrgnLn"))]
    pub mrgn_ln: ActiveOrHistoricCurrencyAndAmount,

    #[yaserde(rename = "CshCollAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "CshCollAmt"))]
    pub csh_coll_amt: AmountAndDirection53,

    #[yaserde(rename = "CollMktVal")]
    #[cfg_attr(feature = "serde", serde(rename = "CollMktVal"))]
    pub coll_mkt_val: AmountAndDirection53,
}

impl Validate for ExposureMetrics4 {}


#[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.105.001.01")]
pub struct ExposureMetrics5 {
    #[yaserde(rename = "CshCollAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "CshCollAmt"))]
    pub csh_coll_amt: AmountAndDirection53,

    #[yaserde(rename = "CollMktVal")]
    #[cfg_attr(feature = "serde", serde(rename = "CollMktVal"))]
    pub coll_mkt_val: AmountAndDirection53,
}

impl Validate for ExposureMetrics5 {}


#[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.105.001.01")]
pub struct ExposureMetrics6 {
    #[yaserde(rename = "PstdMrgnOrColl")]
    #[cfg_attr(feature = "serde", serde(rename = "PstdMrgnOrColl"))]
    pub pstd_mrgn_or_coll: PostedMarginOrCollateral4,
}

impl Validate for ExposureMetrics6 {}


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

pub enum ExposureType10Code {
    #[yaserde(rename = "SBSC")]
    #[cfg_attr(feature = "serde", serde(rename = "SBSC"))]
    Sbsc,
    #[yaserde(rename = "MGLD")]
    #[cfg_attr(feature = "serde", serde(rename = "MGLD"))]
    Mgld,
    #[yaserde(rename = "SLEB")]
    #[cfg_attr(feature = "serde", serde(rename = "SLEB"))]
    Sleb,
    #[yaserde(rename = "REPO")]
    #[cfg_attr(feature = "serde", serde(rename = "REPO"))]
    Repo,
    __Unknown__(String),
}

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

impl Validate for ExposureType10Code {}



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

impl Validate for ExternalAgreementType1Code {
    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)]
pub struct ExternalRatesAndTenors1Code (pub String);
crate::simple_type!(ExternalRatesAndTenors1Code);

impl Validate for ExternalRatesAndTenors1Code {
    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)]
pub struct ExternalSecuritiesLendingType1Code (pub String);
crate::simple_type!(ExternalSecuritiesLendingType1Code);

impl Validate for ExternalSecuritiesLendingType1Code {
    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:auth.105.001.01")]
pub struct GenericIdentification175 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max72Text,

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

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

impl Validate for GenericIdentification175 {}


#[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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.105.001.01")]
pub struct IssuerJurisdiction1Choice {
    #[yaserde(rename = "CtryCd")]
    #[cfg_attr(feature = "serde", serde(rename = "CtryCd"))]
    pub ctry_cd: Option<CountryCode>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<Max35Text>,
}

impl Validate for IssuerJurisdiction1Choice {}




#[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.105.001.01")]
pub struct LoanData134 {
    #[yaserde(rename = "CtrctTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrctTp"))]
    pub ctrct_tp: ExposureType10Code,

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

    #[yaserde(rename = "PrtflCd")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtflCd"))]
    pub prtfl_cd: Max52Text,

    #[yaserde(rename = "TradgVn")]
    #[cfg_attr(feature = "serde", serde(rename = "TradgVn"))]
    pub tradg_vn: TradingVenueType1Choice,

    #[yaserde(rename = "MstrAgrmtTp")]
    #[cfg_attr(feature = "serde", serde(rename = "MstrAgrmtTp"))]
    pub mstr_agrmt_tp: ExternalAgreementType1Code,

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

    #[yaserde(rename = "GnlColl")]
    #[cfg_attr(feature = "serde", serde(rename = "GnlColl"))]
    pub gnl_coll: SpecialCollateral1Code,

    #[yaserde(rename = "Term")]
    #[cfg_attr(feature = "serde", serde(rename = "Term"))]
    pub term: ContractTerm6Choice,

    #[yaserde(rename = "Rates")]
    #[cfg_attr(feature = "serde", serde(rename = "Rates"))]
    pub rates: Rates1Choice,

    #[yaserde(rename = "PrncplAmtCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "PrncplAmtCcy"))]
    pub prncpl_amt_ccy: ActiveOrHistoricCurrencyCode,

    #[yaserde(rename = "PricCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "PricCcy"))]
    pub pric_ccy: ActiveOrHistoricCurrencyCode,

    #[yaserde(rename = "Scty")]
    #[cfg_attr(feature = "serde", serde(rename = "Scty"))]
    pub scty: Security49,

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

impl Validate for LoanData134 {}


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

impl Validate for LongFraction19DecimalNumber {}
#[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.105.001.01")]
pub struct MaturityTerm2 {
    #[yaserde(rename = "Unit")]
    #[cfg_attr(feature = "serde", serde(rename = "Unit"))]
    pub unit: RateBasis1Code,

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

impl Validate for MaturityTerm2 {}


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

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

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

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

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

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

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

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

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

impl Validate for Max72Text {
    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() > 72 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 72 \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:auth.105.001.01")]
pub struct NamedPosition3 {
    #[yaserde(rename = "RefDt")]
    #[cfg_attr(feature = "serde", serde(rename = "RefDt"))]
    pub ref_dt: Isodate,

    #[yaserde(rename = "GnlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "GnlInf"))]
    pub gnl_inf: Vec<PositionSet16>,

    #[yaserde(rename = "Ln")]
    #[cfg_attr(feature = "serde", serde(rename = "Ln"))]
    pub ln: Vec<PositionSet17>,

    #[yaserde(rename = "Coll")]
    #[cfg_attr(feature = "serde", serde(rename = "Coll"))]
    pub coll: Vec<PositionSet18>,

    #[yaserde(rename = "Mrgn")]
    #[cfg_attr(feature = "serde", serde(rename = "Mrgn"))]
    pub mrgn: Vec<PositionSet20>,

    #[yaserde(rename = "Reuse")]
    #[cfg_attr(feature = "serde", serde(rename = "Reuse"))]
    pub reuse: Vec<PositionSet19>,
}

impl Validate for NamedPosition3 {}


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

pub enum NoReasonCode {
    #[yaserde(rename = "NORE")]
    #[cfg_attr(feature = "serde", serde(rename = "NORE"))]
    Nore,
    __Unknown__(String),
}

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

impl Validate for NoReasonCode {}
#[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.105.001.01")]
pub struct OrganisationIdentification15Choice {
    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Option<Leiidentifier>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<OrganisationIdentification38>,
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_b_i_c: Option<AnyBICDec2014Identifier>,
}

impl Validate for OrganisationIdentification15Choice {}




#[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.105.001.01")]
pub struct OrganisationIdentification38 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: GenericIdentification175,

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

    #[yaserde(rename = "Dmcl")]
    #[cfg_attr(feature = "serde", serde(rename = "Dmcl"))]
    pub dmcl: Max500Text,
}

impl Validate for OrganisationIdentification38 {}


#[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)]
pub struct PlusOrMinusIndicator (pub bool);
crate::simple_type!(PlusOrMinusIndicator);

impl Validate for PlusOrMinusIndicator {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.105.001.01")]
pub struct PositionSet16 {
    #[yaserde(rename = "Dmnsns")]
    #[cfg_attr(feature = "serde", serde(rename = "Dmnsns"))]
    pub dmnsns: PositionSetDimensions14,

    #[yaserde(rename = "Mtrcs")]
    #[cfg_attr(feature = "serde", serde(rename = "Mtrcs"))]
    pub mtrcs: PositionSetMetrics7,
}

impl Validate for PositionSet16 {}


#[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.105.001.01")]
pub struct PositionSet17 {
    #[yaserde(rename = "Dmnsns")]
    #[cfg_attr(feature = "serde", serde(rename = "Dmnsns"))]
    pub dmnsns: PositionSetDimensions14,

    #[yaserde(rename = "Mtrcs")]
    #[cfg_attr(feature = "serde", serde(rename = "Mtrcs"))]
    pub mtrcs: PositionSetMetrics13,
}

impl Validate for PositionSet17 {}


#[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.105.001.01")]
pub struct PositionSet18 {
    #[yaserde(rename = "Dmnsns")]
    #[cfg_attr(feature = "serde", serde(rename = "Dmnsns"))]
    pub dmnsns: PositionSetDimensions14,

    #[yaserde(rename = "Mtrcs")]
    #[cfg_attr(feature = "serde", serde(rename = "Mtrcs"))]
    pub mtrcs: PositionSetMetrics12,
}

impl Validate for PositionSet18 {}


#[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.105.001.01")]
pub struct PositionSet19 {
    #[yaserde(rename = "Dmnsns")]
    #[cfg_attr(feature = "serde", serde(rename = "Dmnsns"))]
    pub dmnsns: PositionSetDimensions12,

    #[yaserde(rename = "Mtrcs")]
    #[cfg_attr(feature = "serde", serde(rename = "Mtrcs"))]
    pub mtrcs: PositionSetMetrics11,
}

impl Validate for PositionSet19 {}


#[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.105.001.01")]
pub struct PositionSet20 {
    #[yaserde(rename = "Dmnsns")]
    #[cfg_attr(feature = "serde", serde(rename = "Dmnsns"))]
    pub dmnsns: PositionSetDimensions15,

    #[yaserde(rename = "Mtrcs")]
    #[cfg_attr(feature = "serde", serde(rename = "Mtrcs"))]
    pub mtrcs: PositionSetMetrics10,
}

impl Validate for PositionSet20 {}


#[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.105.001.01")]
pub struct PositionSetDimensions12 {
    #[yaserde(rename = "RptgCtrPty")]
    #[cfg_attr(feature = "serde", serde(rename = "RptgCtrPty"))]
    pub rptg_ctr_pty: OrganisationIdentification15Choice,

    #[yaserde(rename = "CollData")]
    #[cfg_attr(feature = "serde", serde(rename = "CollData"))]
    pub coll_data: CollateralData33,

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

impl Validate for PositionSetDimensions12 {}


#[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.105.001.01")]
pub struct PositionSetDimensions14 {
    #[yaserde(rename = "CtrPtyData")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrPtyData"))]
    pub ctr_pty_data: CounterpartyData86,

    #[yaserde(rename = "LnData")]
    #[cfg_attr(feature = "serde", serde(rename = "LnData"))]
    pub ln_data: LoanData134,

    #[yaserde(rename = "CollData")]
    #[cfg_attr(feature = "serde", serde(rename = "CollData"))]
    pub coll_data: CollateralData33,

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

impl Validate for PositionSetDimensions14 {}


#[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.105.001.01")]
pub struct PositionSetDimensions15 {
    #[yaserde(rename = "RptgCtrPty")]
    #[cfg_attr(feature = "serde", serde(rename = "RptgCtrPty"))]
    pub rptg_ctr_pty: OrganisationIdentification15Choice,

    #[yaserde(rename = "OthrCtrPty")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrCtrPty"))]
    pub othr_ctr_pty: OrganisationIdentification15Choice,

    #[yaserde(rename = "CollPrtflId")]
    #[cfg_attr(feature = "serde", serde(rename = "CollPrtflId"))]
    pub coll_prtfl_id: Max52Text,

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

impl Validate for PositionSetDimensions15 {}


#[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.105.001.01")]
pub struct PositionSetMetrics10 {
    #[yaserde(rename = "VolMtrcs")]
    #[cfg_attr(feature = "serde", serde(rename = "VolMtrcs"))]
    pub vol_mtrcs: ExposureMetrics6,
}

impl Validate for PositionSetMetrics10 {}


#[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.105.001.01")]
pub struct PositionSetMetrics11 {
    #[yaserde(rename = "VolMtrcs")]
    #[cfg_attr(feature = "serde", serde(rename = "VolMtrcs"))]
    pub vol_mtrcs: VolumeMetrics4,

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

impl Validate for PositionSetMetrics11 {}


#[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.105.001.01")]
pub struct PositionSetMetrics12 {
    #[yaserde(rename = "VolMtrcs")]
    #[cfg_attr(feature = "serde", serde(rename = "VolMtrcs"))]
    pub vol_mtrcs: VolumeMetrics6,

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

    #[yaserde(rename = "QtyOrNmnlAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "QtyOrNmnlAmt"))]
    pub qty_or_nmnl_amt: QuantityNominalValue2Choice,
}

impl Validate for PositionSetMetrics12 {}


#[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.105.001.01")]
pub struct PositionSetMetrics13 {
    #[yaserde(rename = "VolMtrcs")]
    #[cfg_attr(feature = "serde", serde(rename = "VolMtrcs"))]
    pub vol_mtrcs: VolumeMetrics5,

    #[yaserde(rename = "PricMtrcs")]
    #[cfg_attr(feature = "serde", serde(rename = "PricMtrcs"))]
    pub pric_mtrcs: PriceMetrics3,
}

impl Validate for PositionSetMetrics13 {}


#[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.105.001.01")]
pub struct PositionSetMetrics7 {
    #[yaserde(rename = "VolMtrcs")]
    #[cfg_attr(feature = "serde", serde(rename = "VolMtrcs"))]
    pub vol_mtrcs: VolumeMetrics5,
}

impl Validate for PositionSetMetrics7 {}
#[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.105.001.01")]
pub struct PositionSetReport3Choice {
    #[yaserde(rename = "DataSetActn")]
    #[cfg_attr(feature = "serde", serde(rename = "DataSetActn"))]
    pub data_set_actn: Option<ReportPeriodActivity1Code>,
    #[yaserde(rename = "Rpt")]
    #[cfg_attr(feature = "serde", serde(rename = "Rpt"))]
    pub rpt: Option<NamedPosition3>,
}

impl Validate for PositionSetReport3Choice {}




#[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.105.001.01")]
pub struct PostedMarginOrCollateral4 {
    #[yaserde(rename = "InitlMrgnPstd")]
    #[cfg_attr(feature = "serde", serde(rename = "InitlMrgnPstd"))]
    pub initl_mrgn_pstd: ActiveOrHistoricCurrencyAndAmount,

    #[yaserde(rename = "VartnMrgnPstd")]
    #[cfg_attr(feature = "serde", serde(rename = "VartnMrgnPstd"))]
    pub vartn_mrgn_pstd: ActiveOrHistoricCurrencyAndAmount,

    #[yaserde(rename = "XcssCollPstd")]
    #[cfg_attr(feature = "serde", serde(rename = "XcssCollPstd"))]
    pub xcss_coll_pstd: ActiveOrHistoricCurrencyAndAmount,
}

impl Validate for PostedMarginOrCollateral4 {}


#[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.105.001.01")]
pub struct PriceMetrics3 {
    #[yaserde(rename = "Rates")]
    #[cfg_attr(feature = "serde", serde(rename = "Rates"))]
    pub rates: Rates3,

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

impl Validate for PriceMetrics3 {}


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

pub enum PriceStatus1Code {
    #[yaserde(rename = "PNDG")]
    #[cfg_attr(feature = "serde", serde(rename = "PNDG"))]
    Pndg,
    #[yaserde(rename = "NOAP")]
    #[cfg_attr(feature = "serde", serde(rename = "NOAP"))]
    Noap,
    __Unknown__(String),
}

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

impl Validate for PriceStatus1Code {}



#[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.105.001.01")]
pub struct PrincipalAmount3 {
    #[yaserde(rename = "ValDtAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "ValDtAmt"))]
    pub val_dt_amt: ActiveOrHistoricCurrencyAndAmount,

    #[yaserde(rename = "MtrtyDtAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "MtrtyDtAmt"))]
    pub mtrty_dt_amt: ActiveOrHistoricCurrencyAndAmount,
}

impl Validate for PrincipalAmount3 {}
#[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.105.001.01")]
pub struct QuantityNominalValue2Choice {
    #[yaserde(rename = "Qty")]
    #[cfg_attr(feature = "serde", serde(rename = "Qty"))]
    pub qty: Option<DecimalNumber>,
    #[yaserde(rename = "NmnlVal")]
    #[cfg_attr(feature = "serde", serde(rename = "NmnlVal"))]
    pub nmnl_val: Option<AmountAndDirection53>,
}

impl Validate for QuantityNominalValue2Choice {}




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

pub enum RateBasis1Code {
    #[yaserde(rename = "DAYS")]
    #[cfg_attr(feature = "serde", serde(rename = "DAYS"))]
    Days,
    #[yaserde(rename = "MNTH")]
    #[cfg_attr(feature = "serde", serde(rename = "MNTH"))]
    Mnth,
    #[yaserde(rename = "WEEK")]
    #[cfg_attr(feature = "serde", serde(rename = "WEEK"))]
    Week,
    #[yaserde(rename = "YEAR")]
    #[cfg_attr(feature = "serde", serde(rename = "YEAR"))]
    Year,
    __Unknown__(String),
}

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

impl Validate for RateBasis1Code {}
#[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.105.001.01")]
pub struct Rates1Choice {
    #[yaserde(rename = "Fxd")]
    #[cfg_attr(feature = "serde", serde(rename = "Fxd"))]
    pub fxd: Option<NoReasonCode>,
    #[yaserde(rename = "Fltg")]
    #[cfg_attr(feature = "serde", serde(rename = "Fltg"))]
    pub fltg: Option<ExternalRatesAndTenors1Code>,
}

impl Validate for Rates1Choice {}




#[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.105.001.01")]
pub struct Rates3 {
    #[yaserde(rename = "Fxd")]
    #[cfg_attr(feature = "serde", serde(rename = "Fxd"))]
    pub fxd: PercentageRate,

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

    #[yaserde(rename = "BuySellBck")]
    #[cfg_attr(feature = "serde", serde(rename = "BuySellBck"))]
    pub buy_sell_bck: SecuritiesTransactionPrice18Choice,
}

impl Validate for Rates3 {}


#[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.105.001.01")]
pub struct ReconciliationFlag2 {
    #[yaserde(rename = "RptTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RptTp"))]
    pub rpt_tp: TradeRepositoryReportingType1Code,

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

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

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

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

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

impl Validate for ReconciliationFlag2 {}


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

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

impl Validate for ReinvestedCashTypeAndAmount2 {}


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

pub enum ReinvestmentType1Code {
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "OCMP")]
    #[cfg_attr(feature = "serde", serde(rename = "OCMP"))]
    Ocmp,
    #[yaserde(rename = "MMFT")]
    #[cfg_attr(feature = "serde", serde(rename = "MMFT"))]
    Mmft,
    #[yaserde(rename = "REPM")]
    #[cfg_attr(feature = "serde", serde(rename = "REPM"))]
    Repm,
    #[yaserde(rename = "SDPU")]
    #[cfg_attr(feature = "serde", serde(rename = "SDPU"))]
    Sdpu,
    __Unknown__(String),
}

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

impl Validate for ReinvestmentType1Code {}



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

pub enum ReportPeriodActivity1Code {
    #[yaserde(rename = "NOTX")]
    #[cfg_attr(feature = "serde", serde(rename = "NOTX"))]
    Notx,
    __Unknown__(String),
}

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

impl Validate for ReportPeriodActivity1Code {}
#[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.105.001.01")]
pub struct ReuseValue1Choice {
    #[yaserde(rename = "Actl")]
    #[cfg_attr(feature = "serde", serde(rename = "Actl"))]
    pub actl: Option<ActiveOrHistoricCurrencyAndAmount>,
    #[yaserde(rename = "Estmtd")]
    #[cfg_attr(feature = "serde", serde(rename = "Estmtd"))]
    pub estmtd: Option<ActiveOrHistoricCurrencyAndAmount>,
}

impl Validate for ReuseValue1Choice {}




#[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.105.001.01")]
pub struct SecuritiesFinancingReportingPositionSetReportV01 {
    #[yaserde(rename = "AggtdPoss")]
    #[cfg_attr(feature = "serde", serde(rename = "AggtdPoss"))]
    pub aggtd_poss: PositionSetReport3Choice,

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

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

impl Validate for SecuritiesLendingType3Choice {}
#[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.105.001.01")]
pub struct SecuritiesTransactionPrice18Choice {
    #[yaserde(rename = "MntryVal")]
    #[cfg_attr(feature = "serde", serde(rename = "MntryVal"))]
    pub mntry_val: Option<AmountAndDirection107>,
    #[yaserde(rename = "Pctg")]
    #[cfg_attr(feature = "serde", serde(rename = "Pctg"))]
    pub pctg: Option<PercentageRate>,
    #[yaserde(rename = "Dcml")]
    #[cfg_attr(feature = "serde", serde(rename = "Dcml"))]
    pub dcml: Option<BaseOneRate>,
    #[yaserde(rename = "BsisPts")]
    #[cfg_attr(feature = "serde", serde(rename = "BsisPts"))]
    pub bsis_pts: Option<DecimalNumber>,
}

impl Validate for SecuritiesTransactionPrice18Choice {}
#[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.105.001.01")]
pub struct SecuritiesTransactionPrice19Choice {
    #[yaserde(rename = "MntryVal")]
    #[cfg_attr(feature = "serde", serde(rename = "MntryVal"))]
    pub mntry_val: Option<AmountAndDirection107>,
    #[yaserde(rename = "Unit")]
    #[cfg_attr(feature = "serde", serde(rename = "Unit"))]
    pub unit: Option<LongFraction19DecimalNumber>,
    #[yaserde(rename = "Pctg")]
    #[cfg_attr(feature = "serde", serde(rename = "Pctg"))]
    pub pctg: Option<PercentageRate>,
    #[yaserde(rename = "Yld")]
    #[cfg_attr(feature = "serde", serde(rename = "Yld"))]
    pub yld: Option<PercentageRate>,
    #[yaserde(rename = "Dcml")]
    #[cfg_attr(feature = "serde", serde(rename = "Dcml"))]
    pub dcml: Option<BaseOneRate>,
    #[yaserde(rename = "PdgPric")]
    #[cfg_attr(feature = "serde", serde(rename = "PdgPric"))]
    pub pdg_pric: Option<PriceStatus1Code>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<SecuritiesTransactionPrice5>,
}

impl Validate for SecuritiesTransactionPrice19Choice {}




#[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.105.001.01")]
pub struct SecuritiesTransactionPrice5 {
    #[yaserde(rename = "Val")]
    #[cfg_attr(feature = "serde", serde(rename = "Val"))]
    pub val: LongFraction19DecimalNumber,

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

impl Validate for SecuritiesTransactionPrice5 {}


#[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.105.001.01")]
pub struct Security49 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Isinoct2015Identifier,

    #[yaserde(rename = "ClssfctnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ClssfctnTp"))]
    pub clssfctn_tp: Cfioct2015Identifier,

    #[yaserde(rename = "QtyOrNmnlVal")]
    #[cfg_attr(feature = "serde", serde(rename = "QtyOrNmnlVal"))]
    pub qty_or_nmnl_val: QuantityNominalValue2Choice,

    #[yaserde(rename = "UnitPric")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitPric"))]
    pub unit_pric: SecuritiesTransactionPrice19Choice,

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

    #[yaserde(rename = "Qlty")]
    #[cfg_attr(feature = "serde", serde(rename = "Qlty"))]
    pub qlty: CollateralQualityType1Code,

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

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

    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: Vec<SecuritiesLendingType3Choice>,

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

impl Validate for Security49 {}


#[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.105.001.01")]
pub struct SecurityIssuer4 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: OrganisationIdentification15Choice,

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

impl Validate for SecurityIssuer4 {}


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

pub enum SpecialCollateral1Code {
    #[yaserde(rename = "GENE")]
    #[cfg_attr(feature = "serde", serde(rename = "GENE"))]
    Gene,
    #[yaserde(rename = "SPEC")]
    #[cfg_attr(feature = "serde", serde(rename = "SPEC"))]
    Spec,
    __Unknown__(String),
}

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

impl Validate for SpecialCollateral1Code {}



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

pub enum SpecialPurpose2Code {
    #[yaserde(rename = "BLNK")]
    #[cfg_attr(feature = "serde", serde(rename = "BLNK"))]
    Blnk,
    #[yaserde(rename = "NTAV")]
    #[cfg_attr(feature = "serde", serde(rename = "NTAV"))]
    Ntav,
    __Unknown__(String),
}

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

impl Validate for SpecialPurpose2Code {}



#[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.105.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.105.001.01")]
pub struct SupplementaryDataEnvelope1 {}

impl Validate for SupplementaryDataEnvelope1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.105.001.01")]
pub struct TimeToMaturity2Choice {
    #[yaserde(rename = "Prd")]
    #[cfg_attr(feature = "serde", serde(rename = "Prd"))]
    pub prd: Option<TimeToMaturityPeriod2>,
    #[yaserde(rename = "Spcl")]
    #[cfg_attr(feature = "serde", serde(rename = "Spcl"))]
    pub spcl: Option<SpecialPurpose2Code>,
}

impl Validate for TimeToMaturity2Choice {}




#[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.105.001.01")]
pub struct TimeToMaturityPeriod2 {
    #[yaserde(rename = "Start")]
    #[cfg_attr(feature = "serde", serde(rename = "Start"))]
    pub start: MaturityTerm2,

    #[yaserde(rename = "End")]
    #[cfg_attr(feature = "serde", serde(rename = "End"))]
    pub end: MaturityTerm2,
}

impl Validate for TimeToMaturityPeriod2 {}


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

pub enum TradeMarket2Code {
    #[yaserde(rename = "DMST")]
    #[cfg_attr(feature = "serde", serde(rename = "DMST"))]
    Dmst,
    #[yaserde(rename = "FRGN")]
    #[cfg_attr(feature = "serde", serde(rename = "FRGN"))]
    Frgn,
    __Unknown__(String),
}

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

impl Validate for TradeMarket2Code {}



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

pub enum TradeRepositoryReportingType1Code {
    #[yaserde(rename = "SWOS")]
    #[cfg_attr(feature = "serde", serde(rename = "SWOS"))]
    Swos,
    #[yaserde(rename = "TWOS")]
    #[cfg_attr(feature = "serde", serde(rename = "TWOS"))]
    Twos,
    __Unknown__(String),
}

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

impl Validate for TradeRepositoryReportingType1Code {}
#[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.105.001.01")]
pub struct TradingVenueType1Choice {
    #[yaserde(rename = "OnVn")]
    #[cfg_attr(feature = "serde", serde(rename = "OnVn"))]
    pub on_vn: Option<TradeMarket2Code>,
    #[yaserde(rename = "OffVn")]
    #[cfg_attr(feature = "serde", serde(rename = "OffVn"))]
    pub off_vn: Option<NoReasonCode>,
}

impl Validate for TradingVenueType1Choice {}




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

impl Validate for TrueFalseIndicator {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.105.001.01")]
pub struct VolumeMetrics4 {
    #[yaserde(rename = "ReuseVal")]
    #[cfg_attr(feature = "serde", serde(rename = "ReuseVal"))]
    pub reuse_val: ReuseValue1Choice,

    #[yaserde(rename = "RinvstdCshAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "RinvstdCshAmt"))]
    pub rinvstd_csh_amt: ActiveOrHistoricCurrencyAndAmount,
}

impl Validate for VolumeMetrics4 {}


#[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.105.001.01")]
pub struct VolumeMetrics5 {
    #[yaserde(rename = "NbOfTxs")]
    #[cfg_attr(feature = "serde", serde(rename = "NbOfTxs"))]
    pub nb_of_txs: Max15NumericText,

    #[yaserde(rename = "Xpsr")]
    #[cfg_attr(feature = "serde", serde(rename = "Xpsr"))]
    pub xpsr: ExposureMetrics4,
}

impl Validate for VolumeMetrics5 {}


#[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.105.001.01")]
pub struct VolumeMetrics6 {
    #[yaserde(rename = "Postv")]
    #[cfg_attr(feature = "serde", serde(rename = "Postv"))]
    pub postv: ExposureMetrics5,

    #[yaserde(rename = "Neg")]
    #[cfg_attr(feature = "serde", serde(rename = "Neg"))]
    pub neg: ExposureMetrics5,
}

impl Validate for VolumeMetrics6 {}

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