rust_iso20022 0.1.1

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

// pub type Document = Document;
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
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:seev.001.001.08")]
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 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:seev.001.001.08")]

pub enum AdditionalRight1Code {
    #[yaserde(rename = "WQPS")]
    #[cfg_attr(feature = "serde", serde(rename = "WQPS"))]
    Wqps,
    #[yaserde(rename = "RSPS")]
    #[cfg_attr(feature = "serde", serde(rename = "RSPS"))]
    Rsps,
    #[yaserde(rename = "AIPS")]
    #[cfg_attr(feature = "serde", serde(rename = "AIPS"))]
    Aips,
    __Unknown__(String),
}

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

impl Validate for AdditionalRight1Code {}
#[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:seev.001.001.08")]
pub struct AdditionalRightCode1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<AdditionalRight1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification13>,
}

impl Validate for AdditionalRightCode1Choice {}
#[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:seev.001.001.08")]
pub struct AdditionalRightThreshold1Choice {
    #[yaserde(rename = "AddtlRghtThrshld")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlRghtThrshld"))]
    pub addtl_rght_thrshld: Option<Max35Text>,
    #[yaserde(rename = "AddtlRghtThrshldPctg")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlRghtThrshldPctg"))]
    pub addtl_rght_thrshld_pctg: Option<PercentageRate>,
}

impl Validate for AdditionalRightThreshold1Choice {}




#[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:seev.001.001.08")]
pub struct AdditionalRights3 {
    #[yaserde(rename = "AddtlRght")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlRght"))]
    pub addtl_rght: AdditionalRightCode1Choice,

    #[yaserde(rename = "AddtlRghtInfURLAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlRghtInfURLAdr"))]
    pub addtl_rght_inf_url_adr: Max2048Text,

    #[yaserde(rename = "AddtlRghtDdln")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlRghtDdln"))]
    pub addtl_rght_ddln: DateFormat58Choice,

    #[yaserde(rename = "AddtlRghtMktDdln")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlRghtMktDdln"))]
    pub addtl_rght_mkt_ddln: DateFormat58Choice,

    #[yaserde(rename = "AddtlRghtThrshld")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlRghtThrshld"))]
    pub addtl_rght_thrshld: AdditionalRightThreshold1Choice,
}

impl Validate for AdditionalRights3 {}


#[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:seev.001.001.08")]

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

pub enum AgentRole1Code {
    #[yaserde(rename = "PRIN")]
    #[cfg_attr(feature = "serde", serde(rename = "PRIN"))]
    Prin,
    #[yaserde(rename = "SUBA")]
    #[cfg_attr(feature = "serde", serde(rename = "SUBA"))]
    Suba,
    __Unknown__(String),
}

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

impl Validate for AgentRole1Code {}



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

impl Validate for AnyBICDec2014Identifier {}
#[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:seev.001.001.08")]
pub struct Attendance2 {
    #[yaserde(rename = "AdmssnConds")]
    #[cfg_attr(feature = "serde", serde(rename = "AdmssnConds"))]
    pub admssn_conds: Vec<AttendanceAdmissionConditions2>,

    #[yaserde(rename = "ConfInf")]
    #[cfg_attr(feature = "serde", serde(rename = "ConfInf"))]
    pub conf_inf: Max350Text,

    #[yaserde(rename = "ConfDdln")]
    #[cfg_attr(feature = "serde", serde(rename = "ConfDdln"))]
    pub conf_ddln: DateFormat58Choice,

    #[yaserde(rename = "ConfMktDdln")]
    #[cfg_attr(feature = "serde", serde(rename = "ConfMktDdln"))]
    pub conf_mkt_ddln: DateFormat58Choice,
}

impl Validate for Attendance2 {}


#[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:seev.001.001.08")]
pub struct AttendanceAdmissionConditions2 {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: AttendanceAdmissionConditions2Code,

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

impl Validate for AttendanceAdmissionConditions2 {}


#[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:seev.001.001.08")]

pub enum AttendanceAdmissionConditions2Code {
    #[yaserde(rename = "MASH")]
    #[cfg_attr(feature = "serde", serde(rename = "MASH"))]
    Mash,
    #[yaserde(rename = "MASL")]
    #[cfg_attr(feature = "serde", serde(rename = "MASL"))]
    Masl,
    #[yaserde(rename = "MAPO")]
    #[cfg_attr(feature = "serde", serde(rename = "MAPO"))]
    Mapo,
    #[yaserde(rename = "MAAL")]
    #[cfg_attr(feature = "serde", serde(rename = "MAAL"))]
    Maal,
    #[yaserde(rename = "MALR")]
    #[cfg_attr(feature = "serde", serde(rename = "MALR"))]
    Malr,
    #[yaserde(rename = "MAHI")]
    #[cfg_attr(feature = "serde", serde(rename = "MAHI"))]
    Mahi,
    #[yaserde(rename = "MATK")]
    #[cfg_attr(feature = "serde", serde(rename = "MATK"))]
    Matk,
    #[yaserde(rename = "MADS")]
    #[cfg_attr(feature = "serde", serde(rename = "MADS"))]
    Mads,
    #[yaserde(rename = "MANP")]
    #[cfg_attr(feature = "serde", serde(rename = "MANP"))]
    Manp,
    __Unknown__(String),
}

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

impl Validate for AttendanceAdmissionConditions2Code {}



#[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:seev.001.001.08")]
pub struct CommunicationAddress11 {
    #[yaserde(rename = "EmailAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "EmailAdr"))]
    pub email_adr: Max256Text,

    #[yaserde(rename = "URLAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "URLAdr"))]
    pub url_adr: Max2048Text,
}

impl Validate for CommunicationAddress11 {}


#[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:seev.001.001.08")]
pub struct ContactIdentification1 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max35Text,

    #[yaserde(rename = "NmPrfx")]
    #[cfg_attr(feature = "serde", serde(rename = "NmPrfx"))]
    pub nm_prfx: NamePrefix1Code,

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

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

    #[yaserde(rename = "PhneNb")]
    #[cfg_attr(feature = "serde", serde(rename = "PhneNb"))]
    pub phne_nb: PhoneNumber,

    #[yaserde(rename = "FaxNb")]
    #[cfg_attr(feature = "serde", serde(rename = "FaxNb"))]
    pub fax_nb: PhoneNumber,

    #[yaserde(rename = "EmailAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "EmailAdr"))]
    pub email_adr: Max256Text,
}

impl Validate for ContactIdentification1 {}


#[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:seev.001.001.08")]
pub struct CorporateEventNarrative3 {
    #[yaserde(rename = "Dsclmr")]
    #[cfg_attr(feature = "serde", serde(rename = "Dsclmr"))]
    pub dsclmr: Vec<LanguageSpecifiedNarrative1>,
}

impl Validate for CorporateEventNarrative3 {}


#[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:seev.001.001.08")]
pub struct DateAndDateTime2Choice {
    #[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 DateAndDateTime2Choice {}




#[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:seev.001.001.08")]
pub struct DateAndPlaceOfBirth2 {
    #[yaserde(rename = "BirthDt")]
    #[cfg_attr(feature = "serde", serde(rename = "BirthDt"))]
    pub birth_dt: Isodate,

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

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

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

impl Validate for DateAndPlaceOfBirth2 {}


#[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:seev.001.001.08")]
pub struct DateFormat1 {
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: DateFormat3Choice,

