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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:reda.004.001.07")]
pub struct AccountIdentificationAndName7 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: CashAccountIdentification8Choice,

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

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

impl Validate for AccountSchemeName1Choice {}




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

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

impl Validate for ActiveCurrencyAnd13DecimalAmount {}


#[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:reda.004.001.07")]
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:reda.004.001.07")]
pub struct AdditionalInformation15 {
    #[yaserde(rename = "InfTp")]
    #[cfg_attr(feature = "serde", serde(rename = "InfTp"))]
    pub inf_tp: GenericIdentification36,

    #[yaserde(rename = "InfVal")]
    #[cfg_attr(feature = "serde", serde(rename = "InfVal"))]
    pub inf_val: Max350Text,
}

impl Validate for AdditionalInformation15 {}


#[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:reda.004.001.07")]
pub struct AdditionalProductInformation3 {
    #[yaserde(rename = "FinInstrmTxCostsExAnteUK")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrmTxCostsExAnteUK"))]
    pub fin_instrm_tx_costs_ex_ante_uk: PercentageRate,

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

impl Validate for AdditionalProductInformation3 {}


#[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:reda.004.001.07")]
pub struct AdditionalReference10 {
    #[yaserde(rename = "Ref")]
    #[cfg_attr(feature = "serde", serde(rename = "Ref"))]
    pub _ref: Max35Text,

    #[yaserde(rename = "RefIssr")]
    #[cfg_attr(feature = "serde", serde(rename = "RefIssr"))]
    pub ref_issr: PartyIdentification139,

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

impl Validate for AdditionalReference10 {}


#[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:reda.004.001.07")]

pub enum AddressType2Code {
    #[yaserde(rename = "ADDR")]
    #[cfg_attr(feature = "serde", serde(rename = "ADDR"))]
    Addr,
    #[yaserde(rename = "PBOX")]
    #[cfg_attr(feature = "serde", serde(rename = "PBOX"))]
    Pbox,
    #[yaserde(rename = "HOME")]
    #[cfg_attr(feature = "serde", serde(rename = "HOME"))]
    Home,
    #[yaserde(rename = "BIZZ")]
    #[cfg_attr(feature = "serde", serde(rename = "BIZZ"))]
    Bizz,
    #[yaserde(rename = "MLTO")]
    #[cfg_attr(feature = "serde", serde(rename = "MLTO"))]
    Mlto,
    #[yaserde(rename = "DLVY")]
    #[cfg_attr(feature = "serde", serde(rename = "DLVY"))]
    Dlvy,
    __Unknown__(String),
}

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

impl Validate for AddressType2Code {}



#[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:reda.004.001.07")]

pub enum AnnualChargePaymentType1Code {
    #[yaserde(rename = "CAPL")]
    #[cfg_attr(feature = "serde", serde(rename = "CAPL"))]
    Capl,
    #[yaserde(rename = "INCO")]
    #[cfg_attr(feature = "serde", serde(rename = "INCO"))]
    Inco,
    __Unknown__(String),
}

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

impl Validate for AnnualChargePaymentType1Code {}



#[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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:reda.004.001.07")]

pub enum AssessmentOfValueRequiredUnderCOLLUKType1Code {
    #[yaserde(rename = "YSCO")]
    #[cfg_attr(feature = "serde", serde(rename = "YSCO"))]
    Ysco,
    #[yaserde(rename = "NSCO")]
    #[cfg_attr(feature = "serde", serde(rename = "NSCO"))]
    Nsco,
    __Unknown__(String),
}

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

impl Validate for AssessmentOfValueRequiredUnderCOLLUKType1Code {}



#[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:reda.004.001.07")]

pub enum BusinessDayConvention1Code {
    #[yaserde(rename = "FWNG")]
    #[cfg_attr(feature = "serde", serde(rename = "FWNG"))]
    Fwng,
    #[yaserde(rename = "PREC")]
    #[cfg_attr(feature = "serde", serde(rename = "PREC"))]
    Prec,
    __Unknown__(String),
}

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

impl Validate for BusinessDayConvention1Code {}



#[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:reda.004.001.07")]
pub struct CashAccount205 {
    #[yaserde(rename = "Ccy")]
    #[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
    pub ccy: ActiveCurrencyCode,

    #[yaserde(rename = "PmryAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "PmryAcct"))]
    pub pmry_acct: CashAccount206,

    #[yaserde(rename = "ScndryAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "ScndryAcct"))]
    pub scndry_acct: CashAccount206,
}

impl Validate for CashAccount205 {}


#[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:reda.004.001.07")]
pub struct CashAccount206 {
    #[yaserde(rename = "AcctId")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctId"))]
    pub acct_id: AccountIdentificationAndName7,

    #[yaserde(rename = "Svcr")]
    #[cfg_attr(feature = "serde", serde(rename = "Svcr"))]
    pub svcr: AnyBICDec2014Identifier,

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

impl Validate for CashAccount206 {}
#[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:reda.004.001.07")]
pub struct CashAccountIdentification8Choice {
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<GenericAccountIdentification1>,
    #[yaserde(rename = "IBAN")]
    #[cfg_attr(feature = "serde", serde(rename = "IBAN"))]
    pub iban: Option<Iban2007Identifier>,
}

impl Validate for CashAccountIdentification8Choice {}
#[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:reda.004.001.07")]
pub struct ChargeType8Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<InvestmentFundMiFIDFee2Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for ChargeType8Choice {}




#[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:reda.004.001.07")]
pub struct ContactAttributes5 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max350Text,

    #[yaserde(rename = "PstlAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "PstlAdr"))]
    pub pstl_adr: PostalAddress1,

    #[yaserde(rename = "PhneNb")]
    #[cfg_attr(feature = "serde", serde(rename = "PhneNb"))]
    pub phne_nb: PhoneNumber,

    #[yaserde(rename = "FaxNb")]
    #[cfg_attr(feature = "serde", serde(rename = "FaxNb"))]
    pub fax_nb: PhoneNumber,

    #[yaserde(rename = "EmailAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "EmailAdr"))]
    pub email_adr: Max256Text,

    #[yaserde(rename = "URLAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "URLAdr"))]
    pub url_adr: Max2048Text,

    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_bic: AnyBICDec2014Identifier,

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

impl Validate for ContactAttributes5 {}


#[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:reda.004.001.07")]
pub struct ContactAttributes6 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max350Text,

    #[yaserde(rename = "PstlAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "PstlAdr"))]
    pub pstl_adr: PostalAddress1,

    #[yaserde(rename = "PhneNb")]
    #[cfg_attr(feature = "serde", serde(rename = "PhneNb"))]
    pub phne_nb: PhoneNumber,

    #[yaserde(rename = "FaxNb")]
    #[cfg_attr(feature = "serde", serde(rename = "FaxNb"))]
    pub fax_nb: PhoneNumber,

    #[yaserde(rename = "EmailAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "EmailAdr"))]
    pub email_adr: Max256Text,

    #[yaserde(rename = "URLAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "URLAdr"))]
    pub url_adr: Max2048Text,

    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_bic: AnyBICDec2014Identifier,

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

impl Validate for ContactAttributes6 {}


#[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:reda.004.001.07")]
pub struct CostsAndCharges2 {
    #[yaserde(rename = "ExAnteRefDt")]
    #[cfg_attr(feature = "serde", serde(rename = "ExAnteRefDt"))]
    pub ex_ante_ref_dt: Isodate,

    #[yaserde(rename = "IndvCostOrChrg")]
    #[cfg_attr(feature = "serde", serde(rename = "IndvCostOrChrg"))]
    pub indv_cost_or_chrg: Vec<IndividualCostOrCharge2>,

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

impl Validate for CostsAndCharges2 {}


#[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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:reda.004.001.07")]

pub enum DistributionPolicy1Code {
    #[yaserde(rename = "DIST")]
    #[cfg_attr(feature = "serde", serde(rename = "DIST"))]
    Dist,
    #[yaserde(rename = "ACCU")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCU"))]
    Accu,
    __Unknown__(String),
}

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

impl Validate for DistributionPolicy1Code {}



#[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:reda.004.001.07")]
pub struct DistributionStrategy1 {
    #[yaserde(rename = "ExctnOnly")]
    #[cfg_attr(feature = "serde", serde(rename = "ExctnOnly"))]
    pub exctn_only: DistributionStrategy1Choice,

    #[yaserde(rename = "ExctnWthApprprtnssTstOrNonAdvsdSvcs")]
    #[cfg_attr(feature = "serde", serde(rename = "ExctnWthApprprtnssTstOrNonAdvsdSvcs"))]
    pub exctn_wth_apprprtnss_tst_or_non_advsd_svcs: DistributionStrategy1Choice,

    #[yaserde(rename = "InvstmtAdvc")]
    #[cfg_attr(feature = "serde", serde(rename = "InvstmtAdvc"))]
    pub invstmt_advc: DistributionStrategy1Choice,

