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

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

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

impl Validate for AccountIdentification5 {}


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

impl Validate for ActiveOrHistoricCurrencyAndAmount {}


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

impl Validate for ActiveOrHistoricCurrencyCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.024.001.01")]
pub struct AmountAndDirection30 {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: ActiveOrHistoricCurrencyAndAmount,

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

impl Validate for AmountAndDirection30 {}


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

    #[yaserde(rename = "ShrtLngInd")]
    #[cfg_attr(feature = "serde", serde(rename = "ShrtLngInd"))]
    pub shrt_lng_ind: ShortLong1Code,
}

impl Validate for AmountAndDirection31 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.024.001.01")]
pub struct AmountAndRate2 {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: AmountAndDirection30,

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

impl Validate for AmountAndRate2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.024.001.01")]
pub struct BalanceDetails5 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: BalanceType6Choice,

    #[yaserde(rename = "Urlsd")]
    #[cfg_attr(feature = "serde", serde(rename = "Urlsd"))]
    pub urlsd: Unrealised1Code,

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

    #[yaserde(rename = "DtldBal")]
    #[cfg_attr(feature = "serde", serde(rename = "DtldBal"))]
    pub dtld_bal: Vec<BalanceDetails6>,
}

impl Validate for BalanceDetails5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.024.001.01")]
pub struct BalanceDetails6 {
    #[yaserde(rename = "Ctgy")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctgy"))]
    pub ctgy: FinancialAssetTypeCategory1Code,

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

    #[yaserde(rename = "Urlsd")]
    #[cfg_attr(feature = "serde", serde(rename = "Urlsd"))]
    pub urlsd: Unrealised1Code,

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

impl Validate for BalanceDetails6 {}


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

pub enum BalanceType13Code {
    #[yaserde(rename = "INVE")]
    #[cfg_attr(feature = "serde", serde(rename = "INVE"))]
    Inve,
    #[yaserde(rename = "CASE")]
    #[cfg_attr(feature = "serde", serde(rename = "CASE"))]
    Case,
    #[yaserde(rename = "BORR")]
    #[cfg_attr(feature = "serde", serde(rename = "BORR"))]
    Borr,
    #[yaserde(rename = "REVE")]
    #[cfg_attr(feature = "serde", serde(rename = "REVE"))]
    Reve,
    #[yaserde(rename = "EXPN")]
    #[cfg_attr(feature = "serde", serde(rename = "EXPN"))]
    Expn,
    #[yaserde(rename = "IIOF")]
    #[cfg_attr(feature = "serde", serde(rename = "IIOF"))]
    Iiof,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "PAYA")]
    #[cfg_attr(feature = "serde", serde(rename = "PAYA"))]
    Paya,
    #[yaserde(rename = "RECE")]
    #[cfg_attr(feature = "serde", serde(rename = "RECE"))]
    Rece,
    __Unknown__(String),
}

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

impl Validate for BalanceType13Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.024.001.01")]
pub struct BalanceType6Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<BalanceType13Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification30>,
}

impl Validate for BalanceType6Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.024.001.01")]
pub struct BalanceType7Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<FinancialAssetBalanceType1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification30>,
    #[yaserde(rename = "Acct")]
    #[cfg_attr(feature = "serde", serde(rename = "Acct"))]
    pub acct: Option<AccountIdentification5>,
}

impl Validate for BalanceType7Choice {}




#[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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.024.001.01")]
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.024.001.01")]
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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.024.001.01")]
pub struct Document {
    #[yaserde(rename = "TtlPrtflValtnRpt")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlPrtflValtnRpt"))]
    pub ttl_prtfl_valtn_rpt: TotalPortfolioValuationReportV01,
}

impl Validate for Document {}


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

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

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

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

