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

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

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

impl Validate for CountryCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.042.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.042.001.01")]
pub struct Document {
    #[yaserde(rename = "SctiesBalTrnsprncyRptStsAdvc")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesBalTrnsprncyRptStsAdvc"))]
    pub scties_bal_trnsprncy_rpt_sts_advc: SecuritiesBalanceTransparencyReportStatusAdviceV01,
}

impl Validate for Document {}


#[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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.042.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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.042.001.01")]
pub struct GenericIdentification36 {
    #[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 GenericIdentification36 {}


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

pub enum HoldingAccountLevel1Code {
    #[yaserde(rename = "SAFE")]
    #[cfg_attr(feature = "serde", serde(rename = "SAFE"))]
    Safe,
    #[yaserde(rename = "LVL1")]
    #[cfg_attr(feature = "serde", serde(rename = "LVL1"))]
    Lvl1,
    #[yaserde(rename = "LVL2")]
    #[cfg_attr(feature = "serde", serde(rename = "LVL2"))]
    Lvl2,
    #[yaserde(rename = "LVL3")]
    #[cfg_attr(feature = "serde", serde(rename = "LVL3"))]
    Lvl3,
    #[yaserde(rename = "LVL4")]
    #[cfg_attr(feature = "serde", serde(rename = "LVL4"))]
    Lvl4,
    #[yaserde(rename = "LVL5")]
    #[cfg_attr(feature = "serde", serde(rename = "LVL5"))]
    Lvl5,
    #[yaserde(rename = "LVL6")]
    #[cfg_attr(feature = "serde", serde(rename = "LVL6"))]
    Lvl6,
    #[yaserde(rename = "LVL7")]
    #[cfg_attr(feature = "serde", serde(rename = "LVL7"))]
    Lvl7,
    #[yaserde(rename = "LVL8")]
    #[cfg_attr(feature = "serde", serde(rename = "LVL8"))]
    Lvl8,
    #[yaserde(rename = "LVL9")]
    #[cfg_attr(feature = "serde", serde(rename = "LVL9"))]
    Lvl9,
    __Unknown__(String),
}

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

impl Validate for HoldingAccountLevel1Code {}



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

pub enum HoldingRejectionReason41Code {
    #[yaserde(rename = "INPR")]
    #[cfg_attr(feature = "serde", serde(rename = "INPR"))]
    Inpr,
    #[yaserde(rename = "INID")]
    #[cfg_attr(feature = "serde", serde(rename = "INID"))]
    Inid,
    #[yaserde(rename = "AGIN")]
    #[cfg_attr(feature = "serde", serde(rename = "AGIN"))]
    Agin,
    #[yaserde(rename = "INTE")]
    #[cfg_attr(feature = "serde", serde(rename = "INTE"))]
    Inte,
    #[yaserde(rename = "CERT")]
    #[cfg_attr(feature = "serde", serde(rename = "CERT"))]
    Cert,
    #[yaserde(rename = "BPAR")]
    #[cfg_attr(feature = "serde", serde(rename = "BPAR"))]
    Bpar,
    #[yaserde(rename = "BREF")]
    #[cfg_attr(feature = "serde", serde(rename = "BREF"))]
    Bref,
    #[yaserde(rename = "DADR")]
    #[cfg_attr(feature = "serde", serde(rename = "DADR"))]
    Dadr,
    #[yaserde(rename = "DCUS")]
    #[cfg_attr(feature = "serde", serde(rename = "DCUS"))]
    Dcus,
    #[yaserde(rename = "IACT")]
    #[cfg_attr(feature = "serde", serde(rename = "IACT"))]
    Iact,
    #[yaserde(rename = "INVA")]
    #[cfg_attr(feature = "serde", serde(rename = "INVA"))]
    Inva,
    #[yaserde(rename = "INDT")]
    #[cfg_attr(feature = "serde", serde(rename = "INDT"))]
    Indt,
    #[yaserde(rename = "OPTI")]
    #[cfg_attr(feature = "serde", serde(rename = "OPTI"))]
    Opti,
    #[yaserde(rename = "OPTY")]
    #[cfg_attr(feature = "serde", serde(rename = "OPTY"))]
    Opty,
    #[yaserde(rename = "INMO")]
    #[cfg_attr(feature = "serde", serde(rename = "INMO"))]
    Inmo,
    #[yaserde(rename = "INVM")]
    #[cfg_attr(feature = "serde", serde(rename = "INVM"))]
    Invm,
    #[yaserde(rename = "INUS")]
    #[cfg_attr(feature = "serde", serde(rename = "INUS"))]
    Inus,
    #[yaserde(rename = "DSEC")]
    #[cfg_attr(feature = "serde", serde(rename = "DSEC"))]
    Dsec,
    #[yaserde(rename = "ENDP")]
    #[cfg_attr(feature = "serde", serde(rename = "ENDP"))]
    Endp,
    #[yaserde(rename = "STAR")]
    #[cfg_attr(feature = "serde", serde(rename = "STAR"))]
    Star,
    #[yaserde(rename = "SECO")]
    #[cfg_attr(feature = "serde", serde(rename = "SECO"))]
    Seco,
    #[yaserde(rename = "NOHO")]
    #[cfg_attr(feature = "serde", serde(rename = "NOHO"))]
    Noho,
    #[yaserde(rename = "NINS")]
    #[cfg_attr(feature = "serde", serde(rename = "NINS"))]
    Nins,
    #[yaserde(rename = "NOAP")]
    #[cfg_attr(feature = "serde", serde(rename = "NOAP"))]
    Noap,
    #[yaserde(rename = "NAUT")]
    #[cfg_attr(feature = "serde", serde(rename = "NAUT"))]
    Naut,
    #[yaserde(rename = "AGID")]
    #[cfg_attr(feature = "serde", serde(rename = "AGID"))]
    Agid,
    #[yaserde(rename = "DISP")]
    #[cfg_attr(feature = "serde", serde(rename = "DISP"))]
    Disp,
    #[yaserde(rename = "CORR")]
    #[cfg_attr(feature = "serde", serde(rename = "CORR"))]
    Corr,
    #[yaserde(rename = "INPS")]
    #[cfg_attr(feature = "serde", serde(rename = "INPS"))]
    Inps,
    #[yaserde(rename = "PLCE")]
    #[cfg_attr(feature = "serde", serde(rename = "PLCE"))]
    Plce,
    #[yaserde(rename = "PRIC")]
    #[cfg_attr(feature = "serde", serde(rename = "PRIC"))]
    Pric,
    #[yaserde(rename = "IVAG")]
    #[cfg_attr(feature = "serde", serde(rename = "IVAG"))]
    Ivag,
    #[yaserde(rename = "QUNP")]
    #[cfg_attr(feature = "serde", serde(rename = "QUNP"))]
    Qunp,
    #[yaserde(rename = "DQUA")]
    #[cfg_attr(feature = "serde", serde(rename = "DQUA"))]
    Dqua,
    #[yaserde(rename = "EQTY")]
    #[cfg_attr(feature = "serde", serde(rename = "EQTY"))]
    Eqty,
    #[yaserde(rename = "DEPT")]
    #[cfg_attr(feature = "serde", serde(rename = "DEPT"))]
    Dept,
    #[yaserde(rename = "RCUS")]
    #[cfg_attr(feature = "serde", serde(rename = "RCUS"))]
    Rcus,
    #[yaserde(rename = "SAFE")]
    #[cfg_attr(feature = "serde", serde(rename = "SAFE"))]
    Safe,
    #[yaserde(rename = "DMON")]
    #[cfg_attr(feature = "serde", serde(rename = "DMON"))]
    Dmon,
    #[yaserde(rename = "NCRR")]
    #[cfg_attr(feature = "serde", serde(rename = "NCRR"))]
    Ncrr,
    #[yaserde(rename = "TQNP")]
    #[cfg_attr(feature = "serde", serde(rename = "TQNP"))]
    Tqnp,
    #[yaserde(rename = "SETR")]
    #[cfg_attr(feature = "serde", serde(rename = "SETR"))]
    Setr,
    #[yaserde(rename = "UKWN")]
    #[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
    Ukwn,
    #[yaserde(rename = "DDEA")]
    #[cfg_attr(feature = "serde", serde(rename = "DDEA"))]
    Ddea,
    #[yaserde(rename = "TERM")]
    #[cfg_attr(feature = "serde", serde(rename = "TERM"))]
    Term,
    #[yaserde(rename = "ULNK")]
    #[cfg_attr(feature = "serde", serde(rename = "ULNK"))]
    Ulnk,
    #[yaserde(rename = "NARR")]
    #[cfg_attr(feature = "serde", serde(rename = "NARR"))]
    Narr,
    #[yaserde(rename = "NRGN")]
    #[cfg_attr(feature = "serde", serde(rename = "NRGN"))]
    Nrgn,
    #[yaserde(rename = "INVB")]
    #[cfg_attr(feature = "serde", serde(rename = "INVB"))]
    Invb,
    #[yaserde(rename = "ADEA")]
    #[cfg_attr(feature = "serde", serde(rename = "ADEA"))]
    Adea,
    #[yaserde(rename = "CASH")]
    #[cfg_attr(feature = "serde", serde(rename = "CASH"))]
    Cash,
    #[yaserde(rename = "COMC")]
    #[cfg_attr(feature = "serde", serde(rename = "COMC"))]
    Comc,
    #[yaserde(rename = "CONL")]
    #[cfg_attr(feature = "serde", serde(rename = "CONL"))]
    Conl,
    #[yaserde(rename = "INHO")]
    #[cfg_attr(feature = "serde", serde(rename = "INHO"))]
    Inho,
    #[yaserde(rename = "ICOL")]
    #[cfg_attr(feature = "serde", serde(rename = "ICOL"))]
    Icol,
    #[yaserde(rename = "INVE")]
    #[cfg_attr(feature = "serde", serde(rename = "INVE"))]
    Inve,
    #[yaserde(rename = "INVN")]
    #[cfg_attr(feature = "serde", serde(rename = "INVN"))]
    Invn,
    #[yaserde(rename = "INVL")]
    #[cfg_attr(feature = "serde", serde(rename = "INVL"))]
    Invl,
    #[yaserde(rename = "VALR")]
    #[cfg_attr(feature = "serde", serde(rename = "VALR"))]
    Valr,
    #[yaserde(rename = "INUK")]
    #[cfg_attr(feature = "serde", serde(rename = "INUK"))]
    Inuk,
    #[yaserde(rename = "LATT")]
    #[cfg_attr(feature = "serde", serde(rename = "LATT"))]
    Latt,
    #[yaserde(rename = "MINO")]
    #[cfg_attr(feature = "serde", serde(rename = "MINO"))]
    Mino,
    #[yaserde(rename = "BOIS")]
    #[cfg_attr(feature = "serde", serde(rename = "BOIS"))]
    Bois,
    #[yaserde(rename = "MCER")]
    #[cfg_attr(feature = "serde", serde(rename = "MCER"))]
    Mcer,
    #[yaserde(rename = "IPOA")]
    #[cfg_attr(feature = "serde", serde(rename = "IPOA"))]
    Ipoa,
    #[yaserde(rename = "MUNO")]
    #[cfg_attr(feature = "serde", serde(rename = "MUNO"))]
    Muno,
    #[yaserde(rename = "INNA")]
    #[cfg_attr(feature = "serde", serde(rename = "INNA"))]
    Inna,
    #[yaserde(rename = "NINV")]
    #[cfg_attr(feature = "serde", serde(rename = "NINV"))]
    Ninv,
    #[yaserde(rename = "ELIG")]
    #[cfg_attr(feature = "serde", serde(rename = "ELIG"))]
    Elig,
    #[yaserde(rename = "PERI")]
    #[cfg_attr(feature = "serde", serde(rename = "PERI"))]
    Peri,
    #[yaserde(rename = "REFE")]
    #[cfg_attr(feature = "serde", serde(rename = "REFE"))]
    Refe,
    #[yaserde(rename = "SAID")]
    #[cfg_attr(feature = "serde", serde(rename = "SAID"))]
    Said,
    #[yaserde(rename = "OWNT")]
    #[cfg_attr(feature = "serde", serde(rename = "OWNT"))]
    Ownt,
    #[yaserde(rename = "NTAV")]
    #[cfg_attr(feature = "serde", serde(rename = "NTAV"))]
    Ntav,
    __Unknown__(String),
}

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

impl Validate for HoldingRejectionReason41Code {}



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

impl Validate for Isinoct2015Identifier {}
#[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.042.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)]
pub struct Leiidentifier (pub String);
crate::simple_type!(Leiidentifier);

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

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

impl Validate for Max210Text {
    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() > 210 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 210 \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:semt.042.001.01")]
pub struct MessageIdentification1 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

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

impl Validate for MessageIdentification1 {}


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

pub enum NoReasonCode {
    #[yaserde(rename = "NORE")]
    #[cfg_attr(feature = "serde", serde(rename = "NORE"))]
    Nore,
    __Unknown__(String),
}

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

impl Validate for NoReasonCode {}



#[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.042.001.01")]
pub struct NumberOfItemsPerStatus1 {
    #[yaserde(rename = "Sts")]
    #[cfg_attr(feature = "serde", serde(rename = "Sts"))]
    pub sts: ReportItemStatus1Code,