    #[yaserde(rename = "PrtflMgmt")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtflMgmt"))]
    pub prtfl_mgmt: DistributionStrategy1Choice,

    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Vec<OtherDistributionStrategy1>,
}

impl Validate for DistributionStrategy1 {}
#[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:reda.004.001.07")]
pub struct DistributionStrategy1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<InvestorType3Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for DistributionStrategy1Choice {}




#[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:reda.004.001.07")]

pub enum DividendPolicy1Code {
    #[yaserde(rename = "CASH")]
    #[cfg_attr(feature = "serde", serde(rename = "CASH"))]
    Cash,
    #[yaserde(rename = "UNIT")]
    #[cfg_attr(feature = "serde", serde(rename = "UNIT"))]
    Unit,
    #[yaserde(rename = "BOTH")]
    #[cfg_attr(feature = "serde", serde(rename = "BOTH"))]
    Both,
    __Unknown__(String),
}

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

impl Validate for DividendPolicy1Code {}



#[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:reda.004.001.07")]
pub struct Document {
    #[yaserde(rename = "FndRefDataRpt")]
    #[cfg_attr(feature = "serde", serde(rename = "FndRefDataRpt"))]
    pub fnd_ref_data_rpt: FundReferenceDataReportV07,
}

impl Validate for Document {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:reda.004.001.07")]

pub enum EmtdataReportingVFMUKType1Code {
    #[yaserde(rename = "YSCO")]
    #[cfg_attr(feature = "serde", serde(rename = "YSCO"))]
    Ysco,
    __Unknown__(String),
}

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

impl Validate for EmtdataReportingVFMUKType1Code {}



#[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:reda.004.001.07")]

pub enum EusavingsDirective1Code {
    #[yaserde(rename = "EUSI")]
    #[cfg_attr(feature = "serde", serde(rename = "EUSI"))]
    Eusi,
    #[yaserde(rename = "EUSO")]
    #[cfg_attr(feature = "serde", serde(rename = "EUSO"))]
    Euso,
    #[yaserde(rename = "VARI")]
    #[cfg_attr(feature = "serde", serde(rename = "VARI"))]
    Vari,
    __Unknown__(String),
}

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

impl Validate for EusavingsDirective1Code {}



#[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:reda.004.001.07")]

pub enum EventFrequency5Code {
    #[yaserde(rename = "YEAR")]
    #[cfg_attr(feature = "serde", serde(rename = "YEAR"))]
    Year,
    #[yaserde(rename = "SEMI")]
    #[cfg_attr(feature = "serde", serde(rename = "SEMI"))]
    Semi,
    #[yaserde(rename = "QUTR")]
    #[cfg_attr(feature = "serde", serde(rename = "QUTR"))]
    Qutr,
    #[yaserde(rename = "MNTH")]
    #[cfg_attr(feature = "serde", serde(rename = "MNTH"))]
    Mnth,
    #[yaserde(rename = "WEEK")]
    #[cfg_attr(feature = "serde", serde(rename = "WEEK"))]
    Week,
    #[yaserde(rename = "DAIL")]
    #[cfg_attr(feature = "serde", serde(rename = "DAIL"))]
    Dail,
    #[yaserde(rename = "CLOS")]
    #[cfg_attr(feature = "serde", serde(rename = "CLOS"))]
    Clos,
    #[yaserde(rename = "TOMN")]
    #[cfg_attr(feature = "serde", serde(rename = "TOMN"))]
    Tomn,
    #[yaserde(rename = "TOWK")]
    #[cfg_attr(feature = "serde", serde(rename = "TOWK"))]
    Towk,
    #[yaserde(rename = "TWMN")]
    #[cfg_attr(feature = "serde", serde(rename = "TWMN"))]
    Twmn,
    __Unknown__(String),
}

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

impl Validate for EventFrequency5Code {}



#[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:reda.004.001.07")]

pub enum EventFrequency8Code {
    #[yaserde(rename = "ADHO")]
    #[cfg_attr(feature = "serde", serde(rename = "ADHO"))]
    Adho,
    #[yaserde(rename = "YEAR")]
    #[cfg_attr(feature = "serde", serde(rename = "YEAR"))]
    Year,
    #[yaserde(rename = "DAIL")]
    #[cfg_attr(feature = "serde", serde(rename = "DAIL"))]
    Dail,
    #[yaserde(rename = "FOMN")]
    #[cfg_attr(feature = "serde", serde(rename = "FOMN"))]
    Fomn,
    #[yaserde(rename = "TOMN")]
    #[cfg_attr(feature = "serde", serde(rename = "TOMN"))]
    Tomn,
    #[yaserde(rename = "TOWK")]
    #[cfg_attr(feature = "serde", serde(rename = "TOWK"))]
    Towk,
    #[yaserde(rename = "TYEA")]
    #[cfg_attr(feature = "serde", serde(rename = "TYEA"))]
    Tyea,
    #[yaserde(rename = "INDA")]
    #[cfg_attr(feature = "serde", serde(rename = "INDA"))]
    Inda,
    #[yaserde(rename = "MNTH")]
    #[cfg_attr(feature = "serde", serde(rename = "MNTH"))]
    Mnth,
    #[yaserde(rename = "ONDE")]
    #[cfg_attr(feature = "serde", serde(rename = "ONDE"))]
    Onde,
    #[yaserde(rename = "OVNG")]
    #[cfg_attr(feature = "serde", serde(rename = "OVNG"))]
    Ovng,
    #[yaserde(rename = "QUTR")]
    #[cfg_attr(feature = "serde", serde(rename = "QUTR"))]
    Qutr,
    #[yaserde(rename = "SEMI")]
    #[cfg_attr(feature = "serde", serde(rename = "SEMI"))]
    Semi,
    #[yaserde(rename = "TWMN")]
    #[cfg_attr(feature = "serde", serde(rename = "TWMN"))]
    Twmn,
    #[yaserde(rename = "WEEK")]
    #[cfg_attr(feature = "serde", serde(rename = "WEEK"))]
    Week,
    __Unknown__(String),
}

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

impl Validate for EventFrequency8Code {}
#[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:reda.004.001.07")]
pub struct ExPostCostCalculationBasis1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ExPostCostCalculationBasis1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for ExPostCostCalculationBasis1Choice {}




#[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:reda.004.001.07")]

pub enum ExPostCostCalculationBasis1Code {
    #[yaserde(rename = "FIXB")]
    #[cfg_attr(feature = "serde", serde(rename = "FIXB"))]
    Fixb,
    #[yaserde(rename = "ROLL")]
    #[cfg_attr(feature = "serde", serde(rename = "ROLL"))]
    Roll,
    __Unknown__(String),
}

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

impl Validate for ExPostCostCalculationBasis1Code {}



#[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:reda.004.001.07")]
pub struct ExtendedParty13 {
    #[yaserde(rename = "PtyRole")]
    #[cfg_attr(feature = "serde", serde(rename = "PtyRole"))]
    pub pty_role: GenericIdentification36,

    #[yaserde(rename = "OthrPtyDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrPtyDtls"))]
    pub othr_pty_dtls: ContactAttributes5,
}

impl Validate for ExtendedParty13 {}


#[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:reda.004.001.07")]
pub struct Extension1 {
    #[yaserde(rename = "PlcAndNm")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcAndNm"))]
    pub plc_and_nm: Max350Text,

    #[yaserde(rename = "Txt")]
    #[cfg_attr(feature = "serde", serde(rename = "Txt"))]
    pub txt: Max350Text,
}

impl Validate for Extension1 {}


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

impl Validate for ExternalAccountIdentification1Code {
    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 ExternalFinancialInstrumentIdentificationType1Code (pub String);
crate::simple_type!(ExternalFinancialInstrumentIdentificationType1Code);

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

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:reda.004.001.07")]
pub struct FinancialInstrument96 {
    #[yaserde(rename = "PhysBrScties")]
    #[cfg_attr(feature = "serde", serde(rename = "PhysBrScties"))]
    pub phys_br_scties: YesNoIndicator,

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

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

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

    #[yaserde(rename = "DstrbtnPlcy")]
    #[cfg_attr(feature = "serde", serde(rename = "DstrbtnPlcy"))]
    pub dstrbtn_plcy: DistributionPolicy1Code,

    #[yaserde(rename = "DvddPlcy")]
    #[cfg_attr(feature = "serde", serde(rename = "DvddPlcy"))]
    pub dvdd_plcy: DividendPolicy1Code,

    #[yaserde(rename = "DvddFrqcy")]
    #[cfg_attr(feature = "serde", serde(rename = "DvddFrqcy"))]
    pub dvdd_frqcy: EventFrequency5Code,

    #[yaserde(rename = "RinvstmtFrqcy")]
    #[cfg_attr(feature = "serde", serde(rename = "RinvstmtFrqcy"))]
    pub rinvstmt_frqcy: EventFrequency5Code,

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

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

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

    #[yaserde(rename = "EUSvgsDrctv")]
    #[cfg_attr(feature = "serde", serde(rename = "EUSvgsDrctv"))]
    pub eu_svgs_drctv: EusavingsDirective1Code,

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

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

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

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

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

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

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

    #[yaserde(rename = "MayBeTermntdEarly")]
    #[cfg_attr(feature = "serde", serde(rename = "MayBeTermntdEarly"))]
    pub may_be_termntd_early: TargetMarket1Code,

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

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

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

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

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

    #[yaserde(rename = "MgmtFeeSrc")]
    #[cfg_attr(feature = "serde", serde(rename = "MgmtFeeSrc"))]
    pub mgmt_fee_src: AnnualChargePaymentType1Code,

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

    #[yaserde(rename = "AddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
    pub addtl_inf: Vec<AdditionalInformation15>,
}

impl Validate for FinancialInstrument96 {}


#[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:reda.004.001.07")]
pub struct Forms1 {
    #[yaserde(rename = "ApplForm")]
    #[cfg_attr(feature = "serde", serde(rename = "ApplForm"))]
    pub appl_form: YesNoIndicator,

    #[yaserde(rename = "SgntrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SgntrTp"))]
    pub sgntr_tp: SignatureType1Code,
}

impl Validate for Forms1 {}
#[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:reda.004.001.07")]
pub struct Frequency20Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<EventFrequency8Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for Frequency20Choice {}




#[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:reda.004.001.07")]

pub enum FundOrderType10Code {
    #[yaserde(rename = "SUBS")]
    #[cfg_attr(feature = "serde", serde(rename = "SUBS"))]
    Subs,
    #[yaserde(rename = "RDIV")]
    #[cfg_attr(feature = "serde", serde(rename = "RDIV"))]
    Rdiv,
    #[yaserde(rename = "REDM")]
    #[cfg_attr(feature = "serde", serde(rename = "REDM"))]
    Redm,
    #[yaserde(rename = "RGSV")]
    #[cfg_attr(feature = "serde", serde(rename = "RGSV"))]
    Rgsv,
    #[yaserde(rename = "WIDP")]
    #[cfg_attr(feature = "serde", serde(rename = "WIDP"))]
    Widp,
    __Unknown__(String),
}

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

impl Validate for FundOrderType10Code {}
#[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:reda.004.001.07")]
pub struct FundOrderType5Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<FundOrderType10Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification36>,
}

impl Validate for FundOrderType5Choice {}




#[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:reda.004.001.07")]
pub struct FundParties1 {
    #[yaserde(rename = "Guarntr")]
    #[cfg_attr(feature = "serde", serde(rename = "Guarntr"))]
    pub guarntr: ContactAttributes5,

    #[yaserde(rename = "Audtr")]
    #[cfg_attr(feature = "serde", serde(rename = "Audtr"))]
    pub audtr: ContactAttributes5,

    #[yaserde(rename = "Trstee")]
    #[cfg_attr(feature = "serde", serde(rename = "Trstee"))]
    pub trstee: ContactAttributes5,

    #[yaserde(rename = "OthrPty")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrPty"))]
    pub othr_pty: Vec<ExtendedParty13>,
}

impl Validate for FundParties1 {}
#[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:reda.004.001.07")]
pub struct FundPaymentType1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<FundPaymentType1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification36>,
}

impl Validate for FundPaymentType1Choice {}




#[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:reda.004.001.07")]

pub enum FundPaymentType1Code {
    #[yaserde(rename = "DRAF")]
    #[cfg_attr(feature = "serde", serde(rename = "DRAF"))]
    Draf,
    #[yaserde(rename = "CACC")]
    #[cfg_attr(feature = "serde", serde(rename = "CACC"))]
    Cacc,
    #[yaserde(rename = "CHEQ")]
    #[cfg_attr(feature = "serde", serde(rename = "CHEQ"))]
    Cheq,
    #[yaserde(rename = "CRDT")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDT"))]
    Crdt,
    #[yaserde(rename = "DDEB")]
    #[cfg_attr(feature = "serde", serde(rename = "DDEB"))]
    Ddeb,
    #[yaserde(rename = "CARD")]
    #[cfg_attr(feature = "serde", serde(rename = "CARD"))]
    Card,
    __Unknown__(String),
}

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

impl Validate for FundPaymentType1Code {}



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

    #[yaserde(rename = "Vrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Vrsn"))]
    pub vrsn: MarketPracticeVersion1,