    #[yaserde(rename = "DtMd")]
    #[cfg_attr(feature = "serde", serde(rename = "DtMd"))]
    pub dt_md: DateMode1Code,
}

impl Validate for DateFormat1 {}
#[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:seev.001.001.08")]
pub struct DateFormat3Choice {
    #[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<DateType1Code>,
}

impl Validate for DateFormat3Choice {}
#[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:seev.001.001.08")]
pub struct DateFormat58Choice {
    #[yaserde(rename = "DtOrDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "DtOrDtTm"))]
    pub dt_or_dt_tm: Option<DateAndDateTime2Choice>,
    #[yaserde(rename = "DtCd")]
    #[cfg_attr(feature = "serde", serde(rename = "DtCd"))]
    pub dt_cd: Option<DateType1Code>,
}

impl Validate for DateFormat58Choice {}




#[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:seev.001.001.08")]

pub enum DateMode1Code {
    #[yaserde(rename = "BODY")]
    #[cfg_attr(feature = "serde", serde(rename = "BODY"))]
    Body,
    #[yaserde(rename = "EODY")]
    #[cfg_attr(feature = "serde", serde(rename = "EODY"))]
    Eody,
    __Unknown__(String),
}

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

impl Validate for DateMode1Code {}



#[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:seev.001.001.08")]

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:seev.001.001.08")]
pub struct Document {
    #[yaserde(rename = "MtgNtfctn")]
    #[cfg_attr(feature = "serde", serde(rename = "MtgNtfctn"))]
    pub mtg_ntfctn: MeetingNotificationV08,
}

impl Validate for Document {}


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

    #[yaserde(rename = "AcctOwnr")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctOwnr"))]
    pub acct_ownr: PartyIdentification231Choice,

    #[yaserde(rename = "HldgBal")]
    #[cfg_attr(feature = "serde", serde(rename = "HldgBal"))]
    pub hldg_bal: Vec<HoldingBalance9>,

    #[yaserde(rename = "RghtsHldr")]
    #[cfg_attr(feature = "serde", serde(rename = "RghtsHldr"))]
    pub rghts_hldr: Vec<PartyIdentification233Choice>,
}

impl Validate for EligiblePosition9 {}
#[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:seev.001.001.08")]
pub struct Entitlement1Choice {
    #[yaserde(rename = "EntitlmntRatio")]
    #[cfg_attr(feature = "serde", serde(rename = "EntitlmntRatio"))]
    pub entitlmnt_ratio: Option<DecimalNumber>,
    #[yaserde(rename = "EntitlmntDesc")]
    #[cfg_attr(feature = "serde", serde(rename = "EntitlmntDesc"))]
    pub entitlmnt_desc: Option<Max35Text>,
}

impl Validate for Entitlement1Choice {}




#[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:seev.001.001.08")]

pub enum EventCompletenessStatus1Code {
    #[yaserde(rename = "COMP")]
    #[cfg_attr(feature = "serde", serde(rename = "COMP"))]
    Comp,
    #[yaserde(rename = "INCO")]
    #[cfg_attr(feature = "serde", serde(rename = "INCO"))]
    Inco,
    __Unknown__(String),
}

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

impl Validate for EventCompletenessStatus1Code {}



#[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:seev.001.001.08")]

pub enum EventConfirmationStatus1Code {
    #[yaserde(rename = "CONF")]
    #[cfg_attr(feature = "serde", serde(rename = "CONF"))]
    Conf,
    #[yaserde(rename = "UCON")]
    #[cfg_attr(feature = "serde", serde(rename = "UCON"))]
    Ucon,
    __Unknown__(String),
}

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

impl Validate for EventConfirmationStatus1Code {}



#[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:seev.001.001.08")]
pub struct EventStatus1 {
    #[yaserde(rename = "EvtCmpltnsSts")]
    #[cfg_attr(feature = "serde", serde(rename = "EvtCmpltnsSts"))]
    pub evt_cmpltns_sts: EventCompletenessStatus1Code,

    #[yaserde(rename = "EvtConfSts")]
    #[cfg_attr(feature = "serde", serde(rename = "EvtConfSts"))]
    pub evt_conf_sts: EventConfirmationStatus1Code,
}

impl Validate for EventStatus1 {}


#[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:seev.001.001.08")]
pub struct FinancialInstrumentQuantity18Choice {
    #[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>,
}

impl Validate for FinancialInstrumentQuantity18Choice {}




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

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

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

impl Validate for GenericIdentification13 {}


#[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:seev.001.001.08")]
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:seev.001.001.08")]
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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.001.001.08")]
pub struct GenericIdentification78 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: GenericIdentification30,

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

impl Validate for GenericIdentification78 {}


#[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:seev.001.001.08")]
pub struct HoldingBalance9 {
    #[yaserde(rename = "Bal")]
    #[cfg_attr(feature = "serde", serde(rename = "Bal"))]
    pub bal: FinancialInstrumentQuantity18Choice,

    #[yaserde(rename = "BalTp")]
    #[cfg_attr(feature = "serde", serde(rename = "BalTp"))]
    pub bal_tp: SecuritiesEntryType2Code,

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

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

impl Validate for HoldingBalance9 {}


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

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

impl Validate for IdentificationType45Choice {}




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

impl Validate for ImpliedCurrencyAndAmount {
    fn validate(&self) -> Result<(), String> { 
        if self.0 < "0".parse::<String>().unwrap() {
            return Err(format!("MinInclusive validation error: invalid value of 0! \nExpected: 0 >= 0.\nActual: 0 == {}", self.0));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.001.001.08")]
pub struct IncentivePremium5 {
    #[yaserde(rename = "Desc")]
    #[cfg_attr(feature = "serde", serde(rename = "Desc"))]
    pub desc: Max350Text,

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

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

    #[yaserde(rename = "PmtDt")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtDt"))]
    pub pmt_dt: DateFormat3Choice,
}

impl Validate for IncentivePremium5 {}
#[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:seev.001.001.08")]
pub struct IncentivePremiumType2Choice {
    #[yaserde(rename = "PerScty")]
    #[cfg_attr(feature = "serde", serde(rename = "PerScty"))]
    pub per_scty: Option<Number>,
    #[yaserde(rename = "PerVote")]
    #[cfg_attr(feature = "serde", serde(rename = "PerVote"))]
    pub per_vote: Vec<VoteTypeAndQuantity1>,
    #[yaserde(rename = "PerAttndee")]
    #[cfg_attr(feature = "serde", serde(rename = "PerAttndee"))]
    pub per_attndee: Option<YesNoIndicator>,
}

impl Validate for IncentivePremiumType2Choice {}




#[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:seev.001.001.08")]
pub struct IndividualPerson43 {
    #[yaserde(rename = "PrssgndPrxy")]
    #[cfg_attr(feature = "serde", serde(rename = "PrssgndPrxy"))]
    pub prssgnd_prxy: PartyIdentification232Choice,

    #[yaserde(rename = "EmplngPty")]
    #[cfg_attr(feature = "serde", serde(rename = "EmplngPty"))]
    pub emplng_pty: PartyIdentification129Choice,
}

impl Validate for IndividualPerson43 {}


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

    #[yaserde(rename = "Role")]
    #[cfg_attr(feature = "serde", serde(rename = "Role"))]
    pub role: AgentRole1Code,
}

impl Validate for IssuerAgent3 {}


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

    #[yaserde(rename = "URLAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "URLAdr"))]
    pub url_adr: Max2048Text,
}

impl Validate for IssuerInformation3 {}


#[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:seev.001.001.08")]
pub struct ItemDescription1 {
    #[yaserde(rename = "Lang")]
    #[cfg_attr(feature = "serde", serde(rename = "Lang"))]
    pub lang: Iso2AlanguageCode,

