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.004.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.004.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.004.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.004.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.004.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 {}

pub mod account_identification_format_choice {
    use super::*;
}

#[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.004.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)]
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:semt.004.001.02")]
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:semt.004.001.02")]
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:semt.004.001.02")]
pub struct AdditionalBalanceInformation2 {
    #[yaserde(rename = "Qty")]
    #[cfg_attr(feature = "serde", serde(rename = "Qty"))]
    pub qty: SubBalanceQuantity1Choice,

    #[yaserde(rename = "SubBalTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SubBalTp"))]
    pub sub_bal_tp: Option<SecuritiesBalanceType2Code>,
    #[yaserde(rename = "XtndedSubBalTp")]
    #[cfg_attr(feature = "serde", serde(rename = "XtndedSubBalTp"))]
    pub xtnded_sub_bal_tp: Option<Extended350Code>,
}

impl Validate for AdditionalBalanceInformation2 {}

pub mod additional_balance_information_2 {
    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.004.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.004.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.004.001.02")]
pub struct AggregateBalanceInformation4 {
    #[yaserde(rename = "AggtQty")]
    #[cfg_attr(feature = "serde", serde(rename = "AggtQty"))]
    pub aggt_qty: BalanceQuantity1Choice,

    #[yaserde(rename = "AvlblQty")]
    #[cfg_attr(feature = "serde", serde(rename = "AvlblQty"))]
    pub avlbl_qty: BalanceQuantity1Choice,

    #[yaserde(rename = "NotAvlblQty")]
    #[cfg_attr(feature = "serde", serde(rename = "NotAvlblQty"))]
    pub not_avlbl_qty: BalanceQuantity1Choice,

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

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

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

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

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

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

    #[yaserde(rename = "SfkpgPlc")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgPlc"))]
    pub sfkpg_plc: SafekeepingPlaceFormatChoice,

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

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

    #[yaserde(rename = "FXDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "FXDtls"))]
    pub fx_dtls: ForeignExchangeTerms6,

    #[yaserde(rename = "BalBrkdwnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "BalBrkdwnDtls"))]
    pub bal_brkdwn_dtls: Vec<SubBalanceInformation2>,

    #[yaserde(rename = "AddtlBalBrkdwnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlBalBrkdwnDtls"))]
    pub addtl_bal_brkdwn_dtls: Vec<AdditionalBalanceInformation2>,

    #[yaserde(rename = "BalAtSfkpgPlc")]
    #[cfg_attr(feature = "serde", serde(rename = "BalAtSfkpgPlc"))]
    pub bal_at_sfkpg_plc: Vec<AggregateBalancePerSafekeepingPlace3>,
}

impl Validate for AggregateBalanceInformation4 {}


#[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.004.001.02")]
pub struct AggregateBalancePerSafekeepingPlace3 {
    #[yaserde(rename = "AggtQty")]
    #[cfg_attr(feature = "serde", serde(rename = "AggtQty"))]
    pub aggt_qty: BalanceQuantity1Choice,

    #[yaserde(rename = "AvlblQty")]
    #[cfg_attr(feature = "serde", serde(rename = "AvlblQty"))]
    pub avlbl_qty: BalanceQuantity1Choice,

    #[yaserde(rename = "NotAvlblQty")]
    #[cfg_attr(feature = "serde", serde(rename = "NotAvlblQty"))]
    pub not_avlbl_qty: BalanceQuantity1Choice,

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

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

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

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

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

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

    #[yaserde(rename = "SfkpgPlc")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgPlc"))]
    pub sfkpg_plc: SafekeepingPlaceFormatChoice,

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

    #[yaserde(rename = "FXDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "FXDtls"))]
    pub fx_dtls: ForeignExchangeTerms6,

    #[yaserde(rename = "BalBrkdwnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "BalBrkdwnDtls"))]
    pub bal_brkdwn_dtls: Vec<SubBalanceInformation2>,