    #[yaserde(rename = "AuthrsdPrxy")]
    #[cfg_attr(feature = "serde", serde(rename = "AuthrsdPrxy"))]
    pub authrsd_prxy: ContactAttributes6,

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

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

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

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

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

    #[yaserde(rename = "FndPties")]
    #[cfg_attr(feature = "serde", serde(rename = "FndPties"))]
    pub fnd_pties: FundParties1,

    #[yaserde(rename = "MainFndOrdrDsk")]
    #[cfg_attr(feature = "serde", serde(rename = "MainFndOrdrDsk"))]
    pub main_fnd_ordr_dsk: OrderDesk1,

    #[yaserde(rename = "FndMgmtCpny")]
    #[cfg_attr(feature = "serde", serde(rename = "FndMgmtCpny"))]
    pub fnd_mgmt_cpny: ContactAttributes5,

    #[yaserde(rename = "FndDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "FndDtls"))]
    pub fnd_dtls: FinancialInstrument96,

    #[yaserde(rename = "ValtnDealgChrtcs")]
    #[cfg_attr(feature = "serde", serde(rename = "ValtnDealgChrtcs"))]
    pub valtn_dealg_chrtcs: ValuationDealingProcessingCharacteristics3,

    #[yaserde(rename = "InvstmtRstrctns")]
    #[cfg_attr(feature = "serde", serde(rename = "InvstmtRstrctns"))]
    pub invstmt_rstrctns: InvestmentRestrictions3,

    #[yaserde(rename = "SbcptPrcgChrtcs")]
    #[cfg_attr(feature = "serde", serde(rename = "SbcptPrcgChrtcs"))]
    pub sbcpt_prcg_chrtcs: ProcessingCharacteristics11,

    #[yaserde(rename = "RedPrcgChrtcs")]
    #[cfg_attr(feature = "serde", serde(rename = "RedPrcgChrtcs"))]
    pub red_prcg_chrtcs: ProcessingCharacteristics12,

    #[yaserde(rename = "SwtchPrcgChrtcs")]
    #[cfg_attr(feature = "serde", serde(rename = "SwtchPrcgChrtcs"))]
    pub swtch_prcg_chrtcs: ProcessingCharacteristics9,

    #[yaserde(rename = "PlanChrtcs")]
    #[cfg_attr(feature = "serde", serde(rename = "PlanChrtcs"))]
    pub plan_chrtcs: Vec<InvestmentPlanCharacteristics1>,

    #[yaserde(rename = "PmtInstrm")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtInstrm"))]
    pub pmt_instrm: Vec<PaymentInstrument16>,

    #[yaserde(rename = "CshSttlmDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "CshSttlmDtls"))]
    pub csh_sttlm_dtls: Vec<CashAccount205>,

    #[yaserde(rename = "LclMktAnx")]
    #[cfg_attr(feature = "serde", serde(rename = "LclMktAnx"))]
    pub lcl_mkt_anx: Vec<LocalMarketAnnex6>,

    #[yaserde(rename = "TrgtMkt")]
    #[cfg_attr(feature = "serde", serde(rename = "TrgtMkt"))]
    pub trgt_mkt: TargetMarket4,

    #[yaserde(rename = "DstrbtnStrtgy")]
    #[cfg_attr(feature = "serde", serde(rename = "DstrbtnStrtgy"))]
    pub dstrbtn_strtgy: DistributionStrategy1,

    #[yaserde(rename = "CostsAndChrgs")]
    #[cfg_attr(feature = "serde", serde(rename = "CostsAndChrgs"))]
    pub costs_and_chrgs: Vec<CostsAndCharges2>,

    #[yaserde(rename = "AddtlInfUKMkt")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlInfUKMkt"))]
    pub addtl_inf_uk_mkt: AdditionalProductInformation3,

    #[yaserde(rename = "ValForMny")]
    #[cfg_attr(feature = "serde", serde(rename = "ValForMny"))]
    pub val_for_mny: ValueForMoney1,

    #[yaserde(rename = "Xtnsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Xtnsn"))]
    pub xtnsn: Vec<Extension1>,
}

impl Validate for FundReferenceDataReport5 {}


#[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:reda.004.001.07")]
pub struct FundReferenceDataReportV07 {
    #[yaserde(rename = "MsgId")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgId"))]
    pub msg_id: MessageIdentification1,

    #[yaserde(rename = "PrvsRef")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvsRef"))]
    pub prvs_ref: Vec<AdditionalReference10>,

    #[yaserde(rename = "RltdRef")]
    #[cfg_attr(feature = "serde", serde(rename = "RltdRef"))]
    pub rltd_ref: AdditionalReference10,

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

    #[yaserde(rename = "Rpt")]
    #[cfg_attr(feature = "serde", serde(rename = "Rpt"))]
    pub rpt: Vec<FundReferenceDataReport5>,
}

impl Validate for FundReferenceDataReportV07 {}


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

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

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

impl Validate for GenericAccountIdentification1 {}


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

    #[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 GenericIdentification1 {}


#[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:reda.004.001.07")]
pub struct GenericIdentification3 {
    #[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,
}

impl Validate for GenericIdentification3 {}


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

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

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

impl Validate for GenericIdentification36 {}


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

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

impl Validate for GenericIdentification47 {}
#[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:reda.004.001.07")]
pub struct GovernanceProcess1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<GovernanceProcessType1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for GovernanceProcess1Choice {}




#[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:reda.004.001.07")]

pub enum GovernanceProcessType1Code {
    #[yaserde(rename = "BMIF")]
    #[cfg_attr(feature = "serde", serde(rename = "BMIF"))]
    Bmif,
    #[yaserde(rename = "NINF")]
    #[cfg_attr(feature = "serde", serde(rename = "NINF"))]
    Ninf,
    #[yaserde(rename = "CMIF")]
    #[cfg_attr(feature = "serde", serde(rename = "CMIF"))]
    Cmif,
    #[yaserde(rename = "AMIF")]
    #[cfg_attr(feature = "serde", serde(rename = "AMIF"))]
    Amif,
    __Unknown__(String),
}

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

impl Validate for GovernanceProcessType1Code {}



#[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:reda.004.001.07")]

pub enum HoldingTransferable1Code {
    #[yaserde(rename = "TRAL")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAL"))]
    Tral,
    #[yaserde(rename = "TRNA")]
    #[cfg_attr(feature = "serde", serde(rename = "TRNA"))]
    Trna,
    #[yaserde(rename = "RFOD")]
    #[cfg_attr(feature = "serde", serde(rename = "RFOD"))]
    Rfod,
    __Unknown__(String),
}

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

impl Validate for HoldingTransferable1Code {}



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

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

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

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

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

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

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

impl Validate for IdentificationSource3Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:reda.004.001.07")]
pub struct IndividualCostOrCharge2 {
    #[yaserde(rename = "CostTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CostTp"))]
    pub cost_tp: ChargeType8Choice,

    #[yaserde(rename = "ExAnteOrExPst")]
    #[cfg_attr(feature = "serde", serde(rename = "ExAnteOrExPst"))]
    pub ex_ante_or_ex_pst: IntendedOrActual2Code,

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

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

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

    #[yaserde(rename = "RefPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "RefPrd"))]
    pub ref_prd: Period15,

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

impl Validate for IndividualCostOrCharge2 {}


#[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:reda.004.001.07")]

pub enum IntendedOrActual2Code {
    #[yaserde(rename = "ANTE")]
    #[cfg_attr(feature = "serde", serde(rename = "ANTE"))]
    Ante,
    #[yaserde(rename = "POST")]
    #[cfg_attr(feature = "serde", serde(rename = "POST"))]
    Post,
    __Unknown__(String),
}

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

impl Validate for IntendedOrActual2Code {}



#[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:reda.004.001.07")]

pub enum InvestmentFundMiFIDFee2Code {
    #[yaserde(rename = "BORF")]
    #[cfg_attr(feature = "serde", serde(rename = "BORF"))]
    Borf,
    #[yaserde(rename = "DIS2")]
    #[cfg_attr(feature = "serde", serde(rename = "DIS2"))]
    Dis2,
    #[yaserde(rename = "FES3")]
    #[cfg_attr(feature = "serde", serde(rename = "FES3"))]
    Fes3,
    #[yaserde(rename = "FEND")]
    #[cfg_attr(feature = "serde", serde(rename = "FEND"))]
    Fend,
    #[yaserde(rename = "FES2")]
    #[cfg_attr(feature = "serde", serde(rename = "FES2"))]
    Fes2,
    #[yaserde(rename = "GOC1")]
    #[cfg_attr(feature = "serde", serde(rename = "GOC1"))]
    Goc1,
    #[yaserde(rename = "GOCS")]
    #[cfg_attr(feature = "serde", serde(rename = "GOCS"))]
    Gocs,
    #[yaserde(rename = "INCF")]
    #[cfg_attr(feature = "serde", serde(rename = "INCF"))]
    Incf,
    #[yaserde(rename = "INCS")]
    #[cfg_attr(feature = "serde", serde(rename = "INCS"))]
    Incs,
    #[yaserde(rename = "MNF1")]
    #[cfg_attr(feature = "serde", serde(rename = "MNF1"))]
    Mnf1,
    #[yaserde(rename = "MANS")]
    #[cfg_attr(feature = "serde", serde(rename = "MANS"))]
    Mans,
    #[yaserde(rename = "NET2")]
    #[cfg_attr(feature = "serde", serde(rename = "NET2"))]
    Net2,
    #[yaserde(rename = "NESF")]
    #[cfg_attr(feature = "serde", serde(rename = "NESF"))]
    Nesf,
    #[yaserde(rename = "NETO")]
    #[cfg_attr(feature = "serde", serde(rename = "NETO"))]
    Neto,
    #[yaserde(rename = "NRAM")]
    #[cfg_attr(feature = "serde", serde(rename = "NRAM"))]
    Nram,
    #[yaserde(rename = "OOEA")]
    #[cfg_attr(feature = "serde", serde(rename = "OOEA"))]
    Ooea,
    #[yaserde(rename = "OOSF")]
    #[cfg_attr(feature = "serde", serde(rename = "OOSF"))]
    Oosf,
    #[yaserde(rename = "OOSS")]
    #[cfg_attr(feature = "serde", serde(rename = "OOSS"))]
    Ooss,
    #[yaserde(rename = "BENS")]
    #[cfg_attr(feature = "serde", serde(rename = "BENS"))]
    Bens,
    #[yaserde(rename = "ENAC")]
    #[cfg_attr(feature = "serde", serde(rename = "ENAC"))]
    Enac,
    #[yaserde(rename = "ENFX")]
    #[cfg_attr(feature = "serde", serde(rename = "ENFX"))]
    Enfx,
    #[yaserde(rename = "EXAC")]
    #[cfg_attr(feature = "serde", serde(rename = "EXAC"))]
    Exac,
    #[yaserde(rename = "ENBX")]
    #[cfg_attr(feature = "serde", serde(rename = "ENBX"))]
    Enbx,
    #[yaserde(rename = "BEND")]
    #[cfg_attr(feature = "serde", serde(rename = "BEND"))]
    Bend,
    #[yaserde(rename = "PENO")]
    #[cfg_attr(feature = "serde", serde(rename = "PENO"))]
    Peno,
    #[yaserde(rename = "OTES")]
    #[cfg_attr(feature = "serde", serde(rename = "OTES"))]
    Otes,
    #[yaserde(rename = "OCAS")]
    #[cfg_attr(feature = "serde", serde(rename = "OCAS"))]
    Ocas,
    #[yaserde(rename = "RPSS")]
    #[cfg_attr(feature = "serde", serde(rename = "RPSS"))]
    Rpss,
    #[yaserde(rename = "TRS1")]
    #[cfg_attr(feature = "serde", serde(rename = "TRS1"))]
    Trs1,
    __Unknown__(String),
}

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

impl Validate for InvestmentFundMiFIDFee2Code {}
#[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:reda.004.001.07")]
pub struct InvestmentFundPlanType1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<InvestmentFundPlanType1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification36>,
}

impl Validate for InvestmentFundPlanType1Choice {}




#[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:reda.004.001.07")]

pub enum InvestmentFundPlanType1Code {
    #[yaserde(rename = "INVP")]
    #[cfg_attr(feature = "serde", serde(rename = "INVP"))]
    Invp,
    #[yaserde(rename = "SWIP")]
    #[cfg_attr(feature = "serde", serde(rename = "SWIP"))]
    Swip,
    #[yaserde(rename = "WTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "WTHP"))]
    Wthp,
    __Unknown__(String),
}

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

impl Validate for InvestmentFundPlanType1Code {}
#[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:reda.004.001.07")]
pub struct InvestmentNeed2Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<InvestmentNeed2Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for InvestmentNeed2Choice {}




#[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:reda.004.001.07")]

pub enum InvestmentNeed2Code {
    #[yaserde(rename = "NSPE")]
    #[cfg_attr(feature = "serde", serde(rename = "NSPE"))]
    Nspe,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "ISLB")]
    #[cfg_attr(feature = "serde", serde(rename = "ISLB"))]
    Islb,
    __Unknown__(String),
}

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

impl Validate for InvestmentNeed2Code {}



#[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:reda.004.001.07")]
pub struct InvestmentPlanCharacteristics1 {
    #[yaserde(rename = "PlanTp")]
    #[cfg_attr(feature = "serde", serde(rename = "PlanTp"))]
    pub plan_tp: InvestmentFundPlanType1Choice,

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

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

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

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

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

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