    #[yaserde(rename = "Titl")]
    #[cfg_attr(feature = "serde", serde(rename = "Titl"))]
    pub titl: Max350Text,

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

impl Validate for ItemDescription1 {}


#[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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.001.001.08")]
pub struct LanguageSpecifiedNarrative1 {
    #[yaserde(rename = "Lang")]
    #[cfg_attr(feature = "serde", serde(rename = "Lang"))]
    pub lang: Iso2AlanguageCode,

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

impl Validate for LanguageSpecifiedNarrative1 {}
#[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:seev.001.001.08")]
pub struct LocationFormat1Choice {
    #[yaserde(rename = "Adr")]
    #[cfg_attr(feature = "serde", serde(rename = "Adr"))]
    pub adr: Option<PostalAddress1>,
    #[yaserde(rename = "LctnCd")]
    #[cfg_attr(feature = "serde", serde(rename = "LctnCd"))]
    pub lctn_cd: Option<PlaceType1Code>,
}

impl Validate for LocationFormat1Choice {}




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

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

impl Validate for Max1025Text {
    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() > 1025 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 1025 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

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

impl Validate for Max2048Text {
    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() > 2048 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 2048 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

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

impl Validate for Max256Text {
    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() > 256 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 256 \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 Max4AlphaNumericText (pub String);
crate::simple_type!(Max4AlphaNumericText);

impl Validate for Max4AlphaNumericText {
    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)]
pub struct Max50Text (pub String);
crate::simple_type!(Max50Text);

impl Validate for Max50Text {
    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() > 50 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 50 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

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

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

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

impl Validate for Max8000Text {
    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() > 8000 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 8000 \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:seev.001.001.08")]
pub struct Meeting6 {
    #[yaserde(rename = "DtAndTm")]
    #[cfg_attr(feature = "serde", serde(rename = "DtAndTm"))]
    pub dt_and_tm: DateFormat58Choice,

    #[yaserde(rename = "DtSts")]
    #[cfg_attr(feature = "serde", serde(rename = "DtSts"))]
    pub dt_sts: MeetingDateStatus2Code,

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

    #[yaserde(rename = "Lctn")]
    #[cfg_attr(feature = "serde", serde(rename = "Lctn"))]
    pub lctn: Vec<LocationFormat1Choice>,

    #[yaserde(rename = "QrmQty")]
    #[cfg_attr(feature = "serde", serde(rename = "QrmQty"))]
    pub qrm_qty: QuorumQuantity1Choice,

    #[yaserde(rename = "URLAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "URLAdr"))]
    pub url_adr: Max2048Text,
}

impl Validate for Meeting6 {}


#[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:seev.001.001.08")]
pub struct MeetingContactPerson3 {
    #[yaserde(rename = "CtctPrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "CtctPrsn"))]
    pub ctct_prsn: ContactIdentification1,

    #[yaserde(rename = "EmplngPty")]
    #[cfg_attr(feature = "serde", serde(rename = "EmplngPty"))]
    pub emplng_pty: PartyIdentification129Choice,

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

impl Validate for MeetingContactPerson3 {}


#[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:seev.001.001.08")]

pub enum MeetingDateStatus2Code {
    #[yaserde(rename = "CNFR")]
    #[cfg_attr(feature = "serde", serde(rename = "CNFR"))]
    Cnfr,
    #[yaserde(rename = "TNTA")]
    #[cfg_attr(feature = "serde", serde(rename = "TNTA"))]
    Tnta,
    __Unknown__(String),
}

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

impl Validate for MeetingDateStatus2Code {}



#[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:seev.001.001.08")]
pub struct MeetingEventReference1 {
    #[yaserde(rename = "EvtId")]
    #[cfg_attr(feature = "serde", serde(rename = "EvtId"))]
    pub evt_id: MeetingEventReference1Choice,

    #[yaserde(rename = "LkgTp")]
    #[cfg_attr(feature = "serde", serde(rename = "LkgTp"))]
    pub lkg_tp: ProcessingPosition3Code,
}

impl Validate for MeetingEventReference1 {}
#[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:seev.001.001.08")]
pub struct MeetingEventReference1Choice {
    #[yaserde(rename = "LkdIssrMtgId")]
    #[cfg_attr(feature = "serde", serde(rename = "LkdIssrMtgId"))]
    pub lkd_issr_mtg_id: Option<Max35Text>,
    #[yaserde(rename = "LkdMtgId")]
    #[cfg_attr(feature = "serde", serde(rename = "LkdMtgId"))]
    pub lkd_mtg_id: Option<Max35Text>,
}

impl Validate for MeetingEventReference1Choice {}




#[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:seev.001.001.08")]
pub struct MeetingNotice6 {
    #[yaserde(rename = "MtgId")]
    #[cfg_attr(feature = "serde", serde(rename = "MtgId"))]
    pub mtg_id: Max35Text,

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

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

    #[yaserde(rename = "Clssfctn")]
    #[cfg_attr(feature = "serde", serde(rename = "Clssfctn"))]
    pub clssfctn: MeetingTypeClassification2Choice,

    #[yaserde(rename = "AnncmntDt")]
    #[cfg_attr(feature = "serde", serde(rename = "AnncmntDt"))]
    pub anncmnt_dt: DateAndDateTime2Choice,

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

    #[yaserde(rename = "Prtcptn")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtcptn"))]
    pub prtcptn: Vec<ParticipationMethod1>,

    #[yaserde(rename = "Attndnc")]
    #[cfg_attr(feature = "serde", serde(rename = "Attndnc"))]
    pub attndnc: Attendance2,

    #[yaserde(rename = "AddtlDcmnttnURLAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlDcmnttnURLAdr"))]
    pub addtl_dcmnttn_url_adr: Vec<Max2048Text>,

    #[yaserde(rename = "AddtlPrcdrDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlPrcdrDtls"))]
    pub addtl_prcdr_dtls: Vec<AdditionalRights3>,

    #[yaserde(rename = "TtlNbOfSctiesOutsdng")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlNbOfSctiesOutsdng"))]
    pub ttl_nb_of_scties_outsdng: FinancialInstrumentQuantity18Choice,

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

    #[yaserde(rename = "PrxyAppntmntNtfctnAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "PrxyAppntmntNtfctnAdr"))]
    pub prxy_appntmnt_ntfctn_adr: PostalAddress1,

    #[yaserde(rename = "PrxyChc")]
    #[cfg_attr(feature = "serde", serde(rename = "PrxyChc"))]
    pub prxy_chc: Proxy4Choice,

    #[yaserde(rename = "CtctPrsnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "CtctPrsnDtls"))]
    pub ctct_prsn_dtls: Vec<MeetingContactPerson3>,

    #[yaserde(rename = "RsltPblctnDt")]
    #[cfg_attr(feature = "serde", serde(rename = "RsltPblctnDt"))]
    pub rslt_pblctn_dt: DateFormat3Choice,

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

    #[yaserde(rename = "EntitlmntFxgDt")]
    #[cfg_attr(feature = "serde", serde(rename = "EntitlmntFxgDt"))]
    pub entitlmnt_fxg_dt: DateFormat1,