    #[yaserde(rename = "NbOfItms")]
    #[cfg_attr(feature = "serde", serde(rename = "NbOfItms"))]
    pub nb_of_itms: Max15NumericText,
}

impl Validate for NumberOfItemsPerStatus1 {}


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

    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Leiidentifier,
}

impl Validate for PartyIdentification100 {}
#[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.042.001.01")]
pub struct PartyIdentification71Choice {
    #[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<GenericIdentification36>,
    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: Option<NameAndAddress5>,
}

impl Validate for PartyIdentification71Choice {}




#[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.042.001.01")]
pub struct PostalAddress1 {
    #[yaserde(rename = "AdrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "AdrTp"))]
    pub adr_tp: AddressType2Code,

    #[yaserde(rename = "AdrLine")]
    #[cfg_attr(feature = "serde", serde(rename = "AdrLine"))]
    pub adr_line: Vec<Max70Text>,

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

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

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

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

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

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

impl Validate for PostalAddress1 {}


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

    #[yaserde(rename = "AcctLvl")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctLvl"))]
    pub acct_lvl: HoldingAccountLevel1Code,

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

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

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

impl Validate for ReportItemRejectionReason1Choice {}




#[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.042.001.01")]
pub struct ReportItemStatus1 {
    #[yaserde(rename = "Xcptn")]
    #[cfg_attr(feature = "serde", serde(rename = "Xcptn"))]
    pub xcptn: ReportItemRejectionReason1Choice,

