rust_iso20022 0.1.1

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

// pub type Document = Document;
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.006.001.02")]
pub struct Account7 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: AccountIdentification1,

    #[yaserde(rename = "AcctSvcr")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctSvcr"))]
    pub acct_svcr: PartyIdentification2Choice,
}

impl Validate for Account7 {}


#[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:semt.006.001.02")]
pub struct AccountIdentification1 {
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: SimpleIdentificationInformation,
}

impl Validate for AccountIdentification1 {}


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

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

    #[yaserde(rename = "Inf")]
    #[cfg_attr(feature = "serde", serde(rename = "Inf"))]
    pub inf: Exact4AlphaNumericText,
}

impl Validate for AccountIdentification3 {}


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

    #[yaserde(rename = "Purp")]
    #[cfg_attr(feature = "serde", serde(rename = "Purp"))]
    pub purp: SecuritiesAccountPurposeType1Code,
}

impl Validate for AccountIdentificationAndPurpose {}
#[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:semt.006.001.02")]
pub struct AccountIdentificationFormatChoice {
    #[yaserde(rename = "SmplId")]
    #[cfg_attr(feature = "serde", serde(rename = "SmplId"))]
    pub smpl_id: Option<AccountIdentification1>,
    #[yaserde(rename = "IdAndPurp")]
    #[cfg_attr(feature = "serde", serde(rename = "IdAndPurp"))]
    pub id_and_purp: Option<AccountIdentificationAndPurpose>,
    #[yaserde(rename = "IdAsDSS")]
    #[cfg_attr(feature = "serde", serde(rename = "IdAsDSS"))]
    pub id_as_d_s_s: Option<AccountIdentification3>,
}

impl Validate for AccountIdentificationFormatChoice {}