    #[yaserde(rename = "RegnSctiesDdln")]
    #[cfg_attr(feature = "serde", serde(rename = "RegnSctiesDdln"))]
    pub regn_scties_ddln: DateFormat58Choice,

    #[yaserde(rename = "RegnSctiesMktDdln")]
    #[cfg_attr(feature = "serde", serde(rename = "RegnSctiesMktDdln"))]
    pub regn_scties_mkt_ddln: DateFormat58Choice,
}

impl Validate for MeetingNotice6 {}


#[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:seev.001.001.08")]
pub struct MeetingNotificationV08 {
    #[yaserde(rename = "NtfctnGnlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "NtfctnGnlInf"))]
    pub ntfctn_gnl_inf: NotificationGeneralInformation2,

    #[yaserde(rename = "NtfctnUpd")]
    #[cfg_attr(feature = "serde", serde(rename = "NtfctnUpd"))]
    pub ntfctn_upd: NotificationUpdate2,

    #[yaserde(rename = "EvtsLkg")]
    #[cfg_attr(feature = "serde", serde(rename = "EvtsLkg"))]
    pub evts_lkg: Vec<MeetingEventReference1>,

    #[yaserde(rename = "Mtg")]
    #[cfg_attr(feature = "serde", serde(rename = "Mtg"))]
    pub mtg: MeetingNotice6,

    #[yaserde(rename = "MtgDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "MtgDtls"))]
    pub mtg_dtls: Vec<Meeting6>,

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

    #[yaserde(rename = "IssrAgt")]
    #[cfg_attr(feature = "serde", serde(rename = "IssrAgt"))]
    pub issr_agt: Vec<IssuerAgent3>,

    #[yaserde(rename = "Scty")]
    #[cfg_attr(feature = "serde", serde(rename = "Scty"))]
    pub scty: Vec<SecurityPosition12>,

    #[yaserde(rename = "Rsltn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rsltn"))]
    pub rsltn: Vec<Resolution5>,

    #[yaserde(rename = "Vote")]
    #[cfg_attr(feature = "serde", serde(rename = "Vote"))]
    pub vote: VoteParameters6,

    #[yaserde(rename = "PwrOfAttnyRqrmnts")]
    #[cfg_attr(feature = "serde", serde(rename = "PwrOfAttnyRqrmnts"))]
    pub pwr_of_attny_rqrmnts: PowerOfAttorneyRequirements4,

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

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

impl Validate for MeetingNotificationV08 {}


#[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:seev.001.001.08")]

pub enum MeetingType4Code {
    #[yaserde(rename = "XMET")]
    #[cfg_attr(feature = "serde", serde(rename = "XMET"))]
    Xmet,
    #[yaserde(rename = "GMET")]
    #[cfg_attr(feature = "serde", serde(rename = "GMET"))]
    Gmet,
    #[yaserde(rename = "MIXD")]
    #[cfg_attr(feature = "serde", serde(rename = "MIXD"))]
    Mixd,
    #[yaserde(rename = "SPCL")]
    #[cfg_attr(feature = "serde", serde(rename = "SPCL"))]
    Spcl,
    #[yaserde(rename = "BMET")]
    #[cfg_attr(feature = "serde", serde(rename = "BMET"))]
    Bmet,
    #[yaserde(rename = "CMET")]
    #[cfg_attr(feature = "serde", serde(rename = "CMET"))]
    Cmet,
    __Unknown__(String),
}

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

impl Validate for MeetingType4Code {}
#[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:seev.001.001.08")]
pub struct MeetingTypeClassification2Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<MeetingTypeClassification2Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification13>,
}

impl Validate for MeetingTypeClassification2Choice {}




#[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:seev.001.001.08")]

pub enum MeetingTypeClassification2Code {
    #[yaserde(rename = "AMET")]
    #[cfg_attr(feature = "serde", serde(rename = "AMET"))]
    Amet,
    #[yaserde(rename = "CLAS")]
    #[cfg_attr(feature = "serde", serde(rename = "CLAS"))]
    Clas,
    #[yaserde(rename = "ISSU")]
    #[cfg_attr(feature = "serde", serde(rename = "ISSU"))]
    Issu,
    #[yaserde(rename = "OMET")]
    #[cfg_attr(feature = "serde", serde(rename = "OMET"))]
    Omet,
    #[yaserde(rename = "VRHI")]
    #[cfg_attr(feature = "serde", serde(rename = "VRHI"))]
    Vrhi,
    __Unknown__(String),
}

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

impl Validate for MeetingTypeClassification2Code {}



#[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:seev.001.001.08")]
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:seev.001.001.08")]

pub enum NamePrefix1Code {
    #[yaserde(rename = "DOCT")]
    #[cfg_attr(feature = "serde", serde(rename = "DOCT"))]
    Doct,
    #[yaserde(rename = "MIST")]
    #[cfg_attr(feature = "serde", serde(rename = "MIST"))]
    Mist,
    #[yaserde(rename = "MISS")]
    #[cfg_attr(feature = "serde", serde(rename = "MISS"))]
    Miss,
    #[yaserde(rename = "MADM")]
    #[cfg_attr(feature = "serde", serde(rename = "MADM"))]
    Madm,
    __Unknown__(String),
}

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

impl Validate for NamePrefix1Code {}



#[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:seev.001.001.08")]

pub enum NamePrefix2Code {
    #[yaserde(rename = "DOCT")]
    #[cfg_attr(feature = "serde", serde(rename = "DOCT"))]
    Doct,
    #[yaserde(rename = "MADM")]
    #[cfg_attr(feature = "serde", serde(rename = "MADM"))]
    Madm,
    #[yaserde(rename = "MISS")]
    #[cfg_attr(feature = "serde", serde(rename = "MISS"))]
    Miss,
    #[yaserde(rename = "MIST")]
    #[cfg_attr(feature = "serde", serde(rename = "MIST"))]
    Mist,
    #[yaserde(rename = "MIKS")]
    #[cfg_attr(feature = "serde", serde(rename = "MIKS"))]
    Miks,
    __Unknown__(String),
}

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

impl Validate for NamePrefix2Code {}



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

    #[yaserde(rename = "IdTp")]
    #[cfg_attr(feature = "serde", serde(rename = "IdTp"))]
    pub id_tp: IdentificationType45Choice,
}

impl Validate for NaturalPersonIdentification1 {}


#[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:seev.001.001.08")]
pub struct NotificationGeneralInformation2 {
    #[yaserde(rename = "NtfctnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "NtfctnTp"))]
    pub ntfctn_tp: NotificationType3Code,

    #[yaserde(rename = "NtfctnSts")]
    #[cfg_attr(feature = "serde", serde(rename = "NtfctnSts"))]
    pub ntfctn_sts: EventStatus1,

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

impl Validate for NotificationGeneralInformation2 {}


#[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:seev.001.001.08")]

pub enum NotificationType3Code {
    #[yaserde(rename = "NEWM")]
    #[cfg_attr(feature = "serde", serde(rename = "NEWM"))]
    Newm,
    #[yaserde(rename = "REPL")]
    #[cfg_attr(feature = "serde", serde(rename = "REPL"))]
    Repl,
    #[yaserde(rename = "RMDR")]
    #[cfg_attr(feature = "serde", serde(rename = "RMDR"))]
    Rmdr,
    __Unknown__(String),
}

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

impl Validate for NotificationType3Code {}



#[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:seev.001.001.08")]
pub struct NotificationUpdate2 {
    #[yaserde(rename = "PrvsNtfctnId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvsNtfctnId"))]
    pub prvs_ntfctn_id: Max35Text,

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

impl Validate for NotificationUpdate2 {}


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

impl Validate for Number {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.001.001.08")]
pub struct NumberOrPercentage1Choice {
    #[yaserde(rename = "ThrshldPctg")]
    #[cfg_attr(feature = "serde", serde(rename = "ThrshldPctg"))]
    pub thrshld_pctg: Option<PercentageRate>,
    #[yaserde(rename = "ThrshldNb")]
    #[cfg_attr(feature = "serde", serde(rename = "ThrshldNb"))]
    pub thrshld_nb: Option<Number>,
}

impl Validate for NumberOrPercentage1Choice {}




#[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:seev.001.001.08")]
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:seev.001.001.08")]
pub struct ParticipationMethod1 {
    #[yaserde(rename = "PrtcptnMtd")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtcptnMtd"))]
    pub prtcptn_mtd: ParticipationMethod1Choice,