    #[yaserde(rename = "AddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
    pub addtl_inf: Vec<AdditionalInformation15>,
}

impl Validate for InvestmentPlanCharacteristics1 {}


#[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:reda.004.001.07")]
pub struct InvestmentRestrictions3 {
    #[yaserde(rename = "MinInitlSbcptAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "MinInitlSbcptAmt"))]
    pub min_initl_sbcpt_amt: ActiveCurrencyAndAmount,

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

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

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

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

    #[yaserde(rename = "MaxRedUnits")]
    #[cfg_attr(feature = "serde", serde(rename = "MaxRedUnits"))]
    pub max_red_units: DecimalNumber,

    #[yaserde(rename = "MinRedPctg")]
    #[cfg_attr(feature = "serde", serde(rename = "MinRedPctg"))]
    pub min_red_pctg: DecimalNumber,

    #[yaserde(rename = "OthrRedRstrctns")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrRedRstrctns"))]
    pub othr_red_rstrctns: Max350Text,

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

    #[yaserde(rename = "MinSwtchSbcptUnits")]
    #[cfg_attr(feature = "serde", serde(rename = "MinSwtchSbcptUnits"))]
    pub min_swtch_sbcpt_units: DecimalNumber,

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

    #[yaserde(rename = "MaxSwtchRedUnits")]
    #[cfg_attr(feature = "serde", serde(rename = "MaxSwtchRedUnits"))]
    pub max_swtch_red_units: DecimalNumber,

    #[yaserde(rename = "OthrSwtchRstrctns")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrSwtchRstrctns"))]
    pub othr_swtch_rstrctns: Max350Text,

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

    #[yaserde(rename = "MinHldgUnits")]
    #[cfg_attr(feature = "serde", serde(rename = "MinHldgUnits"))]
    pub min_hldg_units: DecimalNumber,

    #[yaserde(rename = "MinHldgPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "MinHldgPrd"))]
    pub min_hldg_prd: Max70Text,

    #[yaserde(rename = "HldgTrfbl")]
    #[cfg_attr(feature = "serde", serde(rename = "HldgTrfbl"))]
    pub hldg_trfbl: HoldingTransferable1Code,

    #[yaserde(rename = "AddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
    pub addtl_inf: Vec<AdditionalInformation15>,
}

impl Validate for InvestmentRestrictions3 {}


#[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:reda.004.001.07")]
pub struct InvestorKnowledge1 {
    #[yaserde(rename = "BsicInvstr")]
    #[cfg_attr(feature = "serde", serde(rename = "BsicInvstr"))]
    pub bsic_invstr: TargetMarket1Code,

    #[yaserde(rename = "InfrmdInvstr")]
    #[cfg_attr(feature = "serde", serde(rename = "InfrmdInvstr"))]
    pub infrmd_invstr: TargetMarket1Code,

    #[yaserde(rename = "AdvncdInvstr")]
    #[cfg_attr(feature = "serde", serde(rename = "AdvncdInvstr"))]
    pub advncd_invstr: TargetMarket1Code,

    #[yaserde(rename = "ExprtInvstrDE")]
    #[cfg_attr(feature = "serde", serde(rename = "ExprtInvstrDE"))]
    pub exprt_invstr_de: TargetMarket1Code,

    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Vec<OtherTargetMarketInvestorKnowledge1>,
}

impl Validate for InvestorKnowledge1 {}


#[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:reda.004.001.07")]
pub struct InvestorRequirements4 {
    #[yaserde(rename = "RtrPrflPrsrvtn")]
    #[cfg_attr(feature = "serde", serde(rename = "RtrPrflPrsrvtn"))]
    pub rtr_prfl_prsrvtn: TargetMarket1Code,

    #[yaserde(rename = "RtrPrflGrwth")]
    #[cfg_attr(feature = "serde", serde(rename = "RtrPrflGrwth"))]
    pub rtr_prfl_grwth: TargetMarket1Code,

    #[yaserde(rename = "RtrPrflIncm")]
    #[cfg_attr(feature = "serde", serde(rename = "RtrPrflIncm"))]
    pub rtr_prfl_incm: TargetMarket1Code,

    #[yaserde(rename = "RtrPrflHdgg")]
    #[cfg_attr(feature = "serde", serde(rename = "RtrPrflHdgg"))]
    pub rtr_prfl_hdgg: TargetMarket1Code,

    #[yaserde(rename = "OptnOrLvrgdRtrPrfl")]
    #[cfg_attr(feature = "serde", serde(rename = "OptnOrLvrgdRtrPrfl"))]
    pub optn_or_lvrgd_rtr_prfl: TargetMarket1Code,

    #[yaserde(rename = "RtrPrflPnsnSchmeDE")]
    #[cfg_attr(feature = "serde", serde(rename = "RtrPrflPnsnSchmeDE"))]
    pub rtr_prfl_pnsn_schme_de: TargetMarket1Code,

    #[yaserde(rename = "MinHldgPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "MinHldgPrd"))]
    pub min_hldg_prd: TimeHorizon2Choice,

    #[yaserde(rename = "SstnbltyPrefs")]
    #[cfg_attr(feature = "serde", serde(rename = "SstnbltyPrefs"))]
    pub sstnblty_prefs: SustainabilityPreferences2Code,

    #[yaserde(rename = "OthrSpcfcInvstmtNeed")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrSpcfcInvstmtNeed"))]
    pub othr_spcfc_invstmt_need: InvestmentNeed2Choice,

    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Vec<OtherInvestmentNeed1>,
}

impl Validate for InvestorRequirements4 {}


#[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:reda.004.001.07")]
pub struct InvestorType2 {
    #[yaserde(rename = "InvstrTpRtl")]
    #[cfg_attr(feature = "serde", serde(rename = "InvstrTpRtl"))]
    pub invstr_tp_rtl: TargetMarket1Code,

    #[yaserde(rename = "InvstrTpPrfssnl")]
    #[cfg_attr(feature = "serde", serde(rename = "InvstrTpPrfssnl"))]
    pub invstr_tp_prfssnl: TargetMarket5Choice,

    #[yaserde(rename = "InvstrTpElgblCtrPty")]
    #[cfg_attr(feature = "serde", serde(rename = "InvstrTpElgblCtrPty"))]
    pub invstr_tp_elgbl_ctr_pty: TargetMarket3Code,

    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Vec<OtherTargetMarketInvestor1>,
}

impl Validate for InvestorType2 {}


#[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:reda.004.001.07")]

pub enum InvestorType2Code {
    #[yaserde(rename = "BOT3")]
    #[cfg_attr(feature = "serde", serde(rename = "BOT3"))]
    Bot3,
    #[yaserde(rename = "EPRO")]
    #[cfg_attr(feature = "serde", serde(rename = "EPRO"))]
    Epro,
    #[yaserde(rename = "PRF2")]
    #[cfg_attr(feature = "serde", serde(rename = "PRF2"))]
    Prf2,
    __Unknown__(String),
}

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

impl Validate for InvestorType2Code {}



#[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:reda.004.001.07")]

pub enum InvestorType3Code {
    #[yaserde(rename = "RETL")]
    #[cfg_attr(feature = "serde", serde(rename = "RETL"))]
    Retl,
    #[yaserde(rename = "PRF2")]
    #[cfg_attr(feature = "serde", serde(rename = "PRF2"))]
    Prf2,
    #[yaserde(rename = "NEI1")]
    #[cfg_attr(feature = "serde", serde(rename = "NEI1"))]
    Nei1,
    #[yaserde(rename = "BOT2")]
    #[cfg_attr(feature = "serde", serde(rename = "BOT2"))]
    Bot2,
    __Unknown__(String),
}

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

impl Validate for InvestorType3Code {}



#[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:reda.004.001.07")]

pub enum InvestorType4Code {
    #[yaserde(rename = "BOT3")]
    #[cfg_attr(feature = "serde", serde(rename = "BOT3"))]
    Bot3,
    #[yaserde(rename = "NPRF")]
    #[cfg_attr(feature = "serde", serde(rename = "NPRF"))]
    Nprf,
    #[yaserde(rename = "PRF3")]
    #[cfg_attr(feature = "serde", serde(rename = "PRF3"))]
    Prf3,
    #[yaserde(rename = "PRF4")]
    #[cfg_attr(feature = "serde", serde(rename = "PRF4"))]
    Prf4,
    __Unknown__(String),
}

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

impl Validate for InvestorType4Code {}



#[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:reda.004.001.07")]
pub struct LocalMarketAnnex6 {
    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: Vec<CountryCode>,

    #[yaserde(rename = "LclOrdrDsk")]
    #[cfg_attr(feature = "serde", serde(rename = "LclOrdrDsk"))]
    pub lcl_ordr_dsk: OrderDesk1,

