rust_iso20022 0.1.0

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

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

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:secl.004.001.03")]
pub struct AlternatePartyIdentification4 {
    #[yaserde(rename = "IdTp")]
    #[cfg_attr(feature = "serde", serde(rename = "IdTp"))]
    pub id_tp: IdentificationType6Choice,

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

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

impl Validate for AlternatePartyIdentification4 {}


#[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:secl.004.001.03")]
pub struct AlternatePartyIdentification5 {
    #[yaserde(rename = "IdTp")]
    #[cfg_attr(feature = "serde", serde(rename = "IdTp"))]
    pub id_tp: IdentificationType40Choice,

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

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

impl Validate for AlternatePartyIdentification5 {}


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

    #[yaserde(rename = "CdtDbtInd")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtDbtInd"))]
    pub cdt_dbt_ind: CreditDebitCode,
}

impl Validate for AmountAndDirection21 {}


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

pub enum ClearingAccountType1Code {
    #[yaserde(rename = "HOUS")]
    #[cfg_attr(feature = "serde", serde(rename = "HOUS"))]
    Hous,
    #[yaserde(rename = "CLIE")]
    #[cfg_attr(feature = "serde", serde(rename = "CLIE"))]
    Clie,
    #[yaserde(rename = "LIPR")]
    #[cfg_attr(feature = "serde", serde(rename = "LIPR"))]
    Lipr,
    __Unknown__(String),
}

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

impl Validate for ClearingAccountType1Code {}



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

impl Validate for CountryCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:secl.004.001.03")]

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

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

impl Validate for CreditDebitCode {}



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

impl Validate for CurrencyCode {}
#[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:secl.004.001.03")]
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:secl.004.001.03")]
pub struct DateCode3Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<DateType1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification20>,
}

impl Validate for DateCode3Choice {}
#[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:secl.004.001.03")]
pub struct DateFormat15Choice {
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Option<Isodate>,
    #[yaserde(rename = "DtCd")]
    #[cfg_attr(feature = "serde", serde(rename = "DtCd"))]
    pub dt_cd: Option<DateCode3Choice>,
}

impl Validate for DateFormat15Choice {}




#[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:secl.004.001.03")]

pub enum DateType1Code {
    #[yaserde(rename = "UKWN")]
    #[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
    Ukwn,
    __Unknown__(String),
}

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

impl Validate for DateType1Code {}



#[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:secl.004.001.03")]
pub struct Document {
    #[yaserde(rename = "NetPos")]
    #[cfg_attr(feature = "serde", serde(rename = "NetPos"))]
    pub net_pos: NetPositionV03,
}

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:secl.004.001.03")]

pub enum EventFrequency6Code {
    #[yaserde(rename = "DAIL")]
    #[cfg_attr(feature = "serde", serde(rename = "DAIL"))]
    Dail,
    #[yaserde(rename = "INDA")]
    #[cfg_attr(feature = "serde", serde(rename = "INDA"))]
    Inda,
    #[yaserde(rename = "ONDE")]
    #[cfg_attr(feature = "serde", serde(rename = "ONDE"))]
    Onde,
    __Unknown__(String),
}

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

impl Validate for EventFrequency6Code {}



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

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