    #[yaserde(rename = "IssrDdlnForVtng")]
    #[cfg_attr(feature = "serde", serde(rename = "IssrDdlnForVtng"))]
    pub issr_ddln_for_vtng: DateFormat58Choice,
}

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

impl Validate for ParticipationMethod1Choice {}
#[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:seev.001.001.08")]
pub struct PartyIdentification129Choice {
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_b_i_c: Option<AnyBICDec2014Identifier>,
    #[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>,
    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Option<Leiidentifier>,
}

impl Validate for PartyIdentification129Choice {}
#[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:seev.001.001.08")]
pub struct PartyIdentification198Choice {
    #[yaserde(rename = "NtlRegnNb")]
    #[cfg_attr(feature = "serde", serde(rename = "NtlRegnNb"))]
    pub ntl_regn_nb: Option<Max35Text>,
    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Option<Leiidentifier>,
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_b_i_c: Option<AnyBICDec2014Identifier>,
    #[yaserde(rename = "ClntId")]
    #[cfg_attr(feature = "serde", serde(rename = "ClntId"))]
    pub clnt_id: Option<Max50Text>,
    #[yaserde(rename = "PrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
    pub prtry_id: Option<GenericIdentification36>,
}

impl Validate for PartyIdentification198Choice {}




#[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:seev.001.001.08")]
pub struct PartyIdentification221 {
    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: PersonName2,

    #[yaserde(rename = "EmailAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "EmailAdr"))]
    pub email_adr: Max256Text,

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

impl Validate for PartyIdentification221 {}


#[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:seev.001.001.08")]
pub struct PartyIdentification224 {
    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: PersonName2,

    #[yaserde(rename = "EmailAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "EmailAdr"))]
    pub email_adr: Max256Text,

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

impl Validate for PartyIdentification224 {}
#[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:seev.001.001.08")]
pub struct PartyIdentification231Choice {
    #[yaserde(rename = "LglPrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "LglPrsn"))]
    pub lgl_prsn: Option<PartyIdentification221>,
    #[yaserde(rename = "NtrlPrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "NtrlPrsn"))]
    pub ntrl_prsn: Vec<PartyIdentification238>,
}

impl Validate for PartyIdentification231Choice {}
#[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:seev.001.001.08")]
pub struct PartyIdentification232Choice {
    #[yaserde(rename = "LglPrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "LglPrsn"))]
    pub lgl_prsn: Option<PartyIdentification221>,
    #[yaserde(rename = "NtrlPrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "NtrlPrsn"))]
    pub ntrl_prsn: Option<PartyIdentification238>,
}

impl Validate for PartyIdentification232Choice {}
#[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:seev.001.001.08")]
pub struct PartyIdentification233Choice {
    #[yaserde(rename = "LglPrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "LglPrsn"))]
    pub lgl_prsn: Option<PartyIdentification224>,
    #[yaserde(rename = "NtrlPrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "NtrlPrsn"))]
    pub ntrl_prsn: Vec<PartyIdentification240>,
}

impl Validate for PartyIdentification233Choice {}




#[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:seev.001.001.08")]
pub struct PartyIdentification238 {
    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: PersonName3,

    #[yaserde(rename = "EmailAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "EmailAdr"))]
    pub email_adr: Max256Text,

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

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

    #[yaserde(rename = "DtAndPlcOfBirth")]
    #[cfg_attr(feature = "serde", serde(rename = "DtAndPlcOfBirth"))]
    pub dt_and_plc_of_birth: DateAndPlaceOfBirth2,
}

impl Validate for PartyIdentification238 {}


#[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:seev.001.001.08")]
pub struct PartyIdentification240 {
    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: PersonName3,

    #[yaserde(rename = "EmailAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "EmailAdr"))]
    pub email_adr: Max256Text,

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

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

    #[yaserde(rename = "DtAndPlcOfBirth")]
    #[cfg_attr(feature = "serde", serde(rename = "DtAndPlcOfBirth"))]
    pub dt_and_plc_of_birth: DateAndPlaceOfBirth2,
}

impl Validate for PartyIdentification240 {}


#[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:seev.001.001.08")]
pub struct PersonName2 {
    #[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: PostalAddress26,
}

impl Validate for PersonName2 {}


#[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:seev.001.001.08")]
pub struct PersonName3 {
    #[yaserde(rename = "NmPrfx")]
    #[cfg_attr(feature = "serde", serde(rename = "NmPrfx"))]
    pub nm_prfx: NamePrefix2Code,

    #[yaserde(rename = "FrstNm")]
    #[cfg_attr(feature = "serde", serde(rename = "FrstNm"))]
    pub frst_nm: Max350Text,

    #[yaserde(rename = "Srnm")]
    #[cfg_attr(feature = "serde", serde(rename = "Srnm"))]
    pub srnm: Max350Text,

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

impl Validate for PersonName3 {}


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

impl Validate for PhoneNumber {}
#[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:seev.001.001.08")]

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

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

impl Validate for PlaceType1Code {}



#[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:seev.001.001.08")]
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:seev.001.001.08")]
pub struct PostalAddress26 {
    #[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 = "PstBx")]
    #[cfg_attr(feature = "serde", serde(rename = "PstBx"))]
    pub pst_bx: 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 PostalAddress26 {}


#[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:seev.001.001.08")]

pub enum PowerOfAttorneyLegalisation1Code {
    #[yaserde(rename = "NOTA")]
    #[cfg_attr(feature = "serde", serde(rename = "NOTA"))]
    Nota,
    #[yaserde(rename = "LOCA")]
    #[cfg_attr(feature = "serde", serde(rename = "LOCA"))]
    Loca,
    #[yaserde(rename = "APOS")]
    #[cfg_attr(feature = "serde", serde(rename = "APOS"))]
    Apos,
    #[yaserde(rename = "COUN")]
    #[cfg_attr(feature = "serde", serde(rename = "COUN"))]
    Coun,
    __Unknown__(String),
}

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

impl Validate for PowerOfAttorneyLegalisation1Code {}



#[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:seev.001.001.08")]
pub struct PowerOfAttorneyRequirements4 {
    #[yaserde(rename = "LglRqrmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "LglRqrmnt"))]
    pub lgl_rqrmnt: Vec<PowerOfAttorneyLegalisation1Code>,

    #[yaserde(rename = "OthrDcmnttn")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrDcmnttn"))]
    pub othr_dcmnttn: Max350Text,