    #[yaserde(rename = "AddtlBalBrkdwnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlBalBrkdwnDtls"))]
    pub addtl_bal_brkdwn_dtls: Vec<AdditionalBalanceInformation2>,
}

impl Validate for AggregateBalancePerSafekeepingPlace3 {}


#[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.004.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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.004.001.02")]
pub struct BalanceQuantity1Choice {
    #[yaserde(rename = "Qty")]
    #[cfg_attr(feature = "serde", serde(rename = "Qty"))]
    pub qty: Option<FinancialInstrumentQuantityChoice>,
    #[yaserde(rename = "QtyAsDSS")]
    #[cfg_attr(feature = "serde", serde(rename = "QtyAsDSS"))]
    pub qty_as_d_s_s: Option<GenericIdentification6>,
}

impl Validate for BalanceQuantity1Choice {}

pub mod balance_quantity_1_choice {
    use super::*;
}

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

impl Validate for BaseOneRate {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct 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(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:semt.004.001.02")]
pub struct CustodyStatementOfHoldings2 {
    #[yaserde(rename = "StmtGnlDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "StmtGnlDtls"))]
    pub stmt_gnl_dtls: Statement7,

    #[yaserde(rename = "AcctDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctDtls"))]
    pub acct_dtls: SafekeepingAccount2,

    #[yaserde(rename = "BalForAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "BalForAcct"))]
    pub bal_for_acct: Vec<AggregateBalanceInformation4>,

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

    #[yaserde(rename = "TtlVals")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlVals"))]
    pub ttl_vals: TotalValueInPageAndStatement,

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

impl Validate for CustodyStatementOfHoldings2 {}


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

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

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

    #[yaserde(rename = "StmtToBeCanc")]
    #[cfg_attr(feature = "serde", serde(rename = "StmtToBeCanc"))]
    pub stmt_to_be_canc: CustodyStatementOfHoldings2,
}

impl Validate for CustodyStatementOfHoldingsCancellationV02 {}


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

pub mod date_and_date_time_choice {
    use super::*;
}

#[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.004.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.004.001.02")]
pub struct Document {
    #[yaserde(rename = "CtdyStmtOfHldgsCxlV02")]
    #[cfg_attr(feature = "serde", serde(rename = "CtdyStmtOfHldgsCxlV02"))]
    pub ctdy_stmt_of_hldgs_cxl_v02: CustodyStatementOfHoldingsCancellationV02,
}

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.004.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.004.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.004.001.02")]
pub struct FinancialInstrument13 {
    #[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 = "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,
}

impl Validate for FinancialInstrument13 {}


#[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.004.001.02")]
pub struct FinancialInstrumentQuantityChoice {
    #[yaserde(rename = "Unit")]
    #[cfg_attr(feature = "serde", serde(rename = "Unit"))]
    pub unit: Option<DecimalNumber>,
    #[yaserde(rename = "FaceAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "FaceAmt"))]
    pub face_amt: Option<ImpliedCurrencyAndAmount>,
    #[yaserde(rename = "AmtsdVal")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtsdVal"))]
    pub amtsd_val: Option<ImpliedCurrencyAndAmount>,
}

impl Validate for FinancialInstrumentQuantityChoice {}

pub mod financial_instrument_quantity_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:semt.004.001.02")]
pub struct ForeignExchangeTerms6 {
    #[yaserde(rename = "UnitCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitCcy"))]
    pub unit_ccy: ActiveOrHistoricCurrencyCode,

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

    #[yaserde(rename = "XchgRate")]
    #[cfg_attr(feature = "serde", serde(rename = "XchgRate"))]
    pub xchg_rate: BaseOneRate,

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

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

impl Validate for ForeignExchangeTerms6 {}


#[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.004.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.004.001.02")]
pub struct FrequencyCodeAndDSSCode1Choice {
    #[yaserde(rename = "FrqcyAsCd")]
    #[cfg_attr(feature = "serde", serde(rename = "FrqcyAsCd"))]
    pub frqcy_as_cd: Option<EventFrequency1Code>,
    #[yaserde(rename = "FrqcyAsDSS")]
    #[cfg_attr(feature = "serde", serde(rename = "FrqcyAsDSS"))]
    pub frqcy_as_d_s_s: Option<GenericIdentification7>,
}

impl Validate for FrequencyCodeAndDSSCode1Choice {}

pub mod frequency_code_and_dss_code_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:semt.004.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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.004.001.02")]
pub struct GenericIdentification5 {
    #[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,

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

impl Validate for GenericIdentification5 {}


#[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.004.001.02")]
pub struct GenericIdentification6 {
    #[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,

    #[yaserde(rename = "Bal")]
    #[cfg_attr(feature = "serde", serde(rename = "Bal"))]
    pub bal: Number,
}

impl Validate for GenericIdentification6 {}


#[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.004.001.02")]
pub struct GenericIdentification7 {
    #[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: Max35Text,
}

impl Validate for GenericIdentification7 {}


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

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

pub mod long_postal_address_1_choice {
    use super::*;
}

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

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

pub mod party_identification_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:semt.004.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 {}

pub mod party_identification_2_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:semt.004.001.02")]
pub struct PartyIdentification3 {
    #[yaserde(rename = "BICOrBEI")]
    #[cfg_attr(feature = "serde", serde(rename = "BICOrBEI"))]
    pub bic_or_bei: AnyBICIdentifier,
}

impl Validate for PartyIdentification3 {}


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

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

impl Validate for PlusOrMinusIndicator {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.004.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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.004.001.02")]
pub struct PriceInformation2 {
    #[yaserde(rename = "Val")]
    #[cfg_attr(feature = "serde", serde(rename = "Val"))]
    pub val: PriceRateOrAmountOrUnknownChoice,

    #[yaserde(rename = "ValTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ValTp"))]
    pub val_tp: PriceValueType2Code,

    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: Option<TypeOfPrice11Code>,
    #[yaserde(rename = "XtndedTp")]
    #[cfg_attr(feature = "serde", serde(rename = "XtndedTp"))]
    pub xtnded_tp: Option<Extended350Code>,

    #[yaserde(rename = "SrcOfPric")]
    #[cfg_attr(feature = "serde", serde(rename = "SrcOfPric"))]
    pub src_of_pric: PriceSourceFormatChoice,

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

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

impl Validate for PriceInformation2 {}

pub mod price_information_2 {
    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.004.001.02")]
pub struct PriceRateOrAmountOrUnknownChoice {
    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: Option<PercentageRate>,
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<ActiveOrHistoricCurrencyAnd13DecimalAmount>,
    #[yaserde(rename = "UknwnInd")]
    #[cfg_attr(feature = "serde", serde(rename = "UknwnInd"))]
    pub uknwn_ind: Option<YesNoIndicator>,
}

impl Validate for PriceRateOrAmountOrUnknownChoice {}

pub mod price_rate_or_amount_or_unknown_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:semt.004.001.02")]
pub struct PriceSource {
    #[yaserde(rename = "PricSrc")]
    #[cfg_attr(feature = "serde", serde(rename = "PricSrc"))]
    pub pric_src: PriceSource1Code,

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

impl Validate for PriceSource {}


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

pub enum PriceSource1Code {
    #[yaserde(rename = "FUND")]
    #[cfg_attr(feature = "serde", serde(rename = "FUND"))]
    Fund,
    #[yaserde(rename = "THEO")]
    #[cfg_attr(feature = "serde", serde(rename = "THEO"))]
    Theo,
    #[yaserde(rename = "VEND")]
    #[cfg_attr(feature = "serde", serde(rename = "VEND"))]
    Vend,
    __Unknown__(String),
}

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

impl Validate for PriceSource1Code {}



#[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.004.001.02")]
pub struct PriceSourceFormatChoice {
    #[yaserde(rename = "LclMktPlc")]
    #[cfg_attr(feature = "serde", serde(rename = "LclMktPlc"))]
    pub lcl_mkt_plc: Option<Micidentifier>,
    #[yaserde(rename = "NonLclMktPlc")]
    #[cfg_attr(feature = "serde", serde(rename = "NonLclMktPlc"))]
    pub non_lcl_mkt_plc: Option<PriceSource>,
    #[yaserde(rename = "PlcAsDSS")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcAsDSS"))]
    pub plc_as_d_s_s: Option<GenericIdentification5>,
}

impl Validate for PriceSourceFormatChoice {}

pub mod price_source_format_choice {
    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:semt.004.001.02")]

pub enum PriceValueType2Code {
    #[yaserde(rename = "DISC")]
    #[cfg_attr(feature = "serde", serde(rename = "DISC"))]
    Disc,
    #[yaserde(rename = "PREM")]
    #[cfg_attr(feature = "serde", serde(rename = "PREM"))]
    Prem,
    __Unknown__(String),
}

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

impl Validate for PriceValueType2Code {}



#[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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.004.001.02")]
pub struct QuantityAndAvailability {
    #[yaserde(rename = "Qty")]
    #[cfg_attr(feature = "serde", serde(rename = "Qty"))]
    pub qty: FinancialInstrumentQuantityChoice,

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

impl Validate for QuantityAndAvailability {}


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

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

    #[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 = "AcctOwnr")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctOwnr"))]
    pub acct_ownr: PartyIdentification2Choice,

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

impl Validate for SafekeepingAccount2 {}


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

pub enum SafekeepingPlace1Code {
    #[yaserde(rename = "CUST")]
    #[cfg_attr(feature = "serde", serde(rename = "CUST"))]
    Cust,
    #[yaserde(rename = "ICSD")]
    #[cfg_attr(feature = "serde", serde(rename = "ICSD"))]
    Icsd,
    #[yaserde(rename = "NCSD")]
    #[cfg_attr(feature = "serde", serde(rename = "NCSD"))]
    Ncsd,
    #[yaserde(rename = "SHHE")]
    #[cfg_attr(feature = "serde", serde(rename = "SHHE"))]
    Shhe,
    __Unknown__(String),
}

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

impl Validate for SafekeepingPlace1Code {}



#[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.004.001.02")]
pub struct SafekeepingPlaceAsCodeAndPartyIdentification {
    #[yaserde(rename = "PlcSfkpg")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcSfkpg"))]
    pub plc_sfkpg: SafekeepingPlace1Code,

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

    #[yaserde(rename = "Pty")]
    #[cfg_attr(feature = "serde", serde(rename = "Pty"))]
    pub pty: PartyIdentification3,
}

impl Validate for SafekeepingPlaceAsCodeAndPartyIdentification {}


#[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.004.001.02")]
pub struct SafekeepingPlaceFormatChoice {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Option<SafekeepingPlaceAsCodeAndPartyIdentification>,
    #[yaserde(rename = "IdAsDSS")]
    #[cfg_attr(feature = "serde", serde(rename = "IdAsDSS"))]
    pub id_as_d_s_s: Option<GenericIdentification5>,
    #[yaserde(rename = "IdAsCtry")]
    #[cfg_attr(feature = "serde", serde(rename = "IdAsCtry"))]
    pub id_as_ctry: Option<CountryCode>,
}

impl Validate for SafekeepingPlaceFormatChoice {}

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

pub enum SecuritiesBalanceType1Code {
    #[yaserde(rename = "BLOK")]
    #[cfg_attr(feature = "serde", serde(rename = "BLOK"))]
    Blok,
    #[yaserde(rename = "BORR")]
    #[cfg_attr(feature = "serde", serde(rename = "BORR"))]
    Borr,
    #[yaserde(rename = "COLI")]
    #[cfg_attr(feature = "serde", serde(rename = "COLI"))]
    Coli,
    #[yaserde(rename = "COLO")]
    #[cfg_attr(feature = "serde", serde(rename = "COLO"))]
    Colo,
    #[yaserde(rename = "LOAN")]
    #[cfg_attr(feature = "serde", serde(rename = "LOAN"))]
    Loan,
    #[yaserde(rename = "MARG")]
    #[cfg_attr(feature = "serde", serde(rename = "MARG"))]
    Marg,
    #[yaserde(rename = "PDMT")]
    #[cfg_attr(feature = "serde", serde(rename = "PDMT"))]
    Pdmt,
    #[yaserde(rename = "PRMT")]
    #[cfg_attr(feature = "serde", serde(rename = "PRMT"))]
    Prmt,
    #[yaserde(rename = "PRUM")]
    #[cfg_attr(feature = "serde", serde(rename = "PRUM"))]
    Prum,
    #[yaserde(rename = "PECA")]
    #[cfg_attr(feature = "serde", serde(rename = "PECA"))]
    Peca,
    #[yaserde(rename = "PEND")]
    #[cfg_attr(feature = "serde", serde(rename = "PEND"))]
    Pend,
    #[yaserde(rename = "PENR")]
    #[cfg_attr(feature = "serde", serde(rename = "PENR"))]
    Penr,
    #[yaserde(rename = "PLED")]
    #[cfg_attr(feature = "serde", serde(rename = "PLED"))]
    Pled,
    #[yaserde(rename = "PDUM")]
    #[cfg_attr(feature = "serde", serde(rename = "PDUM"))]
    Pdum,
    #[yaserde(rename = "REGO")]
    #[cfg_attr(feature = "serde", serde(rename = "REGO"))]
    Rego,
    #[yaserde(rename = "RSTR")]
    #[cfg_attr(feature = "serde", serde(rename = "RSTR"))]
    Rstr,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "TRAN")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAN"))]
    Tran,
    #[yaserde(rename = "DRAW")]
    #[cfg_attr(feature = "serde", serde(rename = "DRAW"))]
    Draw,
    #[yaserde(rename = "WDOC")]
    #[cfg_attr(feature = "serde", serde(rename = "WDOC"))]
    Wdoc,
    #[yaserde(rename = "BTRA")]
    #[cfg_attr(feature = "serde", serde(rename = "BTRA"))]
    Btra,
    __Unknown__(String),
}

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

impl Validate for SecuritiesBalanceType1Code {}



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

pub enum SecuritiesBalanceType2Code {
    #[yaserde(rename = "CLEN")]
    #[cfg_attr(feature = "serde", serde(rename = "CLEN"))]
    Clen,
    #[yaserde(rename = "DIRT")]
    #[cfg_attr(feature = "serde", serde(rename = "DIRT"))]
    Dirt,
    #[yaserde(rename = "NOMI")]
    #[cfg_attr(feature = "serde", serde(rename = "NOMI"))]
    Nomi,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "SPOS")]
    #[cfg_attr(feature = "serde", serde(rename = "SPOS"))]
    Spos,
    #[yaserde(rename = "UNRG")]
    #[cfg_attr(feature = "serde", serde(rename = "UNRG"))]
    Unrg,
    __Unknown__(String),
}

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

impl Validate for SecuritiesBalanceType2Code {}



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

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

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

    #[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: FrequencyCodeAndDSSCode1Choice,

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

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

    #[yaserde(rename = "StmtBsis")]
    #[cfg_attr(feature = "serde", serde(rename = "StmtBsis"))]
    pub stmt_bsis: StatementBasisCodeAndDSSCodeChoice,

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

impl Validate for Statement7 {}


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

pub enum StatementBasis1Code {
    #[yaserde(rename = "CONT")]
    #[cfg_attr(feature = "serde", serde(rename = "CONT"))]
    Cont,
    #[yaserde(rename = "SETT")]
    #[cfg_attr(feature = "serde", serde(rename = "SETT"))]
    Sett,
    #[yaserde(rename = "TRAD")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAD"))]
    Trad,
    __Unknown__(String),
}

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

impl Validate for StatementBasis1Code {}



#[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.004.001.02")]
pub struct StatementBasisCodeAndDSSCodeChoice {
    #[yaserde(rename = "StmtBsisAsCd")]
    #[cfg_attr(feature = "serde", serde(rename = "StmtBsisAsCd"))]
    pub stmt_bsis_as_cd: Option<StatementBasis1Code>,
    #[yaserde(rename = "StmtBsisAsDSS")]
    #[cfg_attr(feature = "serde", serde(rename = "StmtBsisAsDSS"))]
    pub stmt_bsis_as_d_s_s: Option<GenericIdentification7>,
}

impl Validate for StatementBasisCodeAndDSSCodeChoice {}

pub mod statement_basis_code_and_dss_code_choice {
    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:semt.004.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.004.001.02")]
pub struct StatementUpdateTypeCodeAndDSSCodeChoice {
    #[yaserde(rename = "StmtUpdTpAsCd")]
    #[cfg_attr(feature = "serde", serde(rename = "StmtUpdTpAsCd"))]
    pub stmt_upd_tp_as_cd: Option<StatementUpdateTypeCode>,
    #[yaserde(rename = "StmtUpdTpAsDSS")]
    #[cfg_attr(feature = "serde", serde(rename = "StmtUpdTpAsDSS"))]
    pub stmt_upd_tp_as_d_s_s: Option<GenericIdentification7>,
}

impl Validate for StatementUpdateTypeCodeAndDSSCodeChoice {}

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

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

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

    #[yaserde(rename = "BalForSubAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "BalForSubAcct"))]
    pub bal_for_sub_acct: Vec<AggregateBalanceInformation4>,
}

impl Validate for SubAccountIdentification5 {}


#[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.004.001.02")]
pub struct SubBalanceInformation2 {
    #[yaserde(rename = "Qty")]
    #[cfg_attr(feature = "serde", serde(rename = "Qty"))]
    pub qty: SubBalanceQuantity1Choice,

    #[yaserde(rename = "SubBalTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SubBalTp"))]
    pub sub_bal_tp: Option<SecuritiesBalanceType1Code>,
    #[yaserde(rename = "XtndedSubBalTp")]
    #[cfg_attr(feature = "serde", serde(rename = "XtndedSubBalTp"))]
    pub xtnded_sub_bal_tp: Option<Extended350Code>,

    #[yaserde(rename = "AddtlBalBrkdwnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlBalBrkdwnDtls"))]
    pub addtl_bal_brkdwn_dtls: Vec<AdditionalBalanceInformation2>,
}

impl Validate for SubBalanceInformation2 {}

pub mod sub_balance_information_2 {
    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.004.001.02")]
pub struct SubBalanceQuantity1Choice {
    #[yaserde(rename = "Qty")]
    #[cfg_attr(feature = "serde", serde(rename = "Qty"))]
    pub qty: Option<FinancialInstrumentQuantityChoice>,
    #[yaserde(rename = "QtyAsDSS")]
    #[cfg_attr(feature = "serde", serde(rename = "QtyAsDSS"))]
    pub qty_as_d_s_s: Option<GenericIdentification6>,
    #[yaserde(rename = "QtyAndAvlbty")]
    #[cfg_attr(feature = "serde", serde(rename = "QtyAndAvlbty"))]
    pub qty_and_avlbty: Option<QuantityAndAvailability>,
}

impl Validate for SubBalanceQuantity1Choice {}

pub mod sub_balance_quantity_1_choice {
    use super::*;
}

#[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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.004.001.02")]
pub struct TotalValueInPageAndStatement {
    #[yaserde(rename = "TtlHldgsValOfPg")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlHldgsValOfPg"))]
    pub ttl_hldgs_val_of_pg: ActiveCurrencyAndAmount,

    #[yaserde(rename = "TtlHldgsValOfStmt")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlHldgsValOfStmt"))]
    pub ttl_hldgs_val_of_stmt: ActiveCurrencyAndAmount,
}

impl Validate for TotalValueInPageAndStatement {}


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

pub enum TypeOfPrice11Code {
    #[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 = "MRKT")]
    #[cfg_attr(feature = "serde", serde(rename = "MRKT"))]
    Mrkt,
    #[yaserde(rename = "INDC")]
    #[cfg_attr(feature = "serde", serde(rename = "INDC"))]
    Indc,
    __Unknown__(String),
}

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

impl Validate for TypeOfPrice11Code {}



#[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 = "004";
    const VARIANT: &'static str = "001";
    const VERSION: &'static str = "02";
    const MESSAGE_NAME: &'static str = "semt.004.001.02";
    const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:semt.004.001.02";
}