#[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:semt.006.001.02")]
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:semt.006.001.02")]
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:semt.006.001.02")]
pub struct AdditionalReference2 {
    #[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: PartyIdentification1Choice,

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

impl Validate for AdditionalReference2 {}


#[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:semt.006.001.02")]

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

pub enum CorporateActionEventType1Code {
    #[yaserde(rename = "DRIP")]
    #[cfg_attr(feature = "serde", serde(rename = "DRIP"))]
    Drip,
    #[yaserde(rename = "CAPG")]
    #[cfg_attr(feature = "serde", serde(rename = "CAPG"))]
    Capg,
    #[yaserde(rename = "DVCA")]
    #[cfg_attr(feature = "serde", serde(rename = "DVCA"))]
    Dvca,
    #[yaserde(rename = "DVOP")]
    #[cfg_attr(feature = "serde", serde(rename = "DVOP"))]
    Dvop,
    #[yaserde(rename = "DVSE")]
    #[cfg_attr(feature = "serde", serde(rename = "DVSE"))]
    Dvse,
    #[yaserde(rename = "LIQU")]
    #[cfg_attr(feature = "serde", serde(rename = "LIQU"))]
    Liqu,
    #[yaserde(rename = "MRGR")]
    #[cfg_attr(feature = "serde", serde(rename = "MRGR"))]
    Mrgr,
    #[yaserde(rename = "NAME")]
    #[cfg_attr(feature = "serde", serde(rename = "NAME"))]
    Name,
    #[yaserde(rename = "SOFF")]
    #[cfg_attr(feature = "serde", serde(rename = "SOFF"))]
    Soff,
    #[yaserde(rename = "SPLF")]
    #[cfg_attr(feature = "serde", serde(rename = "SPLF"))]
    Splf,
    #[yaserde(rename = "SPLR")]
    #[cfg_attr(feature = "serde", serde(rename = "SPLR"))]
    Splr,
    #[yaserde(rename = "TEND")]
    #[cfg_attr(feature = "serde", serde(rename = "TEND"))]
    Tend,
    #[yaserde(rename = "BONU")]
    #[cfg_attr(feature = "serde", serde(rename = "BONU"))]
    Bonu,
    #[yaserde(rename = "RHDI")]
    #[cfg_attr(feature = "serde", serde(rename = "RHDI"))]
    Rhdi,
    #[yaserde(rename = "EXRI")]
    #[cfg_attr(feature = "serde", serde(rename = "EXRI"))]
    Exri,
    #[yaserde(rename = "CHAN")]
    #[cfg_attr(feature = "serde", serde(rename = "CHAN"))]
    Chan,
    #[yaserde(rename = "REDO")]
    #[cfg_attr(feature = "serde", serde(rename = "REDO"))]
    Redo,
    #[yaserde(rename = "EXOP")]
    #[cfg_attr(feature = "serde", serde(rename = "EXOP"))]
    Exop,
    #[yaserde(rename = "EXOF")]
    #[cfg_attr(feature = "serde", serde(rename = "EXOF"))]
    Exof,
    #[yaserde(rename = "DECR")]
    #[cfg_attr(feature = "serde", serde(rename = "DECR"))]
    Decr,
    __Unknown__(String),
}

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

impl Validate for CorporateActionEventType1Code {}



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

pub enum CreditDebitCode {
    #[yaserde(rename = "CRDT")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDT"))]
    Crdt,
    #[yaserde(rename = "DBIT")]
    #[cfg_attr(feature = "serde", serde(rename = "DBIT"))]
    Dbit,
    __Unknown__(String),
}

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

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

impl Validate for DateAndDateTimeChoice {}




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

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:semt.006.001.02")]
pub struct Document {
    #[yaserde(rename = "StmtOfInvstmtFndTxsV02")]
    #[cfg_attr(feature = "serde", serde(rename = "StmtOfInvstmtFndTxsV02"))]
    pub stmt_of_invstmt_fnd_txs_v02: StatementOfInvestmentFundTransactionsV02,
}

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(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:semt.006.001.02")]

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 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)]
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:semt.006.001.02")]
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:semt.006.001.02")]
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:semt.006.001.02")]

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

    #[yaserde(rename = "Acct")]
    #[cfg_attr(feature = "serde", serde(rename = "Acct"))]
    pub acct: Account7,

    #[yaserde(rename = "Role")]
    #[cfg_attr(feature = "serde", serde(rename = "Role"))]
    pub role: Option<InvestmentFundRole2Code>,
    #[yaserde(rename = "XtndedRole")]
    #[cfg_attr(feature = "serde", serde(rename = "XtndedRole"))]
    pub xtnded_role: Option<Extended350Code>,
}

impl Validate for Intermediary11 {}

pub mod intermediary_11 {
    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:semt.006.001.02")]
pub struct InvestmentAccount25 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: AccountIdentification1,

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

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

    #[yaserde(rename = "IntrmyInf")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrmyInf"))]
    pub intrmy_inf: Vec<Intermediary11>,

    #[yaserde(rename = "AcctSvcr")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctSvcr"))]
    pub acct_svcr: PartyIdentification2Choice,
}

impl Validate for InvestmentAccount25 {}


#[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:semt.006.001.02")]

pub enum InvestmentFundRole2Code {
    #[yaserde(rename = "FMCO")]
    #[cfg_attr(feature = "serde", serde(rename = "FMCO"))]
    Fmco,
    #[yaserde(rename = "REGI")]
    #[cfg_attr(feature = "serde", serde(rename = "REGI"))]
    Regi,
    #[yaserde(rename = "TRAG")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAG"))]
    Trag,
    #[yaserde(rename = "INTR")]
    #[cfg_attr(feature = "serde", serde(rename = "INTR"))]
    Intr,
    #[yaserde(rename = "DIST")]
    #[cfg_attr(feature = "serde", serde(rename = "DIST"))]
    Dist,
    #[yaserde(rename = "CONC")]
    #[cfg_attr(feature = "serde", serde(rename = "CONC"))]
    Conc,
    #[yaserde(rename = "UCL1")]
    #[cfg_attr(feature = "serde", serde(rename = "UCL1"))]
    Ucl1,
    #[yaserde(rename = "UCL2")]
    #[cfg_attr(feature = "serde", serde(rename = "UCL2"))]
    Ucl2,
    #[yaserde(rename = "TRAN")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAN"))]
    Tran,
    __Unknown__(String),
}

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