    #[yaserde(rename = "DocSubmissnDdln")]
    #[cfg_attr(feature = "serde", serde(rename = "DocSubmissnDdln"))]
    pub doc_submissn_ddln: DateFormat58Choice,
}

impl Validate for PowerOfAttorneyRequirements4 {}
#[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:seev.001.001.08")]
pub struct PriceRateOrAmount3Choice {
    #[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 PriceRateOrAmount3Choice {}




#[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:seev.001.001.08")]

pub enum ProcessingPosition3Code {
    #[yaserde(rename = "AFTE")]
    #[cfg_attr(feature = "serde", serde(rename = "AFTE"))]
    Afte,
    #[yaserde(rename = "WITH")]
    #[cfg_attr(feature = "serde", serde(rename = "WITH"))]
    With,
    #[yaserde(rename = "BEFO")]
    #[cfg_attr(feature = "serde", serde(rename = "BEFO"))]
    Befo,
    #[yaserde(rename = "INFO")]
    #[cfg_attr(feature = "serde", serde(rename = "INFO"))]
    Info,
    __Unknown__(String),
}

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

impl Validate for ProcessingPosition3Code {}
#[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:seev.001.001.08")]
pub struct Proxy4Choice {
    #[yaserde(rename = "Prxy")]
    #[cfg_attr(feature = "serde", serde(rename = "Prxy"))]
    pub prxy: Option<ProxyAppointmentInformation5>,
    #[yaserde(rename = "PrxyNotAllwd")]
    #[cfg_attr(feature = "serde", serde(rename = "PrxyNotAllwd"))]
    pub prxy_not_allwd: Option<ProxyNotAllowed1Code>,
}

impl Validate for Proxy4Choice {}




#[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:seev.001.001.08")]
pub struct Proxy9 {
    #[yaserde(rename = "PrxyTp")]
    #[cfg_attr(feature = "serde", serde(rename = "PrxyTp"))]
    pub prxy_tp: ProxyType2Code,

    #[yaserde(rename = "PrsnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "PrsnDtls"))]
    pub prsn_dtls: IndividualPerson43,
}

impl Validate for Proxy9 {}


#[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:seev.001.001.08")]
pub struct ProxyAppointmentInformation5 {
    #[yaserde(rename = "RegnMtd")]
    #[cfg_attr(feature = "serde", serde(rename = "RegnMtd"))]
    pub regn_mtd: Max350Text,

    #[yaserde(rename = "Ddln")]
    #[cfg_attr(feature = "serde", serde(rename = "Ddln"))]
    pub ddln: DateFormat58Choice,

    #[yaserde(rename = "MktDdln")]
    #[cfg_attr(feature = "serde", serde(rename = "MktDdln"))]
    pub mkt_ddln: DateFormat58Choice,

    #[yaserde(rename = "AuthrsdPrxy")]
    #[cfg_attr(feature = "serde", serde(rename = "AuthrsdPrxy"))]
    pub authrsd_prxy: Vec<Proxy9>,
}

impl Validate for ProxyAppointmentInformation5 {}


#[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:seev.001.001.08")]

pub enum ProxyNotAllowed1Code {
    #[yaserde(rename = "NPRO")]
    #[cfg_attr(feature = "serde", serde(rename = "NPRO"))]
    Npro,
    __Unknown__(String),
}

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

impl Validate for ProxyNotAllowed1Code {}



#[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:seev.001.001.08")]

pub enum ProxyType2Code {
    #[yaserde(rename = "CHRM")]
    #[cfg_attr(feature = "serde", serde(rename = "CHRM"))]
    Chrm,
    #[yaserde(rename = "DISC")]
    #[cfg_attr(feature = "serde", serde(rename = "DISC"))]
    Disc,
    #[yaserde(rename = "HLDR")]
    #[cfg_attr(feature = "serde", serde(rename = "HLDR"))]
    Hldr,
    __Unknown__(String),
}

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

impl Validate for ProxyType2Code {}
#[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:seev.001.001.08")]
pub struct QuorumQuantity1Choice {
    #[yaserde(rename = "QrmQty")]
    #[cfg_attr(feature = "serde", serde(rename = "QrmQty"))]
    pub qrm_qty: Option<Max35Text>,
    #[yaserde(rename = "QrmQtyPctg")]
    #[cfg_attr(feature = "serde", serde(rename = "QrmQtyPctg"))]
    pub qrm_qty_pctg: Option<PercentageRate>,
}

impl Validate for QuorumQuantity1Choice {}




#[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:seev.001.001.08")]
pub struct Resolution5 {
    #[yaserde(rename = "IssrLabl")]
    #[cfg_attr(feature = "serde", serde(rename = "IssrLabl"))]
    pub issr_labl: Max35Text,

    #[yaserde(rename = "Desc")]
    #[cfg_attr(feature = "serde", serde(rename = "Desc"))]
    pub desc: Vec<ItemDescription1>,

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

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

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

    #[yaserde(rename = "VoteTp")]
    #[cfg_attr(feature = "serde", serde(rename = "VoteTp"))]
    pub vote_tp: VoteType1Code,

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

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

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

    #[yaserde(rename = "VoteInstrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "VoteInstrTp"))]
    pub vote_instr_tp: Vec<VoteInstructionType1>,

    #[yaserde(rename = "MgmtRcmmndtn")]
    #[cfg_attr(feature = "serde", serde(rename = "MgmtRcmmndtn"))]
    pub mgmt_rcmmndtn: VoteInstruction5Code,

    #[yaserde(rename = "NtifngPtyRcmmndtn")]
    #[cfg_attr(feature = "serde", serde(rename = "NtifngPtyRcmmndtn"))]
    pub ntifng_pty_rcmmndtn: VoteInstruction5Code,

    #[yaserde(rename = "Entitlmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "Entitlmnt"))]
    pub entitlmnt: Entitlement1Choice,

    #[yaserde(rename = "VtngRghtsThrshldForApprvl")]
    #[cfg_attr(feature = "serde", serde(rename = "VtngRghtsThrshldForApprvl"))]
    pub vtng_rghts_thrshld_for_apprvl: NumberOrPercentage1Choice,