    #[yaserde(rename = "SbcptPrcgChrtcs")]
    #[cfg_attr(feature = "serde", serde(rename = "SbcptPrcgChrtcs"))]
    pub sbcpt_prcg_chrtcs: ProcessingCharacteristics11,

    #[yaserde(rename = "RedPrcgChrtcs")]
    #[cfg_attr(feature = "serde", serde(rename = "RedPrcgChrtcs"))]
    pub red_prcg_chrtcs: ProcessingCharacteristics10,

    #[yaserde(rename = "SwtchPrcgChrtcs")]
    #[cfg_attr(feature = "serde", serde(rename = "SwtchPrcgChrtcs"))]
    pub swtch_prcg_chrtcs: ProcessingCharacteristics9,

    #[yaserde(rename = "CshSttlmDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "CshSttlmDtls"))]
    pub csh_sttlm_dtls: Vec<CashAccount205>,

    #[yaserde(rename = "AddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
    pub addtl_inf: Vec<AdditionalInformation15>,
}

impl Validate for LocalMarketAnnex6 {}


#[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:reda.004.001.07")]
pub struct LossBearing2 {
    #[yaserde(rename = "NoCptlLoss")]
    #[cfg_attr(feature = "serde", serde(rename = "NoCptlLoss"))]
    pub no_cptl_loss: TargetMarket1Code,

    #[yaserde(rename = "LtdCptlLoss")]
    #[cfg_attr(feature = "serde", serde(rename = "LtdCptlLoss"))]
    pub ltd_cptl_loss: TargetMarket1Code,

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

    #[yaserde(rename = "NoCptlGrnt")]
    #[cfg_attr(feature = "serde", serde(rename = "NoCptlGrnt"))]
    pub no_cptl_grnt: TargetMarket1Code,

    #[yaserde(rename = "LossByndCptl")]
    #[cfg_attr(feature = "serde", serde(rename = "LossByndCptl"))]
    pub loss_bynd_cptl: TargetMarket1Code,

    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Vec<OtherTargetMarketLossBearing1>,
}

impl Validate for LossBearing2 {}


#[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:reda.004.001.07")]
pub struct MainFundOrderDeskLocation1 {
    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: CountryCode,

    #[yaserde(rename = "TmZoneOffSet")]
    #[cfg_attr(feature = "serde", serde(rename = "TmZoneOffSet"))]
    pub tm_zone_off_set: Utcoffset1,
}

impl Validate for MainFundOrderDeskLocation1 {}


#[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:reda.004.001.07")]
pub struct MarketPracticeVersion1 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max35Text,

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

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

impl Validate for MarketPracticeVersion1 {}


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

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

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

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

impl Validate for Max34Text {
    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() > 34 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 34 \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 Max4AlphaNumericText (pub String);
crate::simple_type!(Max4AlphaNumericText);

impl Validate for Max4AlphaNumericText {
    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 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:reda.004.001.07")]
pub struct MessageIdentification1 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

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

impl Validate for MessageIdentification1 {}


#[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:reda.004.001.07")]
pub struct NameAndAddress5 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max350Text,

    #[yaserde(rename = "Adr")]
    #[cfg_attr(feature = "serde", serde(rename = "Adr"))]
    pub adr: PostalAddress1,
}

impl Validate for NameAndAddress5 {}
#[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:reda.004.001.07")]
pub struct NotionalOrUnitBased1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<NotionalOrUnitBased1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for NotionalOrUnitBased1Choice {}




#[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:reda.004.001.07")]

pub enum NotionalOrUnitBased1Code {
    #[yaserde(rename = "UNIT")]
    #[cfg_attr(feature = "serde", serde(rename = "UNIT"))]
    Unit,
    #[yaserde(rename = "NOTI")]
    #[cfg_attr(feature = "serde", serde(rename = "NOTI"))]
    Noti,
    __Unknown__(String),
}

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

impl Validate for NotionalOrUnitBased1Code {}



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

impl Validate for Number {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:reda.004.001.07")]
pub struct OrderDesk1 {
    #[yaserde(rename = "OrdrDsk")]
    #[cfg_attr(feature = "serde", serde(rename = "OrdrDsk"))]
    pub ordr_dsk: ContactAttributes5,

    #[yaserde(rename = "ClsrDts")]
    #[cfg_attr(feature = "serde", serde(rename = "ClsrDts"))]
    pub clsr_dts: Vec<Isodate>,

    #[yaserde(rename = "AddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
    pub addtl_inf: Vec<AdditionalInformation15>,
}

impl Validate for OrderDesk1 {}


#[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:reda.004.001.07")]
pub struct OtherDistributionStrategy1 {
    #[yaserde(rename = "DstrbtnStrtgyTp")]
    #[cfg_attr(feature = "serde", serde(rename = "DstrbtnStrtgyTp"))]
    pub dstrbtn_strtgy_tp: Max35Text,

    #[yaserde(rename = "Trgt")]
    #[cfg_attr(feature = "serde", serde(rename = "Trgt"))]
    pub trgt: DistributionStrategy1Choice,

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

impl Validate for OtherDistributionStrategy1 {}


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

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

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

impl Validate for OtherIdentification1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:reda.004.001.07")]
pub struct OtherInvestmentNeed1 {
    #[yaserde(rename = "ClntObjctvsAndNeedsTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ClntObjctvsAndNeedsTp"))]
    pub clnt_objctvs_and_needs_tp: Max35Text,

    #[yaserde(rename = "Trgt")]
    #[cfg_attr(feature = "serde", serde(rename = "Trgt"))]
    pub trgt: TargetMarket1Choice,

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

impl Validate for OtherInvestmentNeed1 {}


#[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:reda.004.001.07")]

pub enum OtherReviewRelatedToValueAndOrChargesUKType1Code {
    #[yaserde(rename = "REVA")]
    #[cfg_attr(feature = "serde", serde(rename = "REVA"))]
    Reva,
    #[yaserde(rename = "REVO")]
    #[cfg_attr(feature = "serde", serde(rename = "REVO"))]
    Revo,
    __Unknown__(String),
}

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

impl Validate for OtherReviewRelatedToValueAndOrChargesUKType1Code {}



#[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:reda.004.001.07")]
pub struct OtherTargetMarket1 {
    #[yaserde(rename = "TrgtMktTp")]
    #[cfg_attr(feature = "serde", serde(rename = "TrgtMktTp"))]
    pub trgt_mkt_tp: Max350Text,

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

impl Validate for OtherTargetMarket1 {}


#[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:reda.004.001.07")]
pub struct OtherTargetMarketInvestor1 {
    #[yaserde(rename = "InvstrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "InvstrTp"))]
    pub invstr_tp: Max35Text,

    #[yaserde(rename = "Trgt")]
    #[cfg_attr(feature = "serde", serde(rename = "Trgt"))]
    pub trgt: TargetMarket3Choice,

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

impl Validate for OtherTargetMarketInvestor1 {}


#[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:reda.004.001.07")]
pub struct OtherTargetMarketInvestorKnowledge1 {
    #[yaserde(rename = "InvstrKnwldgTp")]
    #[cfg_attr(feature = "serde", serde(rename = "InvstrKnwldgTp"))]
    pub invstr_knwldg_tp: Max35Text,

    #[yaserde(rename = "Trgt")]
    #[cfg_attr(feature = "serde", serde(rename = "Trgt"))]
    pub trgt: TargetMarket1Choice,

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

impl Validate for OtherTargetMarketInvestorKnowledge1 {}


#[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:reda.004.001.07")]
pub struct OtherTargetMarketLossBearing1 {
    #[yaserde(rename = "AbltyToBearLossesTp")]
    #[cfg_attr(feature = "serde", serde(rename = "AbltyToBearLossesTp"))]
    pub ablty_to_bear_losses_tp: Max35Text,

    #[yaserde(rename = "Trgt")]
    #[cfg_attr(feature = "serde", serde(rename = "Trgt"))]
    pub trgt: TargetMarket1Choice,

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

impl Validate for OtherTargetMarketLossBearing1 {}


#[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:reda.004.001.07")]
pub struct OtherTargetMarketRiskTolerance1 {
    #[yaserde(rename = "RskTlrnceTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RskTlrnceTp"))]
    pub rsk_tlrnce_tp: Max35Text,

    #[yaserde(rename = "Trgt")]
    #[cfg_attr(feature = "serde", serde(rename = "Trgt"))]
    pub trgt: TargetMarket1Choice,

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

impl Validate for OtherTargetMarketRiskTolerance1 {}


#[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:reda.004.001.07")]

pub enum OutcomeOfCOLLAssessmentOfValueUKType1Code {
    #[yaserde(rename = "COL1")]
    #[cfg_attr(feature = "serde", serde(rename = "COL1"))]
    Col1,
    #[yaserde(rename = "COL2")]
    #[cfg_attr(feature = "serde", serde(rename = "COL2"))]
    Col2,
    __Unknown__(String),
}

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

impl Validate for OutcomeOfCOLLAssessmentOfValueUKType1Code {}



#[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:reda.004.001.07")]

pub enum OutcomeOfPRINValueAssessmentOrReviewUKType1Code {
    #[yaserde(rename = "PRI2")]
    #[cfg_attr(feature = "serde", serde(rename = "PRI2"))]
    Pri2,
    #[yaserde(rename = "PRI1")]
    #[cfg_attr(feature = "serde", serde(rename = "PRI1"))]
    Pri1,
    __Unknown__(String),
}

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

impl Validate for OutcomeOfPRINValueAssessmentOrReviewUKType1Code {}
#[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:reda.004.001.07")]
pub struct PartyIdentification125Choice {
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_b_i_c: Option<AnyBICDec2014Identifier>,
    #[yaserde(rename = "PrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
    pub prtry_id: Option<GenericIdentification1>,
    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: Option<NameAndAddress5>,
}

impl Validate for PartyIdentification125Choice {}




#[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:reda.004.001.07")]
pub struct PartyIdentification139 {
    #[yaserde(rename = "Pty")]
    #[cfg_attr(feature = "serde", serde(rename = "Pty"))]
    pub pty: PartyIdentification125Choice,

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

impl Validate for PartyIdentification139 {}


#[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:reda.004.001.07")]
pub struct PaymentInstrument16 {
    #[yaserde(rename = "OrdrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "OrdrTp"))]
    pub ordr_tp: FundOrderType5Choice,

    #[yaserde(rename = "InstrmTp")]
    #[cfg_attr(feature = "serde", serde(rename = "InstrmTp"))]
    pub instrm_tp: FundPaymentType1Choice,

    #[yaserde(rename = "AddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
    pub addtl_inf: Vec<AdditionalInformation15>,
}

impl Validate for PaymentInstrument16 {}


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

impl Validate for PercentageRate {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:reda.004.001.07")]
pub struct Period15 {
    #[yaserde(rename = "StartDt")]
    #[cfg_attr(feature = "serde", serde(rename = "StartDt"))]
    pub start_dt: Isodate,

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

impl Validate for Period15 {}


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

impl Validate for PhoneNumber {}
#[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:reda.004.001.07")]
pub struct PostalAddress1 {
    #[yaserde(rename = "AdrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "AdrTp"))]
    pub adr_tp: AddressType2Code,