impl Validate for ExternalFinancialInstrumentIdentificationType1Code {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 4 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 4 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:secl.004.001.03")]
pub struct FinancialInstrumentQuantity1Choice {
    #[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 FinancialInstrumentQuantity1Choice {}




#[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:secl.004.001.03")]
pub struct GenericIdentification20 {
    #[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 GenericIdentification20 {}


#[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:secl.004.001.03")]
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:secl.004.001.03")]
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:secl.004.001.03")]
pub struct GenericIdentification40 {
    #[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 GenericIdentification40 {}


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

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

impl Validate for GenericIdentification58 {}


#[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:secl.004.001.03")]
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:secl.004.001.03")]
pub struct IdentificationType40Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<TypeOfIdentification2Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification29>,
}

impl Validate for IdentificationType40Choice {}
#[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:secl.004.001.03")]
pub struct IdentificationType6Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<TypeOfIdentification1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification30>,
}

impl Validate for IdentificationType6Choice {}




#[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)]
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:secl.004.001.03")]
pub struct MarketIdentification1Choice {
    #[yaserde(rename = "MktIdrCd")]
    #[cfg_attr(feature = "serde", serde(rename = "MktIdrCd"))]
    pub mkt_idr_cd: Option<Micidentifier>,
    #[yaserde(rename = "Desc")]
    #[cfg_attr(feature = "serde", serde(rename = "Desc"))]
    pub desc: Option<Max35Text>,
}

impl Validate for MarketIdentification1Choice {}




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

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

impl Validate for MarketIdentification20 {}


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

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

impl Validate for MarketIdentification84 {}


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

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

impl Validate for MarketIdentification85 {}


#[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:secl.004.001.03")]

pub enum MarketType2Code {
    #[yaserde(rename = "PRIM")]
    #[cfg_attr(feature = "serde", serde(rename = "PRIM"))]
    Prim,
    #[yaserde(rename = "SECM")]
    #[cfg_attr(feature = "serde", serde(rename = "SECM"))]
    Secm,
    #[yaserde(rename = "OTCO")]
    #[cfg_attr(feature = "serde", serde(rename = "OTCO"))]
    Otco,
    #[yaserde(rename = "VARI")]
    #[cfg_attr(feature = "serde", serde(rename = "VARI"))]
    Vari,
    #[yaserde(rename = "EXCH")]
    #[cfg_attr(feature = "serde", serde(rename = "EXCH"))]
    Exch,
    __Unknown__(String),
}

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

impl Validate for MarketType2Code {}



#[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:secl.004.001.03")]

pub enum MarketType5Code {
    #[yaserde(rename = "OTCO")]
    #[cfg_attr(feature = "serde", serde(rename = "OTCO"))]
    Otco,
    #[yaserde(rename = "EXCH")]
    #[cfg_attr(feature = "serde", serde(rename = "EXCH"))]
    Exch,
    __Unknown__(String),
}

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

impl Validate for MarketType5Code {}
#[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:secl.004.001.03")]
pub struct MarketType8Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<MarketType2Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification30>,
}

impl Validate for MarketType8Choice {}
#[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:secl.004.001.03")]
pub struct MarketType9Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<MarketType5Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification30>,
}

impl Validate for MarketType9Choice {}




#[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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:secl.004.001.03")]
pub struct NameAndAddress13 {
    #[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: PostalAddress8,
}

impl Validate for NameAndAddress13 {}


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

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

impl Validate for NameAndAddress5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:secl.004.001.03")]
pub struct NameAndAddress6 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max70Text,

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

impl Validate for NameAndAddress6 {}


#[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:secl.004.001.03")]
pub struct NetPosition3 {
    #[yaserde(rename = "ClrAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "ClrAcct"))]
    pub clr_acct: SecuritiesAccount18,

    #[yaserde(rename = "NonClrMmb")]
    #[cfg_attr(feature = "serde", serde(rename = "NonClrMmb"))]
    pub non_clr_mmb: PartyIdentificationAndAccount31,

    #[yaserde(rename = "DlvryAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "DlvryAcct"))]
    pub dlvry_acct: SecuritiesAccount19,

    #[yaserde(rename = "FinInstrmId")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrmId"))]
    pub fin_instrm_id: SecurityIdentification14,

    #[yaserde(rename = "InitlPosAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "InitlPosAmt"))]
    pub initl_pos_amt: AmountAndDirection21,

    #[yaserde(rename = "NetPosAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "NetPosAmt"))]
    pub net_pos_amt: AmountAndDirection21,

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

    #[yaserde(rename = "AvrgDealPric")]
    #[cfg_attr(feature = "serde", serde(rename = "AvrgDealPric"))]
    pub avrg_deal_pric: Price4,

    #[yaserde(rename = "NetQty")]
    #[cfg_attr(feature = "serde", serde(rename = "NetQty"))]
    pub net_qty: FinancialInstrumentQuantity1Choice,

    #[yaserde(rename = "SctiesMvmntTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesMvmntTp"))]
    pub scties_mvmnt_tp: ReceiveDelivery1Code,

    #[yaserde(rename = "Dpstry")]
    #[cfg_attr(feature = "serde", serde(rename = "Dpstry"))]
    pub dpstry: PartyIdentification34Choice,

    #[yaserde(rename = "TradgCpcty")]
    #[cfg_attr(feature = "serde", serde(rename = "TradgCpcty"))]
    pub tradg_cpcty: TradingCapacity5Code,

    #[yaserde(rename = "PlcOfTrad")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcOfTrad"))]
    pub plc_of_trad: MarketIdentification20,

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

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

    #[yaserde(rename = "TradLegDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "TradLegDtls"))]
    pub trad_leg_dtls: Vec<TradeLeg10>,
}