    #[yaserde(rename = "URLAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "URLAdr"))]
    pub url_adr: Max2048Text,
}

impl Validate for Resolution5 {}


#[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:seev.001.001.08")]

pub enum ResolutionStatus1Code {
    #[yaserde(rename = "ACTV")]
    #[cfg_attr(feature = "serde", serde(rename = "ACTV"))]
    Actv,
    #[yaserde(rename = "WDRA")]
    #[cfg_attr(feature = "serde", serde(rename = "WDRA"))]
    Wdra,
    __Unknown__(String),
}

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

impl Validate for ResolutionStatus1Code {}



#[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:seev.001.001.08")]

pub enum ResolutionType2Code {
    #[yaserde(rename = "EXTR")]
    #[cfg_attr(feature = "serde", serde(rename = "EXTR"))]
    Extr,
    #[yaserde(rename = "SPCL")]
    #[cfg_attr(feature = "serde", serde(rename = "SPCL"))]
    Spcl,
    __Unknown__(String),
}

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

impl Validate for ResolutionType2Code {}



#[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:seev.001.001.08")]

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:seev.001.001.08")]

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

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

impl Validate for SafekeepingPlace2Code {}
#[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:seev.001.001.08")]
pub struct SafekeepingPlaceFormat28Choice {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Option<SafekeepingPlaceTypeAndText6>,
    #[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<SafekeepingPlaceTypeAndIdentification1>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification78>,
}

impl Validate for SafekeepingPlaceFormat28Choice {}




#[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:seev.001.001.08")]
pub struct SafekeepingPlaceTypeAndIdentification1 {
    #[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: AnyBICDec2014Identifier,
}

impl Validate for SafekeepingPlaceTypeAndIdentification1 {}


#[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:seev.001.001.08")]
pub struct SafekeepingPlaceTypeAndText6 {
    #[yaserde(rename = "SfkpgPlcTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgPlcTp"))]
    pub sfkpg_plc_tp: SafekeepingPlace2Code,

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

impl Validate for SafekeepingPlaceTypeAndText6 {}


#[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:seev.001.001.08")]

pub enum SecuritiesEntryType2Code {
    #[yaserde(rename = "BLOK")]
    #[cfg_attr(feature = "serde", serde(rename = "BLOK"))]
    Blok,
    #[yaserde(rename = "ELIG")]
    #[cfg_attr(feature = "serde", serde(rename = "ELIG"))]
    Elig,
    #[yaserde(rename = "PEND")]
    #[cfg_attr(feature = "serde", serde(rename = "PEND"))]
    Pend,
    #[yaserde(rename = "PENR")]
    #[cfg_attr(feature = "serde", serde(rename = "PENR"))]
    Penr,
    #[yaserde(rename = "NOMI")]
    #[cfg_attr(feature = "serde", serde(rename = "NOMI"))]
    Nomi,
    #[yaserde(rename = "SETD")]
    #[cfg_attr(feature = "serde", serde(rename = "SETD"))]
    Setd,
    #[yaserde(rename = "BORR")]
    #[cfg_attr(feature = "serde", serde(rename = "BORR"))]
    Borr,
    #[yaserde(rename = "LOAN")]
    #[cfg_attr(feature = "serde", serde(rename = "LOAN"))]
    Loan,
    #[yaserde(rename = "SPOS")]
    #[cfg_attr(feature = "serde", serde(rename = "SPOS"))]
    Spos,
    #[yaserde(rename = "TRAD")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAD"))]
    Trad,
    #[yaserde(rename = "COLI")]
    #[cfg_attr(feature = "serde", serde(rename = "COLI"))]
    Coli,
    #[yaserde(rename = "COLO")]
    #[cfg_attr(feature = "serde", serde(rename = "COLO"))]
    Colo,
    #[yaserde(rename = "UNBA")]
    #[cfg_attr(feature = "serde", serde(rename = "UNBA"))]
    Unba,
    #[yaserde(rename = "INBA")]
    #[cfg_attr(feature = "serde", serde(rename = "INBA"))]
    Inba,
    #[yaserde(rename = "REGO")]
    #[cfg_attr(feature = "serde", serde(rename = "REGO"))]
    Rego,
    __Unknown__(String),
}

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

impl Validate for SecuritiesEntryType2Code {}



#[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:seev.001.001.08")]
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:seev.001.001.08")]
pub struct SecurityPosition12 {
    #[yaserde(rename = "FinInstrmId")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrmId"))]
    pub fin_instrm_id: SecurityIdentification19,

    #[yaserde(rename = "Pos")]
    #[cfg_attr(feature = "serde", serde(rename = "Pos"))]
    pub pos: Vec<EligiblePosition9>,
}

impl Validate for SecurityPosition12 {}


#[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:seev.001.001.08")]
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:seev.001.001.08")]
pub struct SupplementaryDataEnvelope1 {}

impl Validate for SupplementaryDataEnvelope1 {}


#[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:seev.001.001.08")]

pub enum TypeOfIdentification4Code {
    #[yaserde(rename = "ARNU")]
    #[cfg_attr(feature = "serde", serde(rename = "ARNU"))]
    Arnu,
    #[yaserde(rename = "CUST")]
    #[cfg_attr(feature = "serde", serde(rename = "CUST"))]
    Cust,
    #[yaserde(rename = "CORP")]
    #[cfg_attr(feature = "serde", serde(rename = "CORP"))]
    Corp,
    #[yaserde(rename = "DRLC")]
    #[cfg_attr(feature = "serde", serde(rename = "DRLC"))]
    Drlc,
    #[yaserde(rename = "IDCD")]
    #[cfg_attr(feature = "serde", serde(rename = "IDCD"))]
    Idcd,
    #[yaserde(rename = "NRIN")]
    #[cfg_attr(feature = "serde", serde(rename = "NRIN"))]
    Nrin,
    #[yaserde(rename = "CCPT")]
    #[cfg_attr(feature = "serde", serde(rename = "CCPT"))]
    Ccpt,
    #[yaserde(rename = "SOCS")]
    #[cfg_attr(feature = "serde", serde(rename = "SOCS"))]
    Socs,
    #[yaserde(rename = "TXID")]
    #[cfg_attr(feature = "serde", serde(rename = "TXID"))]
    Txid,
    __Unknown__(String),
}

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

impl Validate for TypeOfIdentification4Code {}



#[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:seev.001.001.08")]

pub enum VoteInstruction5Code {
    #[yaserde(rename = "ABST")]
    #[cfg_attr(feature = "serde", serde(rename = "ABST"))]
    Abst,
    #[yaserde(rename = "CAGS")]
    #[cfg_attr(feature = "serde", serde(rename = "CAGS"))]
    Cags,
    #[yaserde(rename = "CHRM")]
    #[cfg_attr(feature = "serde", serde(rename = "CHRM"))]
    Chrm,
    #[yaserde(rename = "CFOR")]
    #[cfg_attr(feature = "serde", serde(rename = "CFOR"))]
    Cfor,
    #[yaserde(rename = "NOAC")]
    #[cfg_attr(feature = "serde", serde(rename = "NOAC"))]
    Noac,
    #[yaserde(rename = "WTHH")]
    #[cfg_attr(feature = "serde", serde(rename = "WTHH"))]
    Wthh,
    #[yaserde(rename = "ONEY")]
    #[cfg_attr(feature = "serde", serde(rename = "ONEY"))]
    Oney,
    #[yaserde(rename = "THRY")]
    #[cfg_attr(feature = "serde", serde(rename = "THRY"))]
    Thry,
    #[yaserde(rename = "TWOY")]
    #[cfg_attr(feature = "serde", serde(rename = "TWOY"))]
    Twoy,
    #[yaserde(rename = "BLNK")]
    #[cfg_attr(feature = "serde", serde(rename = "BLNK"))]
    Blnk,
    #[yaserde(rename = "NREC")]
    #[cfg_attr(feature = "serde", serde(rename = "NREC"))]
    Nrec,
    __Unknown__(String),
}

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

impl Validate for VoteInstruction5Code {}



#[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:seev.001.001.08")]

pub enum VoteInstruction6Code {
    #[yaserde(rename = "ABST")]
    #[cfg_attr(feature = "serde", serde(rename = "ABST"))]
    Abst,
    #[yaserde(rename = "CAGS")]
    #[cfg_attr(feature = "serde", serde(rename = "CAGS"))]
    Cags,
    #[yaserde(rename = "AMGT")]
    #[cfg_attr(feature = "serde", serde(rename = "AMGT"))]
    Amgt,
    #[yaserde(rename = "BLNK")]
    #[cfg_attr(feature = "serde", serde(rename = "BLNK"))]
    Blnk,
    #[yaserde(rename = "CHRM")]
    #[cfg_attr(feature = "serde", serde(rename = "CHRM"))]
    Chrm,
    #[yaserde(rename = "DISC")]
    #[cfg_attr(feature = "serde", serde(rename = "DISC"))]
    Disc,
    #[yaserde(rename = "CFOR")]
    #[cfg_attr(feature = "serde", serde(rename = "CFOR"))]
    Cfor,
    #[yaserde(rename = "NOAC")]
    #[cfg_attr(feature = "serde", serde(rename = "NOAC"))]
    Noac,
    #[yaserde(rename = "ONEY")]
    #[cfg_attr(feature = "serde", serde(rename = "ONEY"))]
    Oney,
    #[yaserde(rename = "THRY")]
    #[cfg_attr(feature = "serde", serde(rename = "THRY"))]
    Thry,
    #[yaserde(rename = "TWOY")]
    #[cfg_attr(feature = "serde", serde(rename = "TWOY"))]
    Twoy,
    #[yaserde(rename = "WTHH")]
    #[cfg_attr(feature = "serde", serde(rename = "WTHH"))]
    Wthh,
    #[yaserde(rename = "WMGT")]
    #[cfg_attr(feature = "serde", serde(rename = "WMGT"))]
    Wmgt,
    __Unknown__(String),
}

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

impl Validate for VoteInstruction6Code {}



#[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:seev.001.001.08")]
pub struct VoteInstructionType1 {
    #[yaserde(rename = "VoteInstrTpCd")]
    #[cfg_attr(feature = "serde", serde(rename = "VoteInstrTpCd"))]
    pub vote_instr_tp_cd: VoteInstructionType1Choice,

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

impl Validate for VoteInstructionType1 {}
#[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:seev.001.001.08")]
pub struct VoteInstructionType1Choice {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: Option<VoteInstruction6Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification30>,
}

impl Validate for VoteInstructionType1Choice {}




#[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:seev.001.001.08")]
pub struct VoteMethods3 {
    #[yaserde(rename = "VoteThrghNtwk")]
    #[cfg_attr(feature = "serde", serde(rename = "VoteThrghNtwk"))]
    pub vote_thrgh_ntwk: Vec<AnyBICDec2014Identifier>,