pub enum FinancialAssetBalanceType1Code {
    #[yaserde(rename = "ACRU")]
    #[cfg_attr(feature = "serde", serde(rename = "ACRU"))]
    Acru,
    #[yaserde(rename = "OINT")]
    #[cfg_attr(feature = "serde", serde(rename = "OINT"))]
    Oint,
    #[yaserde(rename = "SCAS")]
    #[cfg_attr(feature = "serde", serde(rename = "SCAS"))]
    Scas,
    #[yaserde(rename = "FXTR")]
    #[cfg_attr(feature = "serde", serde(rename = "FXTR"))]
    Fxtr,
    #[yaserde(rename = "CASH")]
    #[cfg_attr(feature = "serde", serde(rename = "CASH"))]
    Cash,
    #[yaserde(rename = "TIPS")]
    #[cfg_attr(feature = "serde", serde(rename = "TIPS"))]
    Tips,
    #[yaserde(rename = "EQUI")]
    #[cfg_attr(feature = "serde", serde(rename = "EQUI"))]
    Equi,
    #[yaserde(rename = "CSTK")]
    #[cfg_attr(feature = "serde", serde(rename = "CSTK"))]
    Cstk,
    #[yaserde(rename = "PREF")]
    #[cfg_attr(feature = "serde", serde(rename = "PREF"))]
    Pref,
    #[yaserde(rename = "MFUN")]
    #[cfg_attr(feature = "serde", serde(rename = "MFUN"))]
    Mfun,
    #[yaserde(rename = "XFUN")]
    #[cfg_attr(feature = "serde", serde(rename = "XFUN"))]
    Xfun,
    #[yaserde(rename = "RGHT")]
    #[cfg_attr(feature = "serde", serde(rename = "RGHT"))]
    Rght,
    #[yaserde(rename = "WARR")]
    #[cfg_attr(feature = "serde", serde(rename = "WARR"))]
    Warr,
    #[yaserde(rename = "BOND")]
    #[cfg_attr(feature = "serde", serde(rename = "BOND"))]
    Bond,
    #[yaserde(rename = "CONV")]
    #[cfg_attr(feature = "serde", serde(rename = "CONV"))]
    Conv,
    #[yaserde(rename = "CBND")]
    #[cfg_attr(feature = "serde", serde(rename = "CBND"))]
    Cbnd,
    #[yaserde(rename = "GBND")]
    #[cfg_attr(feature = "serde", serde(rename = "GBND"))]
    Gbnd,
    #[yaserde(rename = "OPTN")]
    #[cfg_attr(feature = "serde", serde(rename = "OPTN"))]
    Optn,
    #[yaserde(rename = "FUTR")]
    #[cfg_attr(feature = "serde", serde(rename = "FUTR"))]
    Futr,
    #[yaserde(rename = "SWAP")]
    #[cfg_attr(feature = "serde", serde(rename = "SWAP"))]
    Swap,
    #[yaserde(rename = "CUEX")]
    #[cfg_attr(feature = "serde", serde(rename = "CUEX"))]
    Cuex,
    #[yaserde(rename = "FOIV")]
    #[cfg_attr(feature = "serde", serde(rename = "FOIV"))]
    Foiv,
    #[yaserde(rename = "GOLD")]
    #[cfg_attr(feature = "serde", serde(rename = "GOLD"))]
    Gold,
    #[yaserde(rename = "PROP")]
    #[cfg_attr(feature = "serde", serde(rename = "PROP"))]
    Prop,
    #[yaserde(rename = "BAAP")]
    #[cfg_attr(feature = "serde", serde(rename = "BAAP"))]
    Baap,
    #[yaserde(rename = "SYBL")]
    #[cfg_attr(feature = "serde", serde(rename = "SYBL"))]
    Sybl,
    #[yaserde(rename = "CBOO")]
    #[cfg_attr(feature = "serde", serde(rename = "CBOO"))]
    Cboo,
    #[yaserde(rename = "CEOD")]
    #[cfg_attr(feature = "serde", serde(rename = "CEOD"))]
    Ceod,
    #[yaserde(rename = "CDEO")]
    #[cfg_attr(feature = "serde", serde(rename = "CDEO"))]
    Cdeo,
    #[yaserde(rename = "CLOB")]
    #[cfg_attr(feature = "serde", serde(rename = "CLOB"))]
    Clob,
    #[yaserde(rename = "CMOO")]
    #[cfg_attr(feature = "serde", serde(rename = "CMOO"))]
    Cmoo,
    #[yaserde(rename = "COPR")]
    #[cfg_attr(feature = "serde", serde(rename = "COPR"))]
    Copr,
    #[yaserde(rename = "CPPE")]
    #[cfg_attr(feature = "serde", serde(rename = "CPPE"))]
    Cppe,
    #[yaserde(rename = "DISC")]
    #[cfg_attr(feature = "serde", serde(rename = "DISC"))]
    Disc,
    #[yaserde(rename = "FEAD")]
    #[cfg_attr(feature = "serde", serde(rename = "FEAD"))]
    Fead,
    #[yaserde(rename = "FEHA")]
    #[cfg_attr(feature = "serde", serde(rename = "FEHA"))]
    Feha,
    #[yaserde(rename = "FEHL")]
    #[cfg_attr(feature = "serde", serde(rename = "FEHL"))]
    Fehl,
    #[yaserde(rename = "FNMA")]
    #[cfg_attr(feature = "serde", serde(rename = "FNMA"))]
    Fnma,
    #[yaserde(rename = "FLNO")]
    #[cfg_attr(feature = "serde", serde(rename = "FLNO"))]
    Flno,
    #[yaserde(rename = "GNMA")]
    #[cfg_attr(feature = "serde", serde(rename = "GNMA"))]
    Gnma,
    #[yaserde(rename = "TAAB")]
    #[cfg_attr(feature = "serde", serde(rename = "TAAB"))]
    Taab,
    #[yaserde(rename = "IETM")]
    #[cfg_attr(feature = "serde", serde(rename = "IETM"))]
    Ietm,
    #[yaserde(rename = "MPRP")]
    #[cfg_attr(feature = "serde", serde(rename = "MPRP"))]
    Mprp,
    #[yaserde(rename = "MBON")]
    #[cfg_attr(feature = "serde", serde(rename = "MBON"))]
    Mbon,
    #[yaserde(rename = "SLMA")]
    #[cfg_attr(feature = "serde", serde(rename = "SLMA"))]
    Slma,
    #[yaserde(rename = "STIF")]
    #[cfg_attr(feature = "serde", serde(rename = "STIF"))]
    Stif,
    #[yaserde(rename = "TSTP")]
    #[cfg_attr(feature = "serde", serde(rename = "TSTP"))]
    Tstp,
    #[yaserde(rename = "TIDE")]
    #[cfg_attr(feature = "serde", serde(rename = "TIDE"))]
    Tide,
    #[yaserde(rename = "UNBW")]
    #[cfg_attr(feature = "serde", serde(rename = "UNBW"))]
    Unbw,
    #[yaserde(rename = "UNBO")]
    #[cfg_attr(feature = "serde", serde(rename = "UNBO"))]
    Unbo,
    #[yaserde(rename = "VRDN")]
    #[cfg_attr(feature = "serde", serde(rename = "VRDN"))]
    Vrdn,
    #[yaserde(rename = "ZOOO")]
    #[cfg_attr(feature = "serde", serde(rename = "ZOOO"))]
    Zooo,
    #[yaserde(rename = "FWBO")]
    #[cfg_attr(feature = "serde", serde(rename = "FWBO"))]
    Fwbo,
    #[yaserde(rename = "FRAG")]
    #[cfg_attr(feature = "serde", serde(rename = "FRAG"))]
    Frag,
    #[yaserde(rename = "REPO")]
    #[cfg_attr(feature = "serde", serde(rename = "REPO"))]
    Repo,
    #[yaserde(rename = "XREP")]
    #[cfg_attr(feature = "serde", serde(rename = "XREP"))]
    Xrep,
    #[yaserde(rename = "TREP")]
    #[cfg_attr(feature = "serde", serde(rename = "TREP"))]
    Trep,
    #[yaserde(rename = "RXRP")]
    #[cfg_attr(feature = "serde", serde(rename = "RXRP"))]
    Rxrp,
    #[yaserde(rename = "FXFD")]
    #[cfg_attr(feature = "serde", serde(rename = "FXFD"))]
    Fxfd,
    #[yaserde(rename = "FXSP")]
    #[cfg_attr(feature = "serde", serde(rename = "FXSP"))]
    Fxsp,
    __Unknown__(String),
}

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