impl Validate for NetPosition3 {}


#[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:secl.004.001.03")]
pub struct NetPositionV03 {
    #[yaserde(rename = "RptParams")]
    #[cfg_attr(feature = "serde", serde(rename = "RptParams"))]
    pub rpt_params: ReportParameters1,

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

    #[yaserde(rename = "ClrMmb")]
    #[cfg_attr(feature = "serde", serde(rename = "ClrMmb"))]
    pub clr_mmb: PartyIdentification35Choice,

    #[yaserde(rename = "ClrSgmt")]
    #[cfg_attr(feature = "serde", serde(rename = "ClrSgmt"))]
    pub clr_sgmt: PartyIdentification35Choice,

    #[yaserde(rename = "NetPosRpt")]
    #[cfg_attr(feature = "serde", serde(rename = "NetPosRpt"))]
    pub net_pos_rpt: Vec<NetPosition3>,

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

impl Validate for NetPositionV03 {}


#[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:secl.004.001.03")]
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:secl.004.001.03")]
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:secl.004.001.03")]
pub struct PartyIdentification33Choice {
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_b_i_c: Option<AnyBICIdentifier>,
    #[yaserde(rename = "PrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
    pub prtry_id: Option<GenericIdentification29>,
    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: Option<NameAndAddress6>,
}

impl Validate for PartyIdentification33Choice {}
#[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:secl.004.001.03")]
pub struct PartyIdentification34Choice {
    #[yaserde(rename = "BIC")]
    #[cfg_attr(feature = "serde", serde(rename = "BIC"))]
    pub bic: Option<AnyBICIdentifier>,
    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: Option<NameAndAddress5>,
    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: Option<CountryCode>,
}

impl Validate for PartyIdentification34Choice {}
#[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:secl.004.001.03")]
pub struct PartyIdentification35Choice {
    #[yaserde(rename = "BIC")]
    #[cfg_attr(feature = "serde", serde(rename = "BIC"))]
    pub bic: Option<AnyBICIdentifier>,
    #[yaserde(rename = "PrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
    pub prtry_id: Option<GenericIdentification29>,
}

impl Validate for PartyIdentification35Choice {}
#[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:secl.004.001.03")]
pub struct PartyIdentification83Choice {
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_b_i_c: Option<AnyBICIdentifier>,
    #[yaserde(rename = "PrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
    pub prtry_id: Option<GenericIdentification29>,
    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: Option<NameAndAddress13>,
}

impl Validate for PartyIdentification83Choice {}




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

    #[yaserde(rename = "AltrnId")]
    #[cfg_attr(feature = "serde", serde(rename = "AltrnId"))]
    pub altrn_id: AlternatePartyIdentification5,

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

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

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

impl Validate for PartyIdentificationAndAccount100 {}


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

    #[yaserde(rename = "AltrnId")]
    #[cfg_attr(feature = "serde", serde(rename = "AltrnId"))]
    pub altrn_id: AlternatePartyIdentification4,

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

    #[yaserde(rename = "ClrAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "ClrAcct"))]
    pub clr_acct: SecuritiesAccount18,
}

impl Validate for PartyIdentificationAndAccount31 {}