impl Validate for InvestmentFundRole2Code {}



#[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:semt.006.001.02")]
pub struct InvestmentFundTransaction3 {
    #[yaserde(rename = "TxTp")]
    #[cfg_attr(feature = "serde", serde(rename = "TxTp"))]
    pub tx_tp: Option<TransactionType2Code>,
    #[yaserde(rename = "XtndedTxTp")]
    #[cfg_attr(feature = "serde", serde(rename = "XtndedTxTp"))]
    pub xtnded_tx_tp: Option<Extended350Code>,
    #[yaserde(rename = "CorpActnEvtTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CorpActnEvtTp"))]
    pub corp_actn_evt_tp: Option<CorporateActionEventType1Code>,
    #[yaserde(rename = "XtndedCorpActnEvtTp")]
    #[cfg_attr(feature = "serde", serde(rename = "XtndedCorpActnEvtTp"))]
    pub xtnded_corp_actn_evt_tp: Option<Extended350Code>,

    #[yaserde(rename = "BookgSts")]
    #[cfg_attr(feature = "serde", serde(rename = "BookgSts"))]
    pub bookg_sts: TransactionStatus1Code,

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

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

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

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

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

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

    #[yaserde(rename = "OrdrDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "OrdrDtTm"))]
    pub ordr_dt_tm: IsodateTime,

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

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

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

    #[yaserde(rename = "CdtDbt")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtDbt"))]
    pub cdt_dbt: CreditDebitCode,

    #[yaserde(rename = "Rvsl")]
    #[cfg_attr(feature = "serde", serde(rename = "Rvsl"))]
    pub rvsl: ReversalCode,

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

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

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

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

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

    #[yaserde(rename = "PricDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "PricDtls"))]
    pub pric_dtls: UnitPrice11,
}

impl Validate for InvestmentFundTransaction3 {}

pub mod investment_fund_transaction_3 {
    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:semt.006.001.02")]
pub struct InvestmentFundTransactionsByFund2 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: 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 = "SctiesForm")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesForm"))]
    pub scties_form: FormOfSecurity1Code,

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

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

    #[yaserde(rename = "TxDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "TxDtls"))]
    pub tx_dtls: Vec<InvestmentFundTransaction3>,

    #[yaserde(rename = "BalByPg")]
    #[cfg_attr(feature = "serde", serde(rename = "BalByPg"))]
    pub bal_by_pg: PaginationBalance1,
}

impl Validate for InvestmentFundTransactionsByFund2 {}
#[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:semt.006.001.02")]
pub struct LongPostalAddress1Choice {
    #[yaserde(rename = "Ustrd")]
    #[cfg_attr(feature = "serde", serde(rename = "Ustrd"))]
    pub ustrd: Option<Max140Text>,
    #[yaserde(rename = "Strd")]
    #[cfg_attr(feature = "serde", serde(rename = "Strd"))]
    pub strd: Option<StructuredLongPostalAddress1>,
}

impl Validate for LongPostalAddress1Choice {}




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

impl Validate for Max8Text {
    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() > 8 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 8 \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:semt.006.001.02")]
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:semt.006.001.02")]
pub struct NameAndAddress2 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max35Text,

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

impl Validate for NameAndAddress2 {}


#[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:semt.006.001.02")]
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:semt.006.001.02")]
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:semt.006.001.02")]
pub struct PaginationBalance1 {
    #[yaserde(rename = "FrstOpngBal")]
    #[cfg_attr(feature = "serde", serde(rename = "FrstOpngBal"))]
    pub frst_opng_bal: Option<FinancialInstrumentQuantity1>,
    #[yaserde(rename = "IntrmyOpngBal")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrmyOpngBal"))]
    pub intrmy_opng_bal: Option<FinancialInstrumentQuantity1>,