impl Validate for FinancialAssetBalanceType1Code {}



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

pub enum FinancialAssetTypeCategory1Code {
    #[yaserde(rename = "EQTY")]
    #[cfg_attr(feature = "serde", serde(rename = "EQTY"))]
    Eqty,
    #[yaserde(rename = "DEBT")]
    #[cfg_attr(feature = "serde", serde(rename = "DEBT"))]
    Debt,
    #[yaserde(rename = "ENTL")]
    #[cfg_attr(feature = "serde", serde(rename = "ENTL"))]
    Entl,
    #[yaserde(rename = "DERV")]
    #[cfg_attr(feature = "serde", serde(rename = "DERV"))]
    Derv,
    #[yaserde(rename = "MMKT")]
    #[cfg_attr(feature = "serde", serde(rename = "MMKT"))]
    Mmkt,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    __Unknown__(String),
}

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

impl Validate for FinancialAssetTypeCategory1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.024.001.01")]
pub struct Frequency8Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<EventFrequency1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification30>,
}

impl Validate for Frequency8Choice {}




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

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

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

impl Validate for GenericIdentification29 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.024.001.01")]
pub struct GenericIdentification30 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Exact4AlphaNumericText,

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

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

impl Validate for GenericIdentification30 {}


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

impl Validate for IdentificationSource3Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.024.001.01")]
pub struct InvestmentFund1 {
    #[yaserde(rename = "FinInstrmId")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrmId"))]
    pub fin_instrm_id: SecurityIdentification14,

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

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

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