#[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:secl.004.001.03")]
pub struct PartyTextInformation1 {
    #[yaserde(rename = "DclrtnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "DclrtnDtls"))]
    pub dclrtn_dtls: Max350Text,

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

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

impl Validate for PartyTextInformation1 {}


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

impl Validate for PercentageRate {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:secl.004.001.03")]
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:secl.004.001.03")]
pub struct PostalAddress2 {
    #[yaserde(rename = "StrtNm")]
    #[cfg_attr(feature = "serde", serde(rename = "StrtNm"))]
    pub strt_nm: Max70Text,

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


#[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:secl.004.001.03")]
pub struct PostalAddress8 {
    #[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 PostalAddress8 {}


#[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:secl.004.001.03")]
pub struct Price4 {
    #[yaserde(rename = "Val")]
    #[cfg_attr(feature = "serde", serde(rename = "Val"))]
    pub val: PriceRateOrAmountChoice,

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

impl Validate for Price4 {}
#[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:secl.004.001.03")]
pub struct PriceRateOrAmountChoice {
    #[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>,
}

impl Validate for PriceRateOrAmountChoice {}




#[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:secl.004.001.03")]

pub enum PriceValueType7Code {
    #[yaserde(rename = "DISC")]
    #[cfg_attr(feature = "serde", serde(rename = "DISC"))]
    Disc,
    #[yaserde(rename = "PREM")]
    #[cfg_attr(feature = "serde", serde(rename = "PREM"))]
    Prem,
    #[yaserde(rename = "PARV")]
    #[cfg_attr(feature = "serde", serde(rename = "PARV"))]
    Parv,
    #[yaserde(rename = "YIEL")]
    #[cfg_attr(feature = "serde", serde(rename = "YIEL"))]
    Yiel,
    #[yaserde(rename = "SPRE")]
    #[cfg_attr(feature = "serde", serde(rename = "SPRE"))]
    Spre,
    #[yaserde(rename = "PEUN")]
    #[cfg_attr(feature = "serde", serde(rename = "PEUN"))]
    Peun,
    #[yaserde(rename = "ABSO")]
    #[cfg_attr(feature = "serde", serde(rename = "ABSO"))]
    Abso,
    #[yaserde(rename = "TEDP")]
    #[cfg_attr(feature = "serde", serde(rename = "TEDP"))]
    Tedp,
    #[yaserde(rename = "TEDY")]
    #[cfg_attr(feature = "serde", serde(rename = "TEDY"))]
    Tedy,
    #[yaserde(rename = "FICT")]
    #[cfg_attr(feature = "serde", serde(rename = "FICT"))]
    Fict,
    #[yaserde(rename = "VACT")]
    #[cfg_attr(feature = "serde", serde(rename = "VACT"))]
    Vact,
    #[yaserde(rename = "PRCT")]
    #[cfg_attr(feature = "serde", serde(rename = "PRCT"))]
    Prct,
    #[yaserde(rename = "ACTU")]
    #[cfg_attr(feature = "serde", serde(rename = "ACTU"))]
    Actu,
    __Unknown__(String),
}

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

impl Validate for PriceValueType7Code {}



#[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:secl.004.001.03")]

pub enum ReceiveDelivery1Code {
    #[yaserde(rename = "DELI")]
    #[cfg_attr(feature = "serde", serde(rename = "DELI"))]
    Deli,
    #[yaserde(rename = "RECE")]
    #[cfg_attr(feature = "serde", serde(rename = "RECE"))]
    Rece,
    __Unknown__(String),
}

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

impl Validate for ReceiveDelivery1Code {}



#[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:secl.004.001.03")]
pub struct ReportParameters1 {
    #[yaserde(rename = "NetPosId")]
    #[cfg_attr(feature = "serde", serde(rename = "NetPosId"))]
    pub net_pos_id: Max35Text,

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

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

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

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

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

impl Validate for ReportParameters1 {}


#[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:secl.004.001.03")]

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

pub enum SafekeepingPlace3Code {
    #[yaserde(rename = "SHHE")]
    #[cfg_attr(feature = "serde", serde(rename = "SHHE"))]
    Shhe,
    __Unknown__(String),
}

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

impl Validate for SafekeepingPlace3Code {}
#[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:secl.004.001.03")]
pub struct SafekeepingPlaceFormat7Choice {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Option<SafekeepingPlaceTypeAndText1>,
    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: Option<CountryCode>,
    #[yaserde(rename = "TpAndId")]
    #[cfg_attr(feature = "serde", serde(rename = "TpAndId"))]
    pub tp_and_id: Option<SafekeepingPlaceTypeAndAnyBICIdentifier1>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification58>,
}

impl Validate for SafekeepingPlaceFormat7Choice {}




#[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:secl.004.001.03")]
pub struct SafekeepingPlaceTypeAndAnyBICIdentifier1 {
    #[yaserde(rename = "SfkpgPlcTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgPlcTp"))]
    pub sfkpg_plc_tp: SafekeepingPlace1Code,

    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: AnyBICIdentifier,
}

impl Validate for SafekeepingPlaceTypeAndAnyBICIdentifier1 {}


#[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:secl.004.001.03")]
pub struct SafekeepingPlaceTypeAndText1 {
    #[yaserde(rename = "SfkpgPlcTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgPlcTp"))]
    pub sfkpg_plc_tp: SafekeepingPlace3Code,

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

impl Validate for SafekeepingPlaceTypeAndText1 {}


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

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

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

impl Validate for SecuritiesAccount18 {}


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

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

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

impl Validate for SecuritiesAccount19 {}


#[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:secl.004.001.03")]
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:secl.004.001.03")]

pub enum Side1Code {
    #[yaserde(rename = "BUYI")]
    #[cfg_attr(feature = "serde", serde(rename = "BUYI"))]
    Buyi,
    #[yaserde(rename = "SELL")]
    #[cfg_attr(feature = "serde", serde(rename = "SELL"))]
    Sell,
    #[yaserde(rename = "TWOS")]
    #[cfg_attr(feature = "serde", serde(rename = "TWOS"))]
    Twos,
    #[yaserde(rename = "BUMI")]
    #[cfg_attr(feature = "serde", serde(rename = "BUMI"))]
    Bumi,
    #[yaserde(rename = "SEPL")]
    #[cfg_attr(feature = "serde", serde(rename = "SEPL"))]
    Sepl,
    #[yaserde(rename = "SESH")]
    #[cfg_attr(feature = "serde", serde(rename = "SESH"))]
    Sesh,
    #[yaserde(rename = "SSEX")]
    #[cfg_attr(feature = "serde", serde(rename = "SSEX"))]
    Ssex,
    #[yaserde(rename = "CROS")]
    #[cfg_attr(feature = "serde", serde(rename = "CROS"))]
    Cros,
    #[yaserde(rename = "CRSH")]
    #[cfg_attr(feature = "serde", serde(rename = "CRSH"))]
    Crsh,
    #[yaserde(rename = "CSHE")]
    #[cfg_attr(feature = "serde", serde(rename = "CSHE"))]
    Cshe,
    #[yaserde(rename = "DEFI")]
    #[cfg_attr(feature = "serde", serde(rename = "DEFI"))]
    Defi,
    #[yaserde(rename = "OPPO")]
    #[cfg_attr(feature = "serde", serde(rename = "OPPO"))]
    Oppo,
    #[yaserde(rename = "UNDI")]
    #[cfg_attr(feature = "serde", serde(rename = "UNDI"))]
    Undi,
    __Unknown__(String),
}

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

impl Validate for Side1Code {}



#[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:secl.004.001.03")]

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:secl.004.001.03")]
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:secl.004.001.03")]
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:secl.004.001.03")]
pub struct TradeLeg10 {
    #[yaserde(rename = "TradLegId")]
    #[cfg_attr(feature = "serde", serde(rename = "TradLegId"))]
    pub trad_leg_id: Max35Text,

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

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

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

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

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

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

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