    #[yaserde(rename = "AddtlRsnInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlRsnInf"))]
    pub addtl_rsn_inf: Max210Text,

    #[yaserde(rename = "RptItm")]
    #[cfg_attr(feature = "serde", serde(rename = "RptItm"))]
    pub rpt_itm: Vec<ReportItem1>,
}

impl Validate for ReportItemStatus1 {}
#[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.042.001.01")]
pub struct ReportItemStatus1Choice {
    #[yaserde(rename = "Accptd")]
    #[cfg_attr(feature = "serde", serde(rename = "Accptd"))]
    pub accptd: Option<NoReasonCode>,
    #[yaserde(rename = "AccptdWthXcptn")]
    #[cfg_attr(feature = "serde", serde(rename = "AccptdWthXcptn"))]
    pub accptd_wth_xcptn: Vec<ReportItemStatus1>,
    #[yaserde(rename = "Rjctd")]
    #[cfg_attr(feature = "serde", serde(rename = "Rjctd"))]
    pub rjctd: Option<ReportItemStatus1>,
}

impl Validate for ReportItemStatus1Choice {}




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

pub enum ReportItemStatus1Code {
    #[yaserde(rename = "ACPD")]
    #[cfg_attr(feature = "serde", serde(rename = "ACPD"))]
    Acpd,
    #[yaserde(rename = "REJT")]
    #[cfg_attr(feature = "serde", serde(rename = "REJT"))]
    Rejt,
    __Unknown__(String),
}

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

impl Validate for ReportItemStatus1Code {}



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