    #[yaserde(rename = "TtlVal")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlVal"))]
    pub ttl_val: AmountAndDirection30,

    #[yaserde(rename = "Pric")]
    #[cfg_attr(feature = "serde", serde(rename = "Pric"))]
    pub pric: Vec<PriceInformation10>,

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

impl Validate for InvestmentFund1 {}


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

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

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

impl Validate for OtherIdentification1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.024.001.01")]
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)]
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.024.001.01")]
pub struct PortfolioBalance1 {
    #[yaserde(rename = "SummryBal")]
    #[cfg_attr(feature = "serde", serde(rename = "SummryBal"))]
    pub summry_bal: Vec<BalanceDetails5>,
    #[yaserde(rename = "DtldBal")]
    #[cfg_attr(feature = "serde", serde(rename = "DtldBal"))]
    pub dtld_bal: Vec<BalanceDetails6>,
}

impl Validate for PortfolioBalance1 {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.024.001.01")]
pub struct PriceAndDirection1 {
    #[yaserde(rename = "Val")]
    #[cfg_attr(feature = "serde", serde(rename = "Val"))]
    pub val: ActiveOrHistoricCurrencyAnd13DecimalAmount,

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

impl Validate for PriceAndDirection1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.024.001.01")]
pub struct PriceInformation10 {
    #[yaserde(rename = "CurPric")]
    #[cfg_attr(feature = "serde", serde(rename = "CurPric"))]
    pub cur_pric: ActiveOrHistoricCurrencyAnd13DecimalAmount,

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

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

    #[yaserde(rename = "AmtOfChng")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtOfChng"))]
    pub amt_of_chng: PriceValueAndRate4,
}

impl Validate for PriceInformation10 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.024.001.01")]
pub struct PriceValueAndRate4 {
    #[yaserde(rename = "Val")]
    #[cfg_attr(feature = "serde", serde(rename = "Val"))]
    pub val: PriceAndDirection1,

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

impl Validate for PriceValueAndRate4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.024.001.01")]
pub struct Report4 {
    #[yaserde(rename = "RptNb")]
    #[cfg_attr(feature = "serde", serde(rename = "RptNb"))]
    pub rpt_nb: Max5NumericText,

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

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

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

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

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

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

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

    #[yaserde(rename = "RptBsis")]
    #[cfg_attr(feature = "serde", serde(rename = "RptBsis"))]
    pub rpt_bsis: StatementBasis6Choice,

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

    #[yaserde(rename = "RptSrc")]
    #[cfg_attr(feature = "serde", serde(rename = "RptSrc"))]
    pub rpt_src: StatementSource1Choice,

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

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

impl Validate for Report4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.024.001.01")]
pub struct SecuritiesAccount21 {
    #[yaserde(rename = "Acct")]
    #[cfg_attr(feature = "serde", serde(rename = "Acct"))]
    pub acct: AccountIdentification5,

    #[yaserde(rename = "SubAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "SubAcct"))]
    pub sub_acct: AccountIdentification5,

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

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

    #[yaserde(rename = "FXRate")]
    #[cfg_attr(feature = "serde", serde(rename = "FXRate"))]
    pub fx_rate: BaseOneRate,
}

impl Validate for SecuritiesAccount21 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.024.001.01")]
pub struct SecurityIdentification14 {
    #[yaserde(rename = "ISIN")]
    #[cfg_attr(feature = "serde", serde(rename = "ISIN"))]
    pub isin: Isinidentifier,

    #[yaserde(rename = "OthrId")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrId"))]
    pub othr_id: Vec<OtherIdentification1>,

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

impl Validate for SecurityIdentification14 {}


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

pub enum ShortLong1Code {
    #[yaserde(rename = "SHOR")]
    #[cfg_attr(feature = "serde", serde(rename = "SHOR"))]
    Shor,
    #[yaserde(rename = "LONG")]
    #[cfg_attr(feature = "serde", serde(rename = "LONG"))]
    Long,
    __Unknown__(String),
}

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

impl Validate for ShortLong1Code {}



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

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.024.001.01")]
pub struct StatementBasis6Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<StatementBasis1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification30>,
}

impl Validate for StatementBasis6Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.024.001.01")]
pub struct StatementSource1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<StatementSource1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification30>,
}

impl Validate for StatementSource1Choice {}




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

pub enum StatementSource1Code {
    #[yaserde(rename = "ACCT")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCT"))]
    Acct,
    #[yaserde(rename = "CUST")]
    #[cfg_attr(feature = "serde", serde(rename = "CUST"))]
    Cust,
    __Unknown__(String),
}

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

impl Validate for StatementSource1Code {}



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

pub enum StatementUpdateType1Code {
    #[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 StatementUpdateType1Code {
    fn default() -> StatementUpdateType1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for StatementUpdateType1Code {}



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