    #[yaserde(rename = "TradgCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "TradgCcy"))]
    pub tradg_ccy: CurrencyCode,

    #[yaserde(rename = "BuySellInd")]
    #[cfg_attr(feature = "serde", serde(rename = "BuySellInd"))]
    pub buy_sell_ind: Side1Code,

    #[yaserde(rename = "TradQty")]
    #[cfg_attr(feature = "serde", serde(rename = "TradQty"))]
    pub trad_qty: FinancialInstrumentQuantity1Choice,

    #[yaserde(rename = "DealPric")]
    #[cfg_attr(feature = "serde", serde(rename = "DealPric"))]
    pub deal_pric: Price4,

    #[yaserde(rename = "GrssAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "GrssAmt"))]
    pub grss_amt: AmountAndDirection21,

    #[yaserde(rename = "PlcOfTrad")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcOfTrad"))]
    pub plc_of_trad: MarketIdentification84,

    #[yaserde(rename = "PlcOfListg")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcOfListg"))]
    pub plc_of_listg: MarketIdentification85,

    #[yaserde(rename = "TradTp")]
    #[cfg_attr(feature = "serde", serde(rename = "TradTp"))]
    pub trad_tp: TradeType1Code,

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

    #[yaserde(rename = "Brkr")]
    #[cfg_attr(feature = "serde", serde(rename = "Brkr"))]
    pub brkr: PartyIdentificationAndAccount100,

    #[yaserde(rename = "TradgPty")]
    #[cfg_attr(feature = "serde", serde(rename = "TradgPty"))]
    pub tradg_pty: PartyIdentification35Choice,

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

    #[yaserde(rename = "TradgPtyAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "TradgPtyAcct"))]
    pub tradg_pty_acct: SecuritiesAccount19,

    #[yaserde(rename = "TradgCpcty")]
    #[cfg_attr(feature = "serde", serde(rename = "TradgCpcty"))]
    pub tradg_cpcty: TradingCapacity5Code,