    #[yaserde(rename = "VoteByMail")]
    #[cfg_attr(feature = "serde", serde(rename = "VoteByMail"))]
    pub vote_by_mail: Vec<PostalAddress1>,

    #[yaserde(rename = "ElctrncVote")]
    #[cfg_attr(feature = "serde", serde(rename = "ElctrncVote"))]
    pub elctrnc_vote: Vec<CommunicationAddress11>,

    #[yaserde(rename = "VoteByTel")]
    #[cfg_attr(feature = "serde", serde(rename = "VoteByTel"))]
    pub vote_by_tel: Vec<Max35Text>,
}

impl Validate for VoteMethods3 {}


#[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:seev.001.001.08")]
pub struct VoteParameters6 {
    #[yaserde(rename = "SctiesQtyReqrdToVote")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesQtyReqrdToVote"))]
    pub scties_qty_reqrd_to_vote: FinancialInstrumentQuantity18Choice,

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

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

    #[yaserde(rename = "VoteDdln")]
    #[cfg_attr(feature = "serde", serde(rename = "VoteDdln"))]
    pub vote_ddln: DateFormat58Choice,

    #[yaserde(rename = "VoteMktDdln")]
    #[cfg_attr(feature = "serde", serde(rename = "VoteMktDdln"))]
    pub vote_mkt_ddln: DateFormat58Choice,

    #[yaserde(rename = "VoteMthds")]
    #[cfg_attr(feature = "serde", serde(rename = "VoteMthds"))]
    pub vote_mthds: VoteMethods3,

    #[yaserde(rename = "VtngBlltElctrncAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "VtngBlltElctrncAdr"))]
    pub vtng_bllt_elctrnc_adr: CommunicationAddress11,

    #[yaserde(rename = "VtngBlltReqAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "VtngBlltReqAdr"))]
    pub vtng_bllt_req_adr: PostalAddress1,

    #[yaserde(rename = "RvcbltyDdln")]
    #[cfg_attr(feature = "serde", serde(rename = "RvcbltyDdln"))]
    pub rvcblty_ddln: DateFormat58Choice,

    #[yaserde(rename = "RvcbltyMktDdln")]
    #[cfg_attr(feature = "serde", serde(rename = "RvcbltyMktDdln"))]
    pub rvcblty_mkt_ddln: DateFormat58Choice,

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

    #[yaserde(rename = "EarlyIncntivPrm")]
    #[cfg_attr(feature = "serde", serde(rename = "EarlyIncntivPrm"))]
    pub early_incntiv_prm: IncentivePremium5,

    #[yaserde(rename = "IncntivPrm")]
    #[cfg_attr(feature = "serde", serde(rename = "IncntivPrm"))]
    pub incntiv_prm: IncentivePremium5,

    #[yaserde(rename = "EarlyVoteWthPrmDdln")]
    #[cfg_attr(feature = "serde", serde(rename = "EarlyVoteWthPrmDdln"))]
    pub early_vote_wth_prm_ddln: DateFormat58Choice,

    #[yaserde(rename = "VoteWthPrmDdln")]
    #[cfg_attr(feature = "serde", serde(rename = "VoteWthPrmDdln"))]
    pub vote_wth_prm_ddln: DateFormat58Choice,

    #[yaserde(rename = "VoteWthPrmMktDdln")]
    #[cfg_attr(feature = "serde", serde(rename = "VoteWthPrmMktDdln"))]
    pub vote_wth_prm_mkt_ddln: DateFormat58Choice,

    #[yaserde(rename = "AddtlVtngRqrmnts")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlVtngRqrmnts"))]
    pub addtl_vtng_rqrmnts: Max350Text,

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

impl Validate for VoteParameters6 {}


#[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:seev.001.001.08")]

pub enum VoteType1Code {
    #[yaserde(rename = "ADVI")]
    #[cfg_attr(feature = "serde", serde(rename = "ADVI"))]
    Advi,
    #[yaserde(rename = "BNDG")]
    #[cfg_attr(feature = "serde", serde(rename = "BNDG"))]
    Bndg,
    __Unknown__(String),
}

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

impl Validate for VoteType1Code {}



#[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:seev.001.001.08")]
pub struct VoteTypeAndQuantity1 {
    #[yaserde(rename = "VoteInstrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "VoteInstrTp"))]
    pub vote_instr_tp: VoteInstructionType1Choice,

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

impl Validate for VoteTypeAndQuantity1 {}


#[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:seev.001.001.08")]

pub enum VotingParticipationMethod1Code {
    #[yaserde(rename = "MAIL")]
    #[cfg_attr(feature = "serde", serde(rename = "MAIL"))]
    Mail,
    #[yaserde(rename = "PHYS")]
    #[cfg_attr(feature = "serde", serde(rename = "PHYS"))]
    Phys,
    #[yaserde(rename = "PHNV")]
    #[cfg_attr(feature = "serde", serde(rename = "PHNV"))]
    Phnv,
    #[yaserde(rename = "PRXY")]
    #[cfg_attr(feature = "serde", serde(rename = "PRXY"))]
    Prxy,
    #[yaserde(rename = "VIRT")]
    #[cfg_attr(feature = "serde", serde(rename = "VIRT"))]
    Virt,
    #[yaserde(rename = "EVOT")]
    #[cfg_attr(feature = "serde", serde(rename = "EVOT"))]
    Evot,
    __Unknown__(String),
}

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

impl Validate for VotingParticipationMethod1Code {}



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