rust_iso20022 0.1.0

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

// pub type Document = Document;
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct 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.002.001.04")]
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 ActiveCurrencyCode (pub String);
crate::simple_type!(ActiveCurrencyCode);

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

impl Validate for ActiveOrHistoricCurrencyAnd13DecimalAmountSimpleType {
    fn validate(&self) -> Result<(), String> { 
        if self.0 < "0".parse::<String>().unwrap() {
            return Err(format!("MinInclusive validation error: invalid value of 0! \nExpected: 0 >= 0.\nActual: 0 == {}", self.0));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:reda.002.001.04")]
pub struct ActiveOrHistoricCurrencyAnd13DecimalAmount {
    #[yaserde(text)]
    pub value: String,
    #[yaserde(attribute, rename = "Ccy")]
    #[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
    pub ccy: ActiveOrHistoricCurrencyCode,
}

impl Validate for ActiveOrHistoricCurrencyAnd13DecimalAmount {}


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

impl Validate for ActiveOrHistoricCurrencyAndAmountSimpleType {
    fn validate(&self) -> Result<(), String> { 
        if self.0 < "0".parse::<String>().unwrap() {
            return Err(format!("MinInclusive validation error: invalid value of 0! \nExpected: 0 >= 0.\nActual: 0 == {}", self.0));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:reda.002.001.04")]
pub struct ActiveOrHistoricCurrencyAndAmount {
    #[yaserde(text)]
    pub value: String,
    #[yaserde(attribute, rename = "Ccy")]
    #[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
    pub ccy: ActiveOrHistoricCurrencyCode,
}

impl Validate for ActiveOrHistoricCurrencyAndAmount {}


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

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

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

impl Validate for AdditionalReference3 {}


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

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

    #[yaserde(rename = "DmstIdSrc")]
    #[cfg_attr(feature = "serde", serde(rename = "DmstIdSrc"))]
    pub dmst_id_src: Option<CountryCode>,
    #[yaserde(rename = "PrtryIdSrc")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryIdSrc"))]
    pub prtry_id_src: Option<Max35Text>,
}

impl Validate for AlternateSecurityIdentification1 {}

pub mod alternate_security_identification_1 {
    use super::*;
}

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

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

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

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

impl Validate for Cusipidentifier {}
#[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.002.001.04")]

pub enum CalculationBasis2Code {
    #[yaserde(rename = "AVER")]
    #[cfg_attr(feature = "serde", serde(rename = "AVER"))]
    Aver,
    #[yaserde(rename = "DAIL")]
    #[cfg_attr(feature = "serde", serde(rename = "DAIL"))]
    Dail,
    #[yaserde(rename = "MNTH")]
    #[cfg_attr(feature = "serde", serde(rename = "MNTH"))]
    Mnth,
    #[yaserde(rename = "YEAR")]
    #[cfg_attr(feature = "serde", serde(rename = "YEAR"))]
    Year,
    __Unknown__(String),
}

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

impl Validate for CalculationBasis2Code {}



#[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.002.001.04")]
pub struct Charge15 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: Option<ChargeType9Code>,
    #[yaserde(rename = "XtndedTp")]
    #[cfg_attr(feature = "serde", serde(rename = "XtndedTp"))]
    pub xtnded_tp: Option<Extended350Code>,

    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<ActiveCurrencyAnd13DecimalAmount>,
    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: Option<PercentageRate>,

    #[yaserde(rename = "ClctnBsis")]
    #[cfg_attr(feature = "serde", serde(rename = "ClctnBsis"))]
    pub clctn_bsis: Option<CalculationBasis2Code>,
    #[yaserde(rename = "XtndedClctnBsis")]
    #[cfg_attr(feature = "serde", serde(rename = "XtndedClctnBsis"))]
    pub xtnded_clctn_bsis: Option<Extended350Code>,
}

impl Validate for Charge15 {}

pub mod charge_15 {
    use super::*;
}

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

pub enum ChargeType9Code {
    #[yaserde(rename = "MANF")]
    #[cfg_attr(feature = "serde", serde(rename = "MANF"))]
    Manf,
    #[yaserde(rename = "BEND")]
    #[cfg_attr(feature = "serde", serde(rename = "BEND"))]
    Bend,
    #[yaserde(rename = "FEND")]
    #[cfg_attr(feature = "serde", serde(rename = "FEND"))]
    Fend,
    #[yaserde(rename = "ADVI")]
    #[cfg_attr(feature = "serde", serde(rename = "ADVI"))]
    Advi,
    #[yaserde(rename = "CUST")]
    #[cfg_attr(feature = "serde", serde(rename = "CUST"))]
    Cust,
    #[yaserde(rename = "PUBL")]
    #[cfg_attr(feature = "serde", serde(rename = "PUBL"))]
    Publ,
    #[yaserde(rename = "ACCT")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCT"))]
    Acct,
    #[yaserde(rename = "EQUL")]
    #[cfg_attr(feature = "serde", serde(rename = "EQUL"))]
    Equl,
    #[yaserde(rename = "PENA")]
    #[cfg_attr(feature = "serde", serde(rename = "PENA"))]
    Pena,
    __Unknown__(String),
}

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

impl Validate for ChargeType9Code {}



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

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

impl Validate for CountryCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:reda.002.001.04")]
pub struct DateAndDateTime1Choice {
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Option<Isodate>,
    #[yaserde(rename = "DtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "DtTm"))]
    pub dt_tm: Option<IsodateTime>,
}

impl Validate for DateAndDateTime1Choice {}

pub mod date_and_date_time_1_choice {
    use super::*;
}

#[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.002.001.04")]
pub struct DateAndDateTimeChoice {
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Option<Isodate>,
    #[yaserde(rename = "DtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "DtTm"))]
    pub dt_tm: Option<IsodateTime>,
}

impl Validate for DateAndDateTimeChoice {}

pub mod date_and_date_time_choice {
    use super::*;
}

#[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.002.001.04")]
pub struct DateOrDateTimePeriodChoice {
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Option<DatePeriodDetails>,
    #[yaserde(rename = "DtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "DtTm"))]
    pub dt_tm: Option<DateTimePeriodDetails>,
}

impl Validate for DateOrDateTimePeriodChoice {}

pub mod date_or_date_time_period_choice {
    use super::*;
}

#[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.002.001.04")]
pub struct DatePeriodDetails {
    #[yaserde(rename = "FrDt")]
    #[cfg_attr(feature = "serde", serde(rename = "FrDt"))]
    pub fr_dt: Isodate,

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

impl Validate for DatePeriodDetails {}


#[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.002.001.04")]
pub struct DateTimePeriodDetails {
    #[yaserde(rename = "FrDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "FrDtTm"))]
    pub fr_dt_tm: IsodateTime,

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

impl Validate for DateTimePeriodDetails {}


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

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.002.001.04")]
pub struct Document {
    #[yaserde(rename = "PricRptCxl")]
    #[cfg_attr(feature = "serde", serde(rename = "PricRptCxl"))]
    pub pric_rpt_cxl: PriceReportCancellationV04,
}

impl Validate for Document {}


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

impl Validate for DutchIdentifier {}
#[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.002.001.04")]

pub enum EucapitalGain2Code {
    #[yaserde(rename = "EUSI")]
    #[cfg_attr(feature = "serde", serde(rename = "EUSI"))]
    Eusi,
    #[yaserde(rename = "EUSO")]
    #[cfg_attr(feature = "serde", serde(rename = "EUSO"))]
    Euso,
    #[yaserde(rename = "UKWN")]
    #[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
    Ukwn,
    __Unknown__(String),
}

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

impl Validate for EucapitalGain2Code {}



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

pub enum EudividendStatus1Code {
    #[yaserde(rename = "DIVI")]
    #[cfg_attr(feature = "serde", serde(rename = "DIVI"))]
    Divi,
    #[yaserde(rename = "DIVO")]
    #[cfg_attr(feature = "serde", serde(rename = "DIVO"))]
    Divo,
    #[yaserde(rename = "UKWN")]
    #[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
    Ukwn,
    __Unknown__(String),
}

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

impl Validate for EudividendStatus1Code {}



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

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

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

pub enum EventFrequency1Code {
    #[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 = "TOMN")]
    #[cfg_attr(feature = "serde", serde(rename = "TOMN"))]
    Tomn,
    #[yaserde(rename = "MNTH")]
    #[cfg_attr(feature = "serde", serde(rename = "MNTH"))]
    Mnth,
    #[yaserde(rename = "TWMN")]
    #[cfg_attr(feature = "serde", serde(rename = "TWMN"))]
    Twmn,
    #[yaserde(rename = "TOWK")]
    #[cfg_attr(feature = "serde", serde(rename = "TOWK"))]
    Towk,
    #[yaserde(rename = "WEEK")]
    #[cfg_attr(feature = "serde", serde(rename = "WEEK"))]
    Week,
    #[yaserde(rename = "DAIL")]
    #[cfg_attr(feature = "serde", serde(rename = "DAIL"))]
    Dail,
    #[yaserde(rename = "ADHO")]
    #[cfg_attr(feature = "serde", serde(rename = "ADHO"))]
    Adho,
    #[yaserde(rename = "INDA")]
    #[cfg_attr(feature = "serde", serde(rename = "INDA"))]
    Inda,
    #[yaserde(rename = "OVNG")]
    #[cfg_attr(feature = "serde", serde(rename = "OVNG"))]
    Ovng,
    #[yaserde(rename = "ONDE")]
    #[cfg_attr(feature = "serde", serde(rename = "ONDE"))]
    Onde,
    __Unknown__(String),
}

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

impl Validate for EventFrequency1Code {}



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

impl Validate for Extended350Code {
    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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:reda.002.001.04")]
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:reda.002.001.04")]
pub struct FinancialInstrument8 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Vec<SecurityIdentification3Choice>,

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

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

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

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

    #[yaserde(rename = "SctiesForm")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesForm"))]
    pub scties_form: FormOfSecurity1Code,

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

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

impl Validate for FinancialInstrument8 {}


#[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.002.001.04")]
pub struct FinancialInstrumentQuantity1 {
    #[yaserde(rename = "Unit")]
    #[cfg_attr(feature = "serde", serde(rename = "Unit"))]
    pub unit: DecimalNumber,
}

impl Validate for FinancialInstrumentQuantity1 {}


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

pub enum FormOfSecurity1Code {
    #[yaserde(rename = "BEAR")]
    #[cfg_attr(feature = "serde", serde(rename = "BEAR"))]
    Bear,
    #[yaserde(rename = "REGD")]
    #[cfg_attr(feature = "serde", serde(rename = "REGD"))]
    Regd,
    __Unknown__(String),
}

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

impl Validate for FormOfSecurity1Code {}



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

impl Validate for Isinidentifier {}
#[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 Max16Text (pub String);
crate::simple_type!(Max16Text);

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

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

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

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

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

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

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

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

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

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

impl Validate for Pagination {}


#[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.002.001.04")]
pub struct PartyIdentification2Choice {
    #[yaserde(rename = "BICOrBEI")]
    #[cfg_attr(feature = "serde", serde(rename = "BICOrBEI"))]
    pub bicor_b_e_i: Option<AnyBICIdentifier>,
    #[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 PartyIdentification2Choice {}

pub mod party_identification_2_choice {
    use super::*;
}

#[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.002.001.04")]
pub struct PerformanceFactors1 {
    #[yaserde(rename = "CorpActnFctr")]
    #[cfg_attr(feature = "serde", serde(rename = "CorpActnFctr"))]
    pub corp_actn_fctr: DecimalNumber,

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

    #[yaserde(rename = "AcmltnPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "AcmltnPrd"))]
    pub acmltn_prd: DatePeriodDetails,

    #[yaserde(rename = "NrmlPrfrmnc")]
    #[cfg_attr(feature = "serde", serde(rename = "NrmlPrfrmnc"))]
    pub nrml_prfrmnc: DecimalNumber,
}

impl Validate for PerformanceFactors1 {}


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

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.002.001.04")]
pub struct PriceReport3 {
    #[yaserde(rename = "PricValtnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "PricValtnDtls"))]
    pub pric_valtn_dtls: Vec<PriceValuation4>,
}

impl Validate for PriceReport3 {}


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

    #[yaserde(rename = "PoolRef")]
    #[cfg_attr(feature = "serde", serde(rename = "PoolRef"))]
    pub pool_ref: AdditionalReference3,

    #[yaserde(rename = "PrvsRef")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvsRef"))]
    pub prvs_ref: AdditionalReference3,

    #[yaserde(rename = "MsgPgntn")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgPgntn"))]
    pub msg_pgntn: Pagination,

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

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

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

    #[yaserde(rename = "XpctdPricCrrctnDt")]
    #[cfg_attr(feature = "serde", serde(rename = "XpctdPricCrrctnDt"))]
    pub xpctd_pric_crrctn_dt: DateAndDateTime1Choice,

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

    #[yaserde(rename = "CancPricValtnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "CancPricValtnDtls"))]
    pub canc_pric_valtn_dtls: Vec<PriceReport3>,

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

impl Validate for PriceReportCancellationV04 {}


#[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.002.001.04")]
pub struct PriceType2 {
    #[yaserde(rename = "Strd")]
    #[cfg_attr(feature = "serde", serde(rename = "Strd"))]
    pub strd: TypeOfPrice6Code,

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

impl Validate for PriceType2 {}


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

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

    #[yaserde(rename = "NAVDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "NAVDtTm"))]
    pub nav_dt_tm: DateAndDateTimeChoice,

    #[yaserde(rename = "FinInstrmDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrmDtls"))]
    pub fin_instrm_dtls: FinancialInstrument8,

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

    #[yaserde(rename = "TtlNAV")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlNAV"))]
    pub ttl_nav: Vec<ActiveOrHistoricCurrencyAndAmount>,

    #[yaserde(rename = "TtlUnitsNb")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlUnitsNb"))]
    pub ttl_units_nb: FinancialInstrumentQuantity1,

    #[yaserde(rename = "NxtValtnDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "NxtValtnDtTm"))]
    pub nxt_valtn_dt_tm: DateAndDateTimeChoice,

    #[yaserde(rename = "PrvsValtnDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvsValtnDtTm"))]
    pub prvs_valtn_dt_tm: DateAndDateTimeChoice,

    #[yaserde(rename = "ValtnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ValtnTp"))]
    pub valtn_tp: ValuationTiming1Code,

    #[yaserde(rename = "ValtnFrqcy")]
    #[cfg_attr(feature = "serde", serde(rename = "ValtnFrqcy"))]
    pub valtn_frqcy: EventFrequency1Code,

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

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

    #[yaserde(rename = "PricDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "PricDtls"))]
    pub pric_dtls: Vec<UnitPrice15>,

    #[yaserde(rename = "ValtnSttstcs")]
    #[cfg_attr(feature = "serde", serde(rename = "ValtnSttstcs"))]
    pub valtn_sttstcs: Vec<ValuationStatistics3>,

    #[yaserde(rename = "PrfrmncDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "PrfrmncDtls"))]
    pub prfrmnc_dtls: PerformanceFactors1,
}

impl Validate for PriceValuation4 {}


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

impl Validate for PriceValue1 {}


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

impl Validate for PriceValue5 {}


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

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

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

impl Validate for PriceValueChange1 {}


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

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

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

impl Validate for Sedolidentifier {}
#[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.002.001.04")]
pub struct SecurityIdentification3Choice {
    #[yaserde(rename = "ISIN")]
    #[cfg_attr(feature = "serde", serde(rename = "ISIN"))]
    pub isin: Option<Isinidentifier>,
    #[yaserde(rename = "SEDOL")]
    #[cfg_attr(feature = "serde", serde(rename = "SEDOL"))]
    pub sedol: Option<Sedolidentifier>,
    #[yaserde(rename = "CUSIP")]
    #[cfg_attr(feature = "serde", serde(rename = "CUSIP"))]
    pub cusip: Option<Cusipidentifier>,
    #[yaserde(rename = "RIC")]
    #[cfg_attr(feature = "serde", serde(rename = "RIC"))]
    pub ric: Option<Ricidentifier>,
    #[yaserde(rename = "TckrSymb")]
    #[cfg_attr(feature = "serde", serde(rename = "TckrSymb"))]
    pub tckr_symb: Option<TickerIdentifier>,
    #[yaserde(rename = "Blmbrg")]
    #[cfg_attr(feature = "serde", serde(rename = "Blmbrg"))]
    pub blmbrg: Option<BloombergIdentifier>,
    #[yaserde(rename = "CTA")]
    #[cfg_attr(feature = "serde", serde(rename = "CTA"))]
    pub cta: Option<ConsolidatedTapeAssociationIdentifier>,
    #[yaserde(rename = "QUICK")]
    #[cfg_attr(feature = "serde", serde(rename = "QUICK"))]
    pub quick: Option<Quickidentifier>,
    #[yaserde(rename = "Wrtppr")]
    #[cfg_attr(feature = "serde", serde(rename = "Wrtppr"))]
    pub wrtppr: Option<WertpapierIdentifier>,
    #[yaserde(rename = "Dtch")]
    #[cfg_attr(feature = "serde", serde(rename = "Dtch"))]
    pub dtch: Option<DutchIdentifier>,
    #[yaserde(rename = "Vlrn")]
    #[cfg_attr(feature = "serde", serde(rename = "Vlrn"))]
    pub vlrn: Option<ValorenIdentifier>,
    #[yaserde(rename = "SCVM")]
    #[cfg_attr(feature = "serde", serde(rename = "SCVM"))]
    pub scvm: Option<SicovamIdentifier>,
    #[yaserde(rename = "Belgn")]
    #[cfg_attr(feature = "serde", serde(rename = "Belgn"))]
    pub belgn: Option<BelgianIdentifier>,
    #[yaserde(rename = "Cmon")]
    #[cfg_attr(feature = "serde", serde(rename = "Cmon"))]
    pub cmon: Option<EuroclearClearstreamIdentifier>,
    #[yaserde(rename = "OthrPrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrPrtryId"))]
    pub othr_prtry_id: Option<AlternateSecurityIdentification1>,
}

impl Validate for SecurityIdentification3Choice {}

pub mod security_identification_3_choice {
    use super::*;
}

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

impl Validate for SicovamIdentifier {}
#[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.002.001.04")]
pub struct StatisticsByPredefinedTimePeriods2 {
    #[yaserde(rename = "HghstPricVal12Mnths")]
    #[cfg_attr(feature = "serde", serde(rename = "HghstPricVal12Mnths"))]
    pub hghst_pric_val_12_mnths: PriceValue5,

    #[yaserde(rename = "LwstPricVal12Mnths")]
    #[cfg_attr(feature = "serde", serde(rename = "LwstPricVal12Mnths"))]
    pub lwst_pric_val_12_mnths: PriceValue5,

    #[yaserde(rename = "OneYrPricChng")]
    #[cfg_attr(feature = "serde", serde(rename = "OneYrPricChng"))]
    pub one_yr_pric_chng: PriceValueChange1,

    #[yaserde(rename = "ThreeYrPricChng")]
    #[cfg_attr(feature = "serde", serde(rename = "ThreeYrPricChng"))]
    pub three_yr_pric_chng: PriceValueChange1,

    #[yaserde(rename = "FiveYrPricChng")]
    #[cfg_attr(feature = "serde", serde(rename = "FiveYrPricChng"))]
    pub five_yr_pric_chng: PriceValueChange1,
}

impl Validate for StatisticsByPredefinedTimePeriods2 {}


#[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.002.001.04")]
pub struct StatisticsByUserDefinedTimePeriod2 {
    #[yaserde(rename = "Prd")]
    #[cfg_attr(feature = "serde", serde(rename = "Prd"))]
    pub prd: DateOrDateTimePeriodChoice,

    #[yaserde(rename = "HghstPricVal")]
    #[cfg_attr(feature = "serde", serde(rename = "HghstPricVal"))]
    pub hghst_pric_val: PriceValue5,

    #[yaserde(rename = "LwstPricVal")]
    #[cfg_attr(feature = "serde", serde(rename = "LwstPricVal"))]
    pub lwst_pric_val: PriceValue5,

    #[yaserde(rename = "PricChng")]
    #[cfg_attr(feature = "serde", serde(rename = "PricChng"))]
    pub pric_chng: PriceValueChange1,

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

impl Validate for StatisticsByUserDefinedTimePeriod2 {}


#[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.002.001.04")]
pub struct Tax17 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: Option<TaxType12Code>,
    #[yaserde(rename = "XtndedTp")]
    #[cfg_attr(feature = "serde", serde(rename = "XtndedTp"))]
    pub xtnded_tp: Option<Extended350Code>,

    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Vec<ActiveOrHistoricCurrencyAnd13DecimalAmount>,

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

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

    #[yaserde(rename = "TaxClctnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxClctnDtls"))]
    pub tax_clctn_dtls: TaxCalculationInformation4,
}

impl Validate for Tax17 {}

pub mod tax_17 {
    use super::*;
}

#[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.002.001.04")]
pub struct TaxCalculationInformation4 {
    #[yaserde(rename = "EUCptlGn")]
    #[cfg_attr(feature = "serde", serde(rename = "EUCptlGn"))]
    pub eucptl_gn: Option<EucapitalGain2Code>,
    #[yaserde(rename = "XtndedEUCptlGn")]
    #[cfg_attr(feature = "serde", serde(rename = "XtndedEUCptlGn"))]
    pub xtnded_e_u_cptl_gn: Option<Extended350Code>,

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

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

    #[yaserde(rename = "TaxblIncmPerDvdd")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxblIncmPerDvdd"))]
    pub taxbl_incm_per_dvdd: ActiveOrHistoricCurrencyAnd13DecimalAmount,

    #[yaserde(rename = "EUDvddSts")]
    #[cfg_attr(feature = "serde", serde(rename = "EUDvddSts"))]
    pub eudvdd_sts: Option<EudividendStatus1Code>,
    #[yaserde(rename = "XtndedEUDvddSts")]
    #[cfg_attr(feature = "serde", serde(rename = "XtndedEUDvddSts"))]
    pub xtnded_e_u_dvdd_sts: Option<Extended350Code>,
}

impl Validate for TaxCalculationInformation4 {}

pub mod tax_calculation_information_4 {
    use super::*;
}

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

pub enum TaxType12Code {
    #[yaserde(rename = "INPO")]
    #[cfg_attr(feature = "serde", serde(rename = "INPO"))]
    Inpo,
    #[yaserde(rename = "EUTR")]
    #[cfg_attr(feature = "serde", serde(rename = "EUTR"))]
    Eutr,
    #[yaserde(rename = "AKT1")]
    #[cfg_attr(feature = "serde", serde(rename = "AKT1"))]
    Akt1,
    #[yaserde(rename = "AKT2")]
    #[cfg_attr(feature = "serde", serde(rename = "AKT2"))]
    Akt2,
    #[yaserde(rename = "ZWIS")]
    #[cfg_attr(feature = "serde", serde(rename = "ZWIS"))]
    Zwis,
    #[yaserde(rename = "MIET")]
    #[cfg_attr(feature = "serde", serde(rename = "MIET"))]
    Miet,
    __Unknown__(String),
}

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

impl Validate for TaxType12Code {}



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

pub enum TaxableIncomePerShareCalculated2Code {
    #[yaserde(rename = "TSIY")]
    #[cfg_attr(feature = "serde", serde(rename = "TSIY"))]
    Tsiy,
    #[yaserde(rename = "TSIN")]
    #[cfg_attr(feature = "serde", serde(rename = "TSIN"))]
    Tsin,
    #[yaserde(rename = "UKWN")]
    #[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
    Ukwn,
    __Unknown__(String),
}

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

impl Validate for TaxableIncomePerShareCalculated2Code {}



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

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

pub enum TypeOfPrice6Code {
    #[yaserde(rename = "BIDE")]
    #[cfg_attr(feature = "serde", serde(rename = "BIDE"))]
    Bide,
    #[yaserde(rename = "OFFR")]
    #[cfg_attr(feature = "serde", serde(rename = "OFFR"))]
    Offr,
    #[yaserde(rename = "NAVL")]
    #[cfg_attr(feature = "serde", serde(rename = "NAVL"))]
    Navl,
    #[yaserde(rename = "CREA")]
    #[cfg_attr(feature = "serde", serde(rename = "CREA"))]
    Crea,
    #[yaserde(rename = "CANC")]
    #[cfg_attr(feature = "serde", serde(rename = "CANC"))]
    Canc,
    #[yaserde(rename = "INTE")]
    #[cfg_attr(feature = "serde", serde(rename = "INTE"))]
    Inte,
    #[yaserde(rename = "SWNG")]
    #[cfg_attr(feature = "serde", serde(rename = "SWNG"))]
    Swng,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "MIDD")]
    #[cfg_attr(feature = "serde", serde(rename = "MIDD"))]
    Midd,
    #[yaserde(rename = "RINV")]
    #[cfg_attr(feature = "serde", serde(rename = "RINV"))]
    Rinv,
    #[yaserde(rename = "SWIC")]
    #[cfg_attr(feature = "serde", serde(rename = "SWIC"))]
    Swic,
    #[yaserde(rename = "DDVR")]
    #[cfg_attr(feature = "serde", serde(rename = "DDVR"))]
    Ddvr,
    #[yaserde(rename = "ACTU")]
    #[cfg_attr(feature = "serde", serde(rename = "ACTU"))]
    Actu,
    #[yaserde(rename = "NAUP")]
    #[cfg_attr(feature = "serde", serde(rename = "NAUP"))]
    Naup,
    __Unknown__(String),
}

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

impl Validate for TypeOfPrice6Code {}



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

pub enum TypeOfPrice9Code {
    #[yaserde(rename = "BIDE")]
    #[cfg_attr(feature = "serde", serde(rename = "BIDE"))]
    Bide,
    #[yaserde(rename = "OFFR")]
    #[cfg_attr(feature = "serde", serde(rename = "OFFR"))]
    Offr,
    #[yaserde(rename = "NAVL")]
    #[cfg_attr(feature = "serde", serde(rename = "NAVL"))]
    Navl,
    #[yaserde(rename = "CREA")]
    #[cfg_attr(feature = "serde", serde(rename = "CREA"))]
    Crea,
    #[yaserde(rename = "CANC")]
    #[cfg_attr(feature = "serde", serde(rename = "CANC"))]
    Canc,
    #[yaserde(rename = "INTE")]
    #[cfg_attr(feature = "serde", serde(rename = "INTE"))]
    Inte,
    #[yaserde(rename = "SWNG")]
    #[cfg_attr(feature = "serde", serde(rename = "SWNG"))]
    Swng,
    #[yaserde(rename = "MIDD")]
    #[cfg_attr(feature = "serde", serde(rename = "MIDD"))]
    Midd,
    #[yaserde(rename = "RINV")]
    #[cfg_attr(feature = "serde", serde(rename = "RINV"))]
    Rinv,
    #[yaserde(rename = "SWIC")]
    #[cfg_attr(feature = "serde", serde(rename = "SWIC"))]
    Swic,
    #[yaserde(rename = "DDVR")]
    #[cfg_attr(feature = "serde", serde(rename = "DDVR"))]
    Ddvr,
    #[yaserde(rename = "ACTU")]
    #[cfg_attr(feature = "serde", serde(rename = "ACTU"))]
    Actu,
    #[yaserde(rename = "NAUP")]
    #[cfg_attr(feature = "serde", serde(rename = "NAUP"))]
    Naup,
    #[yaserde(rename = "GUAR")]
    #[cfg_attr(feature = "serde", serde(rename = "GUAR"))]
    Guar,
    #[yaserde(rename = "ENAV")]
    #[cfg_attr(feature = "serde", serde(rename = "ENAV"))]
    Enav,
    __Unknown__(String),
}

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

impl Validate for TypeOfPrice9Code {}



#[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.002.001.04")]
pub struct UnitPrice15 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: Option<TypeOfPrice9Code>,
    #[yaserde(rename = "XtndedTp")]
    #[cfg_attr(feature = "serde", serde(rename = "XtndedTp"))]
    pub xtnded_tp: Option<Extended350Code>,

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

    #[yaserde(rename = "ValInInvstmtCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "ValInInvstmtCcy"))]
    pub val_in_invstmt_ccy: Vec<PriceValue1>,

    #[yaserde(rename = "ValInAltrntvCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "ValInAltrntvCcy"))]
    pub val_in_altrntv_ccy: Vec<PriceValue1>,

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

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

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

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

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

    #[yaserde(rename = "TaxblIncmPerShr")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxblIncmPerShr"))]
    pub taxbl_incm_per_shr: ActiveOrHistoricCurrencyAnd13DecimalAmount,

    #[yaserde(rename = "TaxblIncmPerShrClctd")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxblIncmPerShrClctd"))]
    pub taxbl_incm_per_shr_clctd: Option<TaxableIncomePerShareCalculated2Code>,
    #[yaserde(rename = "XtndedTaxblIncmPerShrClctd")]
    #[cfg_attr(feature = "serde", serde(rename = "XtndedTaxblIncmPerShrClctd"))]
    pub xtnded_taxbl_incm_per_shr_clctd: Option<Extended350Code>,

    #[yaserde(rename = "TaxblIncmPerDvdd")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxblIncmPerDvdd"))]
    pub taxbl_incm_per_dvdd: ActiveOrHistoricCurrencyAnd13DecimalAmount,

    #[yaserde(rename = "EUDvddSts")]
    #[cfg_attr(feature = "serde", serde(rename = "EUDvddSts"))]
    pub eudvdd_sts: Option<EudividendStatus1Code>,
    #[yaserde(rename = "XtndedEUDvddSts")]
    #[cfg_attr(feature = "serde", serde(rename = "XtndedEUDvddSts"))]
    pub xtnded_e_u_dvdd_sts: Option<Extended350Code>,

    #[yaserde(rename = "ChrgDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "ChrgDtls"))]
    pub chrg_dtls: Vec<Charge15>,

    #[yaserde(rename = "TaxLbltyDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxLbltyDtls"))]
    pub tax_lblty_dtls: Vec<Tax17>,

    #[yaserde(rename = "TaxRfndDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxRfndDtls"))]
    pub tax_rfnd_dtls: Vec<Tax17>,
}

impl Validate for UnitPrice15 {}

pub mod unit_price_15 {
    use super::*;
}

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

impl Validate for ValorenIdentifier {}
#[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.002.001.04")]
pub struct ValuationStatistics3 {
    #[yaserde(rename = "Ccy")]
    #[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
    pub ccy: ActiveOrHistoricCurrencyCode,

    #[yaserde(rename = "PricTpChngBsis")]
    #[cfg_attr(feature = "serde", serde(rename = "PricTpChngBsis"))]
    pub pric_tp_chng_bsis: PriceType2,

    #[yaserde(rename = "PricChng")]
    #[cfg_attr(feature = "serde", serde(rename = "PricChng"))]
    pub pric_chng: PriceValueChange1,

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

    #[yaserde(rename = "ByPrdfndTmPrds")]
    #[cfg_attr(feature = "serde", serde(rename = "ByPrdfndTmPrds"))]
    pub by_prdfnd_tm_prds: StatisticsByPredefinedTimePeriods2,

    #[yaserde(rename = "ByUsrDfndTmPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "ByUsrDfndTmPrd"))]
    pub by_usr_dfnd_tm_prd: Vec<StatisticsByUserDefinedTimePeriod2>,
}

impl Validate for ValuationStatistics3 {}


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

pub enum ValuationTiming1Code {
    #[yaserde(rename = "EXCP")]
    #[cfg_attr(feature = "serde", serde(rename = "EXCP"))]
    Excp,
    #[yaserde(rename = "USUA")]
    #[cfg_attr(feature = "serde", serde(rename = "USUA"))]
    Usua,
    #[yaserde(rename = "PATC")]
    #[cfg_attr(feature = "serde", serde(rename = "PATC"))]
    Patc,
    __Unknown__(String),
}

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

impl Validate for ValuationTiming1Code {}



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

impl Validate for WertpapierIdentifier {}
#[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 = "002";
    const VARIANT: &'static str = "001";
    const VERSION: &'static str = "04";
    const MESSAGE_NAME: &'static str = "reda.002.001.04";
    const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:reda.002.001.04";
}