    #[yaserde(rename = "Envlp")]
    #[cfg_attr(feature = "serde", serde(rename = "Envlp"))]
    pub envlp: SupplementaryDataEnvelope1,
}

impl Validate for SupplementaryData1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.024.001.01")]
pub struct SupplementaryDataEnvelope1 {}

impl Validate for SupplementaryDataEnvelope1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.024.001.01")]
pub struct TotalPortfolioValuation1 {
    #[yaserde(rename = "TtlPrtflVal")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlPrtflVal"))]
    pub ttl_prtfl_val: AmountAndDirection30,

    #[yaserde(rename = "PrvsTtlPrtflVal")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvsTtlPrtflVal"))]
    pub prvs_ttl_prtfl_val: AmountAndDirection30,

    #[yaserde(rename = "TtlPrtflValChng")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlPrtflValChng"))]
    pub ttl_prtfl_val_chng: AmountAndRate2,

    #[yaserde(rename = "TtlBookVal")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlBookVal"))]
    pub ttl_book_val: AmountAndDirection30,

    #[yaserde(rename = "PrvsTtlBookVal")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvsTtlBookVal"))]
    pub prvs_ttl_book_val: AmountAndDirection30,

    #[yaserde(rename = "TtlBookValChng")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlBookValChng"))]
    pub ttl_book_val_chng: AmountAndRate2,

    #[yaserde(rename = "TtlRcts")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlRcts"))]
    pub ttl_rcts: AmountAndDirection30,

    #[yaserde(rename = "TtlDsbrsmnts")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlDsbrsmnts"))]
    pub ttl_dsbrsmnts: AmountAndDirection30,

    #[yaserde(rename = "IncmRcvd")]
    #[cfg_attr(feature = "serde", serde(rename = "IncmRcvd"))]
    pub incm_rcvd: AmountAndDirection30,

    #[yaserde(rename = "ExpnssPd")]
    #[cfg_attr(feature = "serde", serde(rename = "ExpnssPd"))]
    pub expnss_pd: AmountAndDirection30,

    #[yaserde(rename = "UrlsdGnOrLoss")]
    #[cfg_attr(feature = "serde", serde(rename = "UrlsdGnOrLoss"))]
    pub urlsd_gn_or_loss: AmountAndDirection31,

    #[yaserde(rename = "RealsdGnOrLoss")]
    #[cfg_attr(feature = "serde", serde(rename = "RealsdGnOrLoss"))]
    pub realsd_gn_or_loss: AmountAndDirection31,

    #[yaserde(rename = "AcrdIncm")]
    #[cfg_attr(feature = "serde", serde(rename = "AcrdIncm"))]
    pub acrd_incm: AmountAndDirection30,

    #[yaserde(rename = "InvstmtFndDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "InvstmtFndDtls"))]
    pub invstmt_fnd_dtls: Vec<InvestmentFund1>,
}

impl Validate for TotalPortfolioValuation1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.024.001.01")]
pub struct TotalPortfolioValuationReportV01 {
    #[yaserde(rename = "Pgntn")]
    #[cfg_attr(feature = "serde", serde(rename = "Pgntn"))]
    pub pgntn: Pagination,

    #[yaserde(rename = "RptGnlDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "RptGnlDtls"))]
    pub rpt_gnl_dtls: Report4,

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

    #[yaserde(rename = "TtlPrtflValtn")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlPrtflValtn"))]
    pub ttl_prtfl_valtn: TotalPortfolioValuation1,

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

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

impl Validate for TotalPortfolioValuationReportV01 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.024.001.01")]
pub struct TypeOfPrice27Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<TypeOfPrice30Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification29>,
}

impl Validate for TypeOfPrice27Choice {}




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

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

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

impl Validate for TypeOfPrice30Code {}



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

pub enum Unrealised1Code {
    #[yaserde(rename = "GAIN")]
    #[cfg_attr(feature = "serde", serde(rename = "GAIN"))]
    Gain,
    #[yaserde(rename = "LOSS")]
    #[cfg_attr(feature = "serde", serde(rename = "LOSS"))]
    Loss,
    __Unknown__(String),
}

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

impl Validate for Unrealised1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.024.001.01")]
pub struct UpdateType4Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<StatementUpdateType1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification30>,
}

impl Validate for UpdateType4Choice {}




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