    #[yaserde(rename = "TradPstngCd")]
    #[cfg_attr(feature = "serde", serde(rename = "TradPstngCd"))]
    pub trad_pstng_cd: TradePosting1Code,

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

    #[yaserde(rename = "SfkpgAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgAcct"))]
    pub sfkpg_acct: SecuritiesAccount19,
}

impl Validate for TradeLeg10 {}


#[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:secl.004.001.03")]

pub enum TradePosting1Code {
    #[yaserde(rename = "GROS")]
    #[cfg_attr(feature = "serde", serde(rename = "GROS"))]
    Gros,
    #[yaserde(rename = "NETT")]
    #[cfg_attr(feature = "serde", serde(rename = "NETT"))]
    Nett,
    __Unknown__(String),
}

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

impl Validate for TradePosting1Code {}



#[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:secl.004.001.03")]

pub enum TradeType1Code {
    #[yaserde(rename = "OOBK")]
    #[cfg_attr(feature = "serde", serde(rename = "OOBK"))]
    Oobk,
    #[yaserde(rename = "OFBK")]
    #[cfg_attr(feature = "serde", serde(rename = "OFBK"))]
    Ofbk,
    #[yaserde(rename = "BKTR")]
    #[cfg_attr(feature = "serde", serde(rename = "BKTR"))]
    Bktr,
    #[yaserde(rename = "COTR")]
    #[cfg_attr(feature = "serde", serde(rename = "COTR"))]
    Cotr,
    #[yaserde(rename = "GUTR")]
    #[cfg_attr(feature = "serde", serde(rename = "GUTR"))]
    Gutr,
    #[yaserde(rename = "LKTR")]
    #[cfg_attr(feature = "serde", serde(rename = "LKTR"))]
    Lktr,
    __Unknown__(String),
}

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

impl Validate for TradeType1Code {}



#[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:secl.004.001.03")]

pub enum TradingCapacity5Code {
    #[yaserde(rename = "PRIN")]
    #[cfg_attr(feature = "serde", serde(rename = "PRIN"))]
    Prin,
    #[yaserde(rename = "RISP")]
    #[cfg_attr(feature = "serde", serde(rename = "RISP"))]
    Risp,
    #[yaserde(rename = "AGEN")]
    #[cfg_attr(feature = "serde", serde(rename = "AGEN"))]
    Agen,
    __Unknown__(String),
}

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

impl Validate for TradingCapacity5Code {}



#[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:secl.004.001.03")]

pub enum TypeOfIdentification1Code {
    #[yaserde(rename = "ARNU")]
    #[cfg_attr(feature = "serde", serde(rename = "ARNU"))]
    Arnu,
    #[yaserde(rename = "CCPT")]
    #[cfg_attr(feature = "serde", serde(rename = "CCPT"))]
    Ccpt,
    #[yaserde(rename = "CHTY")]
    #[cfg_attr(feature = "serde", serde(rename = "CHTY"))]
    Chty,
    #[yaserde(rename = "CORP")]
    #[cfg_attr(feature = "serde", serde(rename = "CORP"))]
    Corp,
    #[yaserde(rename = "DRLC")]
    #[cfg_attr(feature = "serde", serde(rename = "DRLC"))]
    Drlc,
    #[yaserde(rename = "FIIN")]
    #[cfg_attr(feature = "serde", serde(rename = "FIIN"))]
    Fiin,
    #[yaserde(rename = "TXID")]
    #[cfg_attr(feature = "serde", serde(rename = "TXID"))]
    Txid,
    __Unknown__(String),
}

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

impl Validate for TypeOfIdentification1Code {}



#[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:secl.004.001.03")]

pub enum TypeOfIdentification2Code {
    #[yaserde(rename = "ARNU")]
    #[cfg_attr(feature = "serde", serde(rename = "ARNU"))]
    Arnu,
    #[yaserde(rename = "CHTY")]
    #[cfg_attr(feature = "serde", serde(rename = "CHTY"))]
    Chty,
    #[yaserde(rename = "CORP")]
    #[cfg_attr(feature = "serde", serde(rename = "CORP"))]
    Corp,
    #[yaserde(rename = "FIIN")]
    #[cfg_attr(feature = "serde", serde(rename = "FIIN"))]
    Fiin,
    #[yaserde(rename = "TXID")]
    #[cfg_attr(feature = "serde", serde(rename = "TXID"))]
    Txid,
    __Unknown__(String),
}

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

impl Validate for TypeOfIdentification2Code {}



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