    #[yaserde(rename = "SndrId")]
    #[cfg_attr(feature = "serde", serde(rename = "SndrId"))]
    pub sndr_id: PartyIdentification100,

    #[yaserde(rename = "RcvrId")]
    #[cfg_attr(feature = "serde", serde(rename = "RcvrId"))]
    pub rcvr_id: PartyIdentification100,

    #[yaserde(rename = "RltdStmt")]
    #[cfg_attr(feature = "serde", serde(rename = "RltdStmt"))]
    pub rltd_stmt: StatementReference1,

    #[yaserde(rename = "Sts")]
    #[cfg_attr(feature = "serde", serde(rename = "Sts"))]
    pub sts: ReportItemStatus1Choice,

    #[yaserde(rename = "NbOfItmsPerSts")]
    #[cfg_attr(feature = "serde", serde(rename = "NbOfItmsPerSts"))]
    pub nb_of_itms_per_sts: Vec<NumberOfItemsPerStatus1>,

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

impl Validate for SecuritiesBalanceTransparencyReportStatusAdviceV01 {}


#[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.042.001.01")]
pub struct SecurityIdentification19 {
    #[yaserde(rename = "ISIN")]
    #[cfg_attr(feature = "serde", serde(rename = "ISIN"))]
    pub isin: Isinoct2015Identifier,

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


#[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.042.001.01")]
pub struct StatementReference1 {
    #[yaserde(rename = "StmtId")]
    #[cfg_attr(feature = "serde", serde(rename = "StmtId"))]
    pub stmt_id: Max35Text,

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

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

impl Validate for StatementReference1 {}


#[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.042.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.042.001.01")]
pub struct SupplementaryDataEnvelope1 {}

impl Validate for SupplementaryDataEnvelope1 {}


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