    #[yaserde(rename = "AdrLine")]
    #[cfg_attr(feature = "serde", serde(rename = "AdrLine"))]
    pub adr_line: Vec<Max70Text>,

    #[yaserde(rename = "StrtNm")]
    #[cfg_attr(feature = "serde", serde(rename = "StrtNm"))]
    pub strt_nm: Max70Text,

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

    #[yaserde(rename = "PstCd")]
    #[cfg_attr(feature = "serde", serde(rename = "PstCd"))]
    pub pst_cd: 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 PostalAddress1 {}


#[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:reda.004.001.07")]

pub enum PriceMethod1Code {
    #[yaserde(rename = "FORW")]
    #[cfg_attr(feature = "serde", serde(rename = "FORW"))]
    Forw,
    #[yaserde(rename = "HIST")]
    #[cfg_attr(feature = "serde", serde(rename = "HIST"))]
    Hist,
    __Unknown__(String),
}

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

impl Validate for PriceMethod1Code {}



#[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:reda.004.001.07")]
pub struct ProcessingCharacteristics10 {
    #[yaserde(rename = "DealgCcyAccptd")]
    #[cfg_attr(feature = "serde", serde(rename = "DealgCcyAccptd"))]
    pub dealg_ccy_accptd: Vec<ActiveCurrencyCode>,

    #[yaserde(rename = "RedAuthstn")]
    #[cfg_attr(feature = "serde", serde(rename = "RedAuthstn"))]
    pub red_authstn: Forms1,

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

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

    #[yaserde(rename = "Rndg")]
    #[cfg_attr(feature = "serde", serde(rename = "Rndg"))]
    pub rndg: RoundingDirection2Code,

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

    #[yaserde(rename = "MainFndOrdrDskLctn")]
    #[cfg_attr(feature = "serde", serde(rename = "MainFndOrdrDskLctn"))]
    pub main_fnd_ordr_dsk_lctn: MainFundOrderDeskLocation1,

    #[yaserde(rename = "DealgFrqcy")]
    #[cfg_attr(feature = "serde", serde(rename = "DealgFrqcy"))]
    pub dealg_frqcy: EventFrequency5Code,

    #[yaserde(rename = "DealgFrqcyDesc")]
    #[cfg_attr(feature = "serde", serde(rename = "DealgFrqcyDesc"))]
    pub dealg_frqcy_desc: Max350Text,

    #[yaserde(rename = "DealgCutOffTm")]
    #[cfg_attr(feature = "serde", serde(rename = "DealgCutOffTm"))]
    pub dealg_cut_off_tm: Isotime,

    #[yaserde(rename = "DealgCutOffTmFrame")]
    #[cfg_attr(feature = "serde", serde(rename = "DealgCutOffTmFrame"))]
    pub dealg_cut_off_tm_frame: TimeFrame9,

    #[yaserde(rename = "DealConfTm")]
    #[cfg_attr(feature = "serde", serde(rename = "DealConfTm"))]
    pub deal_conf_tm: Isotime,

    #[yaserde(rename = "DealConfTmFrame")]
    #[cfg_attr(feature = "serde", serde(rename = "DealConfTmFrame"))]
    pub deal_conf_tm_frame: TimeFrame8,

    #[yaserde(rename = "LtdPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "LtdPrd"))]
    pub ltd_prd: Max350Text,

    #[yaserde(rename = "SttlmCycl")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmCycl"))]
    pub sttlm_cycl: TimeFrame8Choice,

    #[yaserde(rename = "AddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
    pub addtl_inf: Vec<AdditionalInformation15>,
}

impl Validate for ProcessingCharacteristics10 {}


#[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:reda.004.001.07")]
pub struct ProcessingCharacteristics11 {
    #[yaserde(rename = "DealgCcyAccptd")]
    #[cfg_attr(feature = "serde", serde(rename = "DealgCcyAccptd"))]
    pub dealg_ccy_accptd: Vec<ActiveCurrencyCode>,

    #[yaserde(rename = "InitlInvstmtAppl")]
    #[cfg_attr(feature = "serde", serde(rename = "InitlInvstmtAppl"))]
    pub initl_invstmt_appl: Forms1,

    #[yaserde(rename = "SbsqntInvstmtAppl")]
    #[cfg_attr(feature = "serde", serde(rename = "SbsqntInvstmtAppl"))]
    pub sbsqnt_invstmt_appl: Forms1,

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

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

    #[yaserde(rename = "Rndg")]
    #[cfg_attr(feature = "serde", serde(rename = "Rndg"))]
    pub rndg: RoundingDirection2Code,

    #[yaserde(rename = "MainFndOrdrDskLctn")]
    #[cfg_attr(feature = "serde", serde(rename = "MainFndOrdrDskLctn"))]
    pub main_fnd_ordr_dsk_lctn: MainFundOrderDeskLocation1,

    #[yaserde(rename = "DealgFrqcy")]
    #[cfg_attr(feature = "serde", serde(rename = "DealgFrqcy"))]
    pub dealg_frqcy: EventFrequency5Code,

    #[yaserde(rename = "DealgFrqcyDesc")]
    #[cfg_attr(feature = "serde", serde(rename = "DealgFrqcyDesc"))]
    pub dealg_frqcy_desc: Max350Text,

    #[yaserde(rename = "DealgCutOffTm")]
    #[cfg_attr(feature = "serde", serde(rename = "DealgCutOffTm"))]
    pub dealg_cut_off_tm: Isotime,

    #[yaserde(rename = "DealgCutOffTmFrame")]
    #[cfg_attr(feature = "serde", serde(rename = "DealgCutOffTmFrame"))]
    pub dealg_cut_off_tm_frame: TimeFrame9,

    #[yaserde(rename = "DealConfTm")]
    #[cfg_attr(feature = "serde", serde(rename = "DealConfTm"))]
    pub deal_conf_tm: Isotime,

    #[yaserde(rename = "DealConfTmFrame")]
    #[cfg_attr(feature = "serde", serde(rename = "DealConfTmFrame"))]
    pub deal_conf_tm_frame: TimeFrame11,

    #[yaserde(rename = "LtdPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "LtdPrd"))]
    pub ltd_prd: Max350Text,

    #[yaserde(rename = "SttlmCycl")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmCycl"))]
    pub sttlm_cycl: TimeFrame7Choice,

    #[yaserde(rename = "AddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
    pub addtl_inf: Vec<AdditionalInformation15>,
}

impl Validate for ProcessingCharacteristics11 {}


#[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:reda.004.001.07")]
pub struct ProcessingCharacteristics12 {
    #[yaserde(rename = "DealgCcyAccptd")]
    #[cfg_attr(feature = "serde", serde(rename = "DealgCcyAccptd"))]
    pub dealg_ccy_accptd: Vec<ActiveCurrencyCode>,

    #[yaserde(rename = "RedAuthstn")]
    #[cfg_attr(feature = "serde", serde(rename = "RedAuthstn"))]
    pub red_authstn: Forms1,

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

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

    #[yaserde(rename = "Rndg")]
    #[cfg_attr(feature = "serde", serde(rename = "Rndg"))]
    pub rndg: RoundingDirection2Code,

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

    #[yaserde(rename = "MainFndOrdrDskLctn")]
    #[cfg_attr(feature = "serde", serde(rename = "MainFndOrdrDskLctn"))]
    pub main_fnd_ordr_dsk_lctn: MainFundOrderDeskLocation1,

    #[yaserde(rename = "DealgFrqcy")]
    #[cfg_attr(feature = "serde", serde(rename = "DealgFrqcy"))]
    pub dealg_frqcy: EventFrequency5Code,

    #[yaserde(rename = "DealgFrqcyDesc")]
    #[cfg_attr(feature = "serde", serde(rename = "DealgFrqcyDesc"))]
    pub dealg_frqcy_desc: Max350Text,

    #[yaserde(rename = "DealgCutOffTm")]
    #[cfg_attr(feature = "serde", serde(rename = "DealgCutOffTm"))]
    pub dealg_cut_off_tm: Isotime,

    #[yaserde(rename = "DealgCutOffTmFrame")]
    #[cfg_attr(feature = "serde", serde(rename = "DealgCutOffTmFrame"))]
    pub dealg_cut_off_tm_frame: TimeFrame9,

    #[yaserde(rename = "DealConfTm")]
    #[cfg_attr(feature = "serde", serde(rename = "DealConfTm"))]
    pub deal_conf_tm: Isotime,

    #[yaserde(rename = "DealConfTmFrame")]
    #[cfg_attr(feature = "serde", serde(rename = "DealConfTmFrame"))]
    pub deal_conf_tm_frame: TimeFrame10,

    #[yaserde(rename = "LtdPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "LtdPrd"))]
    pub ltd_prd: Max350Text,

    #[yaserde(rename = "SttlmCycl")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmCycl"))]
    pub sttlm_cycl: TimeFrame8Choice,

    #[yaserde(rename = "AddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
    pub addtl_inf: Vec<AdditionalInformation15>,
}

impl Validate for ProcessingCharacteristics12 {}


#[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:reda.004.001.07")]
pub struct ProcessingCharacteristics9 {
    #[yaserde(rename = "DealgCcyAccptd")]
    #[cfg_attr(feature = "serde", serde(rename = "DealgCcyAccptd"))]
    pub dealg_ccy_accptd: Vec<ActiveCurrencyCode>,

    #[yaserde(rename = "SwtchAuthstn")]
    #[cfg_attr(feature = "serde", serde(rename = "SwtchAuthstn"))]
    pub swtch_authstn: Forms1,

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

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

    #[yaserde(rename = "Rndg")]
    #[cfg_attr(feature = "serde", serde(rename = "Rndg"))]
    pub rndg: RoundingDirection2Code,

    #[yaserde(rename = "MainFndOrdrDskLctn")]
    #[cfg_attr(feature = "serde", serde(rename = "MainFndOrdrDskLctn"))]
    pub main_fnd_ordr_dsk_lctn: MainFundOrderDeskLocation1,

    #[yaserde(rename = "DealgFrqcy")]
    #[cfg_attr(feature = "serde", serde(rename = "DealgFrqcy"))]
    pub dealg_frqcy: EventFrequency5Code,

    #[yaserde(rename = "DealgFrqcyDesc")]
    #[cfg_attr(feature = "serde", serde(rename = "DealgFrqcyDesc"))]
    pub dealg_frqcy_desc: Max350Text,

    #[yaserde(rename = "DealgCutOffTm")]
    #[cfg_attr(feature = "serde", serde(rename = "DealgCutOffTm"))]
    pub dealg_cut_off_tm: Isotime,

    #[yaserde(rename = "DealgCutOffTmFrame")]
    #[cfg_attr(feature = "serde", serde(rename = "DealgCutOffTmFrame"))]
    pub dealg_cut_off_tm_frame: TimeFrame9,

    #[yaserde(rename = "DealConfTm")]
    #[cfg_attr(feature = "serde", serde(rename = "DealConfTm"))]
    pub deal_conf_tm: Isotime,