    #[yaserde(rename = "FnlClsgBal")]
    #[cfg_attr(feature = "serde", serde(rename = "FnlClsgBal"))]
    pub fnl_clsg_bal: Option<FinancialInstrumentQuantity1>,
    #[yaserde(rename = "IntrmyClsgBal")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrmyClsgBal"))]
    pub intrmy_clsg_bal: Option<FinancialInstrumentQuantity1>,
}

impl Validate for PaginationBalance1 {}

pub mod pagination_balance_1 {
    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:semt.006.001.02")]
pub struct PartyIdentification1Choice {
    #[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<NameAndAddress2>,
}

impl Validate for PartyIdentification1Choice {}
#[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:semt.006.001.02")]
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 {}




#[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:semt.006.001.02")]
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:semt.006.001.02")]

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

pub enum ReversalCode {
    #[yaserde(rename = "RVCD")]
    #[cfg_attr(feature = "serde", serde(rename = "RVCD"))]
    Rvcd,
    #[yaserde(rename = "RVDB")]
    #[cfg_attr(feature = "serde", serde(rename = "RVDB"))]
    Rvdb,
    __Unknown__(String),
}

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

impl Validate for ReversalCode {}



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

pub enum SecuritiesAccountPurposeType1Code {
    #[yaserde(rename = "MARG")]
    #[cfg_attr(feature = "serde", serde(rename = "MARG"))]
    Marg,
    #[yaserde(rename = "SHOR")]
    #[cfg_attr(feature = "serde", serde(rename = "SHOR"))]
    Shor,
    #[yaserde(rename = "ABRD")]
    #[cfg_attr(feature = "serde", serde(rename = "ABRD"))]
    Abrd,
    #[yaserde(rename = "CEND")]
    #[cfg_attr(feature = "serde", serde(rename = "CEND"))]
    Cend,
    #[yaserde(rename = "DVPA")]
    #[cfg_attr(feature = "serde", serde(rename = "DVPA"))]
    Dvpa,
    #[yaserde(rename = "PHYS")]
    #[cfg_attr(feature = "serde", serde(rename = "PHYS"))]
    Phys,
    __Unknown__(String),
}

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

impl Validate for SecuritiesAccountPurposeType1Code {}
#[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:semt.006.001.02")]
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 {}




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

impl Validate for SimpleIdentificationInformation {}


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

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

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

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

    #[yaserde(rename = "UpdTp")]
    #[cfg_attr(feature = "serde", serde(rename = "UpdTp"))]
    pub upd_tp: StatementUpdateTypeCode,

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

    #[yaserde(rename = "RptNb")]
    #[cfg_attr(feature = "serde", serde(rename = "RptNb"))]
    pub rpt_nb: Max5NumericText,
}

impl Validate for Statement8 {}


#[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:semt.006.001.02")]
pub struct StatementOfInvestmentFundTransactionsV02 {
    #[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<AdditionalReference2>,

    #[yaserde(rename = "RltdRef")]
    #[cfg_attr(feature = "serde", serde(rename = "RltdRef"))]
    pub rltd_ref: Vec<AdditionalReference2>,

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

    #[yaserde(rename = "StmtGnlDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "StmtGnlDtls"))]
    pub stmt_gnl_dtls: Statement8,

    #[yaserde(rename = "InvstmtAcctDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "InvstmtAcctDtls"))]
    pub invstmt_acct_dtls: InvestmentAccount25,

    #[yaserde(rename = "TxOnAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "TxOnAcct"))]
    pub tx_on_acct: Vec<InvestmentFundTransactionsByFund2>,