    #[yaserde(rename = "DealConfTmFrame")]
    #[cfg_attr(feature = "serde", serde(rename = "DealConfTmFrame"))]
    pub deal_conf_tm_frame: TimeFrame8,

    #[yaserde(rename = "LtdPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "LtdPrd"))]
    pub ltd_prd: Max350Text,

    #[yaserde(rename = "SttlmCycl")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmCycl"))]
    pub sttlm_cycl: TimeFrame8Choice,

    #[yaserde(rename = "AddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
    pub addtl_inf: Vec<AdditionalInformation15>,
}

impl Validate for ProcessingCharacteristics9 {}
#[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:reda.004.001.07")]
pub struct ProductStructure1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ProductStructure1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for ProductStructure1Choice {}




#[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:reda.004.001.07")]

pub enum ProductStructure1Code {
    #[yaserde(rename = "BOND")]
    #[cfg_attr(feature = "serde", serde(rename = "BOND"))]
    Bond,
    #[yaserde(rename = "NUMM")]
    #[cfg_attr(feature = "serde", serde(rename = "NUMM"))]
    Numm,
    #[yaserde(rename = "UCMM")]
    #[cfg_attr(feature = "serde", serde(rename = "UCMM"))]
    Ucmm,
    #[yaserde(rename = "EXTC")]
    #[cfg_attr(feature = "serde", serde(rename = "EXTC"))]
    Extc,
    #[yaserde(rename = "UCIT")]
    #[cfg_attr(feature = "serde", serde(rename = "UCIT"))]
    Ucit,
    #[yaserde(rename = "SSEC")]
    #[cfg_attr(feature = "serde", serde(rename = "SSEC"))]
    Ssec,
    #[yaserde(rename = "SFUN")]
    #[cfg_attr(feature = "serde", serde(rename = "SFUN"))]
    Sfun,
    #[yaserde(rename = "NUCI")]
    #[cfg_attr(feature = "serde", serde(rename = "NUCI"))]
    Nuci,
    __Unknown__(String),
}

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

impl Validate for ProductStructure1Code {}
#[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:reda.004.001.07")]
pub struct QuotationType1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<QuotationType1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for QuotationType1Choice {}




#[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:reda.004.001.07")]

pub enum QuotationType1Code {
    #[yaserde(rename = "ACTU")]
    #[cfg_attr(feature = "serde", serde(rename = "ACTU"))]
    Actu,
    #[yaserde(rename = "PRCT")]
    #[cfg_attr(feature = "serde", serde(rename = "PRCT"))]
    Prct,
    __Unknown__(String),
}

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

impl Validate for QuotationType1Code {}



#[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:reda.004.001.07")]

pub enum ReferToFundOrderDesk1Code {
    #[yaserde(rename = "RFOD")]
    #[cfg_attr(feature = "serde", serde(rename = "RFOD"))]
    Rfod,
    __Unknown__(String),
}

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

impl Validate for ReferToFundOrderDesk1Code {}



#[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:reda.004.001.07")]

pub enum RiskLevel1Code {
    #[yaserde(rename = "HIGH")]
    #[cfg_attr(feature = "serde", serde(rename = "HIGH"))]
    High,
    #[yaserde(rename = "LOWW")]
    #[cfg_attr(feature = "serde", serde(rename = "LOWW"))]
    Loww,
    #[yaserde(rename = "MEDM")]
    #[cfg_attr(feature = "serde", serde(rename = "MEDM"))]
    Medm,
    __Unknown__(String),
}

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

impl Validate for RiskLevel1Code {}



#[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:reda.004.001.07")]
pub struct RiskTolerance1 {
    #[yaserde(rename = "RskTlrncePRIIPSMthdlgy")]
    #[cfg_attr(feature = "serde", serde(rename = "RskTlrncePRIIPSMthdlgy"))]
    pub rsk_tlrnce_priips_mthdlgy: Max1Number,

    #[yaserde(rename = "RskTlrnceUCITSMthdlgy")]
    #[cfg_attr(feature = "serde", serde(rename = "RskTlrnceUCITSMthdlgy"))]
    pub rsk_tlrnce_ucits_mthdlgy: Max1Number,

    #[yaserde(rename = "RskTlrnceIntl")]
    #[cfg_attr(feature = "serde", serde(rename = "RskTlrnceIntl"))]
    pub rsk_tlrnce_intl: RiskLevel1Code,

    #[yaserde(rename = "RskTlrnceForNonPRIIPSAndNonUCITSES")]
    #[cfg_attr(feature = "serde", serde(rename = "RskTlrnceForNonPRIIPSAndNonUCITSES"))]
    pub rsk_tlrnce_for_non_priips_and_non_ucitses: Max1Number,

    #[yaserde(rename = "NotForInvstrsWthTheLwstRskTlrnceDE")]
    #[cfg_attr(feature = "serde", serde(rename = "NotForInvstrsWthTheLwstRskTlrnceDE"))]
    pub not_for_invstrs_wth_the_lwst_rsk_tlrnce_de: TargetMarket2Code,

    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Vec<OtherTargetMarketRiskTolerance1>,
}

impl Validate for RiskTolerance1 {}


#[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:reda.004.001.07")]

pub enum RoundingDirection2Code {
    #[yaserde(rename = "RDUP")]
    #[cfg_attr(feature = "serde", serde(rename = "RDUP"))]
    Rdup,
    #[yaserde(rename = "RDWN")]
    #[cfg_attr(feature = "serde", serde(rename = "RDWN"))]
    Rdwn,
    __Unknown__(String),
}

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

impl Validate for RoundingDirection2Code {}
#[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:reda.004.001.07")]
pub struct SecurityClassificationType2Choice {
    #[yaserde(rename = "CFI")]
    #[cfg_attr(feature = "serde", serde(rename = "CFI"))]
    pub cfi: Option<Cfioct2015Identifier>,
    #[yaserde(rename = "AltrnClssfctn")]
    #[cfg_attr(feature = "serde", serde(rename = "AltrnClssfctn"))]
    pub altrn_clssfctn: Option<GenericIdentification3>,
}

impl Validate for SecurityClassificationType2Choice {}




#[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:reda.004.001.07")]
pub struct SecurityIdentification40 {
    #[yaserde(rename = "OthrId")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrId"))]
    pub othr_id: Vec<OtherIdentification1>,

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

    #[yaserde(rename = "ISIN")]
    #[cfg_attr(feature = "serde", serde(rename = "ISIN"))]
    pub isin: Isinoct2015Identifier,
}

impl Validate for SecurityIdentification40 {}


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

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

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

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

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

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

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

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

    #[yaserde(rename = "CtryOfDmcl")]
    #[cfg_attr(feature = "serde", serde(rename = "CtryOfDmcl"))]
    pub ctry_of_dmcl: CountryCode,

    #[yaserde(rename = "RegdDstrbtnCtry")]
    #[cfg_attr(feature = "serde", serde(rename = "RegdDstrbtnCtry"))]
    pub regd_dstrbtn_ctry: Vec<CountryCode>,

    #[yaserde(rename = "PdctTp")]
    #[cfg_attr(feature = "serde", serde(rename = "PdctTp"))]
    pub pdct_tp: ProductStructure1Choice,

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

    #[yaserde(rename = "IssrPdctGovncPrc")]
    #[cfg_attr(feature = "serde", serde(rename = "IssrPdctGovncPrc"))]
    pub issr_pdct_govnc_prc: GovernanceProcess1Choice,

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

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

    #[yaserde(rename = "NtnlOrUnitBased")]
    #[cfg_attr(feature = "serde", serde(rename = "NtnlOrUnitBased"))]
    pub ntnl_or_unit_based: NotionalOrUnitBased1Choice,

    #[yaserde(rename = "QtnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "QtnTp"))]
    pub qtn_tp: QuotationType1Choice,

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

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

    #[yaserde(rename = "ExPstCostClctnBsis")]
    #[cfg_attr(feature = "serde", serde(rename = "ExPstCostClctnBsis"))]
    pub ex_pst_cost_clctn_bsis: ExPostCostCalculationBasis1Choice,

    #[yaserde(rename = "AddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
    pub addtl_inf: Vec<AdditionalInformation15>,
}

impl Validate for SecurityIdentification47 {}


#[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:reda.004.001.07")]

pub enum SignatureType1Code {
    #[yaserde(rename = "ORIG")]
    #[cfg_attr(feature = "serde", serde(rename = "ORIG"))]
    Orig,
    #[yaserde(rename = "DIGI")]
    #[cfg_attr(feature = "serde", serde(rename = "DIGI"))]
    Digi,
    #[yaserde(rename = "ELEC")]
    #[cfg_attr(feature = "serde", serde(rename = "ELEC"))]
    Elec,
    #[yaserde(rename = "NONE")]
    #[cfg_attr(feature = "serde", serde(rename = "NONE"))]
    None,
    __Unknown__(String),
}

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

impl Validate for SignatureType1Code {}



#[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:reda.004.001.07")]

pub enum SustainabilityPreferences2Code {
    #[yaserde(rename = "NEUT")]
    #[cfg_attr(feature = "serde", serde(rename = "NEUT"))]
    Neut,
    #[yaserde(rename = "YSCO")]
    #[cfg_attr(feature = "serde", serde(rename = "YSCO"))]
    Ysco,
    __Unknown__(String),
}

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

impl Validate for SustainabilityPreferences2Code {}
#[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:reda.004.001.07")]
pub struct TargetMarket1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<TargetMarket1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for TargetMarket1Choice {}




#[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:reda.004.001.07")]

pub enum TargetMarket1Code {
    #[yaserde(rename = "YSCO")]
    #[cfg_attr(feature = "serde", serde(rename = "YSCO"))]
    Ysco,
    #[yaserde(rename = "NEUT")]
    #[cfg_attr(feature = "serde", serde(rename = "NEUT"))]
    Neut,
    #[yaserde(rename = "NSCO")]
    #[cfg_attr(feature = "serde", serde(rename = "NSCO"))]
    Nsco,
    __Unknown__(String),
}

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

impl Validate for TargetMarket1Code {}



#[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:reda.004.001.07")]

pub enum TargetMarket2Code {
    #[yaserde(rename = "NEUT")]
    #[cfg_attr(feature = "serde", serde(rename = "NEUT"))]
    Neut,
    #[yaserde(rename = "YSCO")]
    #[cfg_attr(feature = "serde", serde(rename = "YSCO"))]
    Ysco,
    __Unknown__(String),
}

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

impl Validate for TargetMarket2Code {}
#[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:reda.004.001.07")]
pub struct TargetMarket3Choice {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: Option<InvestorType2Code>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<TargetMarket1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for TargetMarket3Choice {}




#[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:reda.004.001.07")]

pub enum TargetMarket3Code {
    #[yaserde(rename = "YSCO")]
    #[cfg_attr(feature = "serde", serde(rename = "YSCO"))]
    Ysco,
    #[yaserde(rename = "NSCO")]
    #[cfg_attr(feature = "serde", serde(rename = "NSCO"))]
    Nsco,
    __Unknown__(String),
}

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

impl Validate for TargetMarket3Code {}



#[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:reda.004.001.07")]
pub struct TargetMarket4 {
    #[yaserde(rename = "RefDt")]
    #[cfg_attr(feature = "serde", serde(rename = "RefDt"))]
    pub ref_dt: Isodate,