    #[yaserde(rename = "SubAcctDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "SubAcctDtls"))]
    pub sub_acct_dtls: Vec<SubAccountIdentification6>,

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

impl Validate for StatementOfInvestmentFundTransactionsV02 {}


#[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:semt.006.001.02")]

pub enum StatementUpdateTypeCode {
    #[yaserde(rename = "COMP")]
    #[cfg_attr(feature = "serde", serde(rename = "COMP"))]
    Comp,
    #[yaserde(rename = "DELT")]
    #[cfg_attr(feature = "serde", serde(rename = "DELT"))]
    Delt,
    __Unknown__(String),
}

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

impl Validate for StatementUpdateTypeCode {}



#[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:semt.006.001.02")]
pub struct StructuredLongPostalAddress1 {
    #[yaserde(rename = "BldgNm")]
    #[cfg_attr(feature = "serde", serde(rename = "BldgNm"))]
    pub bldg_nm: Max35Text,

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

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

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

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

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

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

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

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

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

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

    #[yaserde(rename = "POB")]
    #[cfg_attr(feature = "serde", serde(rename = "POB"))]
    pub pob: Max16Text,
}

impl Validate for StructuredLongPostalAddress1 {}


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

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

    #[yaserde(rename = "TxOnSubAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "TxOnSubAcct"))]
    pub tx_on_sub_acct: Vec<InvestmentFundTransactionsByFund2>,
}

impl Validate for SubAccountIdentification6 {}


#[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:semt.006.001.02")]

pub enum TransactionStatus1Code {
    #[yaserde(rename = "RVSL")]
    #[cfg_attr(feature = "serde", serde(rename = "RVSL"))]
    Rvsl,
    #[yaserde(rename = "REBO")]
    #[cfg_attr(feature = "serde", serde(rename = "REBO"))]
    Rebo,
    #[yaserde(rename = "CANC")]
    #[cfg_attr(feature = "serde", serde(rename = "CANC"))]
    Canc,
    __Unknown__(String),
}

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

impl Validate for TransactionStatus1Code {}



#[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:semt.006.001.02")]

pub enum TransactionType2Code {
    #[yaserde(rename = "REDM")]
    #[cfg_attr(feature = "serde", serde(rename = "REDM"))]
    Redm,
    #[yaserde(rename = "SUBS")]
    #[cfg_attr(feature = "serde", serde(rename = "SUBS"))]
    Subs,
    #[yaserde(rename = "SSPL")]
    #[cfg_attr(feature = "serde", serde(rename = "SSPL"))]
    Sspl,
    #[yaserde(rename = "RWPL")]
    #[cfg_attr(feature = "serde", serde(rename = "RWPL"))]
    Rwpl,
    #[yaserde(rename = "TRIN")]
    #[cfg_attr(feature = "serde", serde(rename = "TRIN"))]
    Trin,
    #[yaserde(rename = "TOUT")]
    #[cfg_attr(feature = "serde", serde(rename = "TOUT"))]
    Tout,
    #[yaserde(rename = "SWII")]
    #[cfg_attr(feature = "serde", serde(rename = "SWII"))]
    Swii,
    #[yaserde(rename = "SWIO")]
    #[cfg_attr(feature = "serde", serde(rename = "SWIO"))]
    Swio,
    #[yaserde(rename = "SUAA")]
    #[cfg_attr(feature = "serde", serde(rename = "SUAA"))]
    Suaa,
    #[yaserde(rename = "REAA")]
    #[cfg_attr(feature = "serde", serde(rename = "REAA"))]
    Reaa,
    __Unknown__(String),
}

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

impl Validate for TransactionType2Code {}



#[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:semt.006.001.02")]

pub enum TypeOfPrice10Code {
    #[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,
    __Unknown__(String),
}

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

impl Validate for TypeOfPrice10Code {}



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

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

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

impl Validate for UnitPrice11 {}

pub mod unit_price_11 {
    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)]
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::semt;
    const FUNCTIONALITY: &'static str = "006";
    const VARIANT: &'static str = "001";
    const VERSION: &'static str = "02";
    const MESSAGE_NAME: &'static str = "semt.006.001.02";
    const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:semt.006.001.02";
}