    #[yaserde(rename = "InvstrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "InvstrTp"))]
    pub invstr_tp: InvestorType2,

    #[yaserde(rename = "KnwldgAndOrExprnc")]
    #[cfg_attr(feature = "serde", serde(rename = "KnwldgAndOrExprnc"))]
    pub knwldg_and_or_exprnc: InvestorKnowledge1,

    #[yaserde(rename = "AbltyToBearLosses")]
    #[cfg_attr(feature = "serde", serde(rename = "AbltyToBearLosses"))]
    pub ablty_to_bear_losses: LossBearing2,

    #[yaserde(rename = "RskTlrnce")]
    #[cfg_attr(feature = "serde", serde(rename = "RskTlrnce"))]
    pub rsk_tlrnce: RiskTolerance1,

    #[yaserde(rename = "ClntObjctvsAndNeeds")]
    #[cfg_attr(feature = "serde", serde(rename = "ClntObjctvsAndNeeds"))]
    pub clnt_objctvs_and_needs: InvestorRequirements4,

    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Vec<OtherTargetMarket1>,
}

impl Validate for TargetMarket4 {}
#[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:reda.004.001.07")]
pub struct TargetMarket5Choice {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: Option<InvestorType4Code>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<TargetMarket1Code>,
}

impl Validate for TargetMarket5Choice {}




#[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:reda.004.001.07")]
pub struct TimeFrame10 {
    #[yaserde(rename = "OthrTmFrameDesc")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrTmFrameDesc"))]
    pub othr_tm_frame_desc: Max350Text,

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

    #[yaserde(rename = "NonWorkgDayAdjstmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "NonWorkgDayAdjstmnt"))]
    pub non_workg_day_adjstmnt: BusinessDayConvention1Code,

    #[yaserde(rename = "RefrToOrdrDsk")]
    #[cfg_attr(feature = "serde", serde(rename = "RefrToOrdrDsk"))]
    pub refr_to_ordr_dsk: ReferToFundOrderDesk1Code,
}

impl Validate for TimeFrame10 {}


#[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:reda.004.001.07")]
pub struct TimeFrame11 {
    #[yaserde(rename = "OthrTmFrameDesc")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrTmFrameDesc"))]
    pub othr_tm_frame_desc: Max350Text,

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

    #[yaserde(rename = "NonWorkgDayAdjstmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "NonWorkgDayAdjstmnt"))]
    pub non_workg_day_adjstmnt: BusinessDayConvention1Code,

    #[yaserde(rename = "RefrToOrdrDsk")]
    #[cfg_attr(feature = "serde", serde(rename = "RefrToOrdrDsk"))]
    pub refr_to_ordr_dsk: ReferToFundOrderDesk1Code,
}

impl Validate for TimeFrame11 {}


#[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:reda.004.001.07")]

pub enum TimeFrame2Code {
    #[yaserde(rename = "HOLD")]
    #[cfg_attr(feature = "serde", serde(rename = "HOLD"))]
    Hold,
    #[yaserde(rename = "LONG")]
    #[cfg_attr(feature = "serde", serde(rename = "LONG"))]
    Long,
    #[yaserde(rename = "MEDM")]
    #[cfg_attr(feature = "serde", serde(rename = "MEDM"))]
    Medm,
    #[yaserde(rename = "SHOR")]
    #[cfg_attr(feature = "serde", serde(rename = "SHOR"))]
    Shor,
    #[yaserde(rename = "VSHT")]
    #[cfg_attr(feature = "serde", serde(rename = "VSHT"))]
    Vsht,
    __Unknown__(String),
}

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

impl Validate for TimeFrame2Code {}
#[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:reda.004.001.07")]
pub struct TimeFrame7Choice {
    #[yaserde(rename = "TPlus")]
    #[cfg_attr(feature = "serde", serde(rename = "TPlus"))]
    pub tplus: Option<Number>,
    #[yaserde(rename = "Prepmt")]
    #[cfg_attr(feature = "serde", serde(rename = "Prepmt"))]
    pub prepmt: Option<YesNoIndicator>,
}

impl Validate for TimeFrame7Choice {}




#[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:reda.004.001.07")]
pub struct TimeFrame8 {
    #[yaserde(rename = "OthrTmFrameDesc")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrTmFrameDesc"))]
    pub othr_tm_frame_desc: Max350Text,

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

    #[yaserde(rename = "NonWorkgDayAdjstmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "NonWorkgDayAdjstmnt"))]
    pub non_workg_day_adjstmnt: BusinessDayConvention1Code,

    #[yaserde(rename = "RefrToOrdrDsk")]
    #[cfg_attr(feature = "serde", serde(rename = "RefrToOrdrDsk"))]
    pub refr_to_ordr_dsk: ReferToFundOrderDesk1Code,
}

impl Validate for TimeFrame8 {}
#[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:reda.004.001.07")]
pub struct TimeFrame8Choice {
    #[yaserde(rename = "TPlus")]
    #[cfg_attr(feature = "serde", serde(rename = "TPlus"))]
    pub tplus: Option<Number>,
    #[yaserde(rename = "RPlus")]
    #[cfg_attr(feature = "serde", serde(rename = "RPlus"))]
    pub rplus: Option<Number>,
}

impl Validate for TimeFrame8Choice {}




#[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:reda.004.001.07")]
pub struct TimeFrame9 {
    #[yaserde(rename = "OthrTmFrameDesc")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrTmFrameDesc"))]
    pub othr_tm_frame_desc: Max350Text,

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

    #[yaserde(rename = "NonWorkgDayAdjstmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "NonWorkgDayAdjstmnt"))]
    pub non_workg_day_adjstmnt: BusinessDayConvention1Code,

    #[yaserde(rename = "RefrToOrdrDsk")]
    #[cfg_attr(feature = "serde", serde(rename = "RefrToOrdrDsk"))]
    pub refr_to_ordr_dsk: ReferToFundOrderDesk1Code,
}

impl Validate for TimeFrame9 {}
#[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:reda.004.001.07")]
pub struct TimeFrame9Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<TimeFrame2Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for TimeFrame9Choice {}
#[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:reda.004.001.07")]
pub struct TimeHorizon2Choice {
    #[yaserde(rename = "NbOfYrs")]
    #[cfg_attr(feature = "serde", serde(rename = "NbOfYrs"))]
    pub nb_of_yrs: Option<DecimalNumber>,
    #[yaserde(rename = "TmFrame")]
    #[cfg_attr(feature = "serde", serde(rename = "TmFrame"))]
    pub tm_frame: Option<TimeFrame9Choice>,
}

impl Validate for TimeHorizon2Choice {}




#[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:reda.004.001.07")]
pub struct Utcoffset1 {
    #[yaserde(rename = "Sgn")]
    #[cfg_attr(feature = "serde", serde(rename = "Sgn"))]
    pub sgn: PlusOrMinusIndicator,

    #[yaserde(rename = "NbOfHrs")]
    #[cfg_attr(feature = "serde", serde(rename = "NbOfHrs"))]
    pub nb_of_hrs: Isotime,
}

impl Validate for Utcoffset1 {}
#[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:reda.004.001.07")]
pub struct UnitsOrAmount1Choice {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<ActiveCurrencyAndAmount>,
    #[yaserde(rename = "Unit")]
    #[cfg_attr(feature = "serde", serde(rename = "Unit"))]
    pub unit: Option<DecimalNumber>,
}

impl Validate for UnitsOrAmount1Choice {}




#[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:reda.004.001.07")]
pub struct ValuationDealingProcessingCharacteristics3 {
    #[yaserde(rename = "ValtnFrqcy")]
    #[cfg_attr(feature = "serde", serde(rename = "ValtnFrqcy"))]
    pub valtn_frqcy: EventFrequency5Code,

    #[yaserde(rename = "ValtnFrqcyDesc")]
    #[cfg_attr(feature = "serde", serde(rename = "ValtnFrqcyDesc"))]
    pub valtn_frqcy_desc: Max350Text,

    #[yaserde(rename = "ValtnTm")]
    #[cfg_attr(feature = "serde", serde(rename = "ValtnTm"))]
    pub valtn_tm: Isotime,

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

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

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

    #[yaserde(rename = "PricMtd")]
    #[cfg_attr(feature = "serde", serde(rename = "PricMtd"))]
    pub pric_mtd: PriceMethod1Code,

    #[yaserde(rename = "PricCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "PricCcy"))]
    pub pric_ccy: Vec<ActiveCurrencyCode>,

    #[yaserde(rename = "AddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
    pub addtl_inf: Vec<AdditionalInformation15>,
}

impl Validate for ValuationDealingProcessingCharacteristics3 {}


#[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:reda.004.001.07")]
pub struct ValueForMoney1 {
    #[yaserde(rename = "EMTDataRptgVFMUK")]
    #[cfg_attr(feature = "serde", serde(rename = "EMTDataRptgVFMUK"))]
    pub emt_data_rptg_vfmuk: EmtdataReportingVFMUKType1Code,

    #[yaserde(rename = "AssmntOfValReqrdUdrCOLLUK")]
    #[cfg_attr(feature = "serde", serde(rename = "AssmntOfValReqrdUdrCOLLUK"))]
    pub assmnt_of_val_reqrd_udr_colluk: AssessmentOfValueRequiredUnderCOLLUKType1Code,

    #[yaserde(rename = "OutcmOfCOLLAssmntOfValUK")]
    #[cfg_attr(feature = "serde", serde(rename = "OutcmOfCOLLAssmntOfValUK"))]
    pub outcm_of_coll_assmnt_of_val_uk: OutcomeOfCOLLAssessmentOfValueUKType1Code,

    #[yaserde(rename = "OutcmOfPRINValAssmntOrRvwUK")]
    #[cfg_attr(feature = "serde", serde(rename = "OutcmOfPRINValAssmntOrRvwUK"))]
    pub outcm_of_prin_val_assmnt_or_rvw_uk: OutcomeOfPRINValueAssessmentOrReviewUKType1Code,

    #[yaserde(rename = "OthrRvwRltdToValAndOrChrgsUK")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrRvwRltdToValAndOrChrgsUK"))]
    pub othr_rvw_rltd_to_val_and_or_chrgs_uk: OtherReviewRelatedToValueAndOrChargesUKType1Code,

    #[yaserde(rename = "FrthrInfUK")]
    #[cfg_attr(feature = "serde", serde(rename = "FrthrInfUK"))]
    pub frthr_inf_uk: Max350Text,

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

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

impl Validate for ValueForMoney1 {}


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

impl Validate for YesNoIndicator {}

impl crate::MxMessage for Document {
    const BUSINESS_AREA: crate::BusinessArea = crate::BusinessArea::reda;
    const FUNCTIONALITY: &'static str = "004";
    const VARIANT: &'static str = "001";
    const VERSION: &'static str = "07";
    const MESSAGE_NAME: &'static str = "reda.004.001.07";
    const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:reda.004.001.07";
}