rust_iso20022 0.1.0

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

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

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

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

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.13")]
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.13")]
pub struct AdditionalRightThreshold2Choice {
    #[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<Percentage14Rate>,
}

impl Validate for AdditionalRightThreshold2Choice {}




#[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.13")]
pub struct AdditionalRights4 {
    #[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: AdditionalRightThreshold2Choice,
}

impl Validate for AdditionalRights4 {}


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

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.13")]

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.13")]
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.13")]
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.13")]

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.13")]
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.13")]
pub struct CommunicationAddress12 {
    #[yaserde(rename = "URLAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "URLAdr"))]
    pub url_adr: Max2048Text,
}

impl Validate for CommunicationAddress12 {}


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

    #[yaserde(rename = "PrcgTxtForNxtIntrmy")]
    #[cfg_attr(feature = "serde", serde(rename = "PrcgTxtForNxtIntrmy"))]
    pub prcg_txt_for_nxt_intrmy: Vec<Max8000Text>,
}

impl Validate for CorporateEventNarrative4 {}


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

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

impl Validate for DateCode34Choice {}




#[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.13")]
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.13")]
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.13")]
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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.001.001.13")]
pub struct DateFormat60Choice {
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Option<DateAndDateTime2Choice>,
    #[yaserde(rename = "DtCd")]
    #[cfg_attr(feature = "serde", serde(rename = "DtCd"))]
    pub dt_cd: Option<DateCode34Choice>,
}

impl Validate for DateFormat60Choice {}




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

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.13")]

pub enum DateType10Code {
    #[yaserde(rename = "MEET")]
    #[cfg_attr(feature = "serde", serde(rename = "MEET"))]
    Meet,
    #[yaserde(rename = "UKWN")]
    #[cfg_attr(feature = "serde", serde(rename = "UKWN"))]
    Ukwn,
    #[yaserde(rename = "NARR")]
    #[cfg_attr(feature = "serde", serde(rename = "NARR"))]
    Narr,
    #[yaserde(rename = "RDTE")]
    #[cfg_attr(feature = "serde", serde(rename = "RDTE"))]
    Rdte,
    #[yaserde(rename = "PPYD")]
    #[cfg_attr(feature = "serde", serde(rename = "PPYD"))]
    Ppyd,
    __Unknown__(String),
}

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

impl Validate for DateType10Code {}



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

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

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.13")]
pub struct EligiblePosition18 {
    #[yaserde(rename = "AcctId")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctId"))]
    pub acct_id: Max35Text,

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

    #[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<HoldingBalance14>,

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

impl Validate for EligiblePosition18 {}
#[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.13")]
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.13")]

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.13")]

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.13")]
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.13")]
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.13")]
pub struct FinancialInstrumentQuantity45Choice {
    #[yaserde(rename = "Unit")]
    #[cfg_attr(feature = "serde", serde(rename = "Unit"))]
    pub unit: Option<DecimalNumber>,
    #[yaserde(rename = "FaceAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "FaceAmt"))]
    pub face_amt: Option<ImpliedCurrencyAndAmount>,
    #[yaserde(rename = "DgtlTknUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "DgtlTknUnit"))]
    pub dgtl_tkn_unit: Option<Max30DecimalNumber>,
}

impl Validate for FinancialInstrumentQuantity45Choice {}




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

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

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

impl Validate for HoldingBalance14 {}


#[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.13")]
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.13")]
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.13")]
pub struct IncentivePremium6 {
    #[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: PriceRateOrAmount8Choice,

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

pub enum InvestorClassificationType1Code {
    #[yaserde(rename = "ELIG")]
    #[cfg_attr(feature = "serde", serde(rename = "ELIG"))]
    Elig,
    #[yaserde(rename = "NLIG")]
    #[cfg_attr(feature = "serde", serde(rename = "NLIG"))]
    Nlig,
    #[yaserde(rename = "NQIB")]
    #[cfg_attr(feature = "serde", serde(rename = "NQIB"))]
    Nqib,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "QUIB")]
    #[cfg_attr(feature = "serde", serde(rename = "QUIB"))]
    Quib,
    __Unknown__(String),
}

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

impl Validate for InvestorClassificationType1Code {}



#[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.13")]
pub struct InvestorTypeIdentification1 {
    #[yaserde(rename = "InvstrTpId")]
    #[cfg_attr(feature = "serde", serde(rename = "InvstrTpId"))]
    pub invstr_tp_id: InvestorClassificationType1Code,

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

impl Validate for InvestorTypeIdentification1 {}


#[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.13")]
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.13")]
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.13")]
pub struct ItemDescription2 {
    #[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: Max1025Text,

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

impl Validate for ItemDescription2 {}


#[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.13")]
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.13")]
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.001.001.13")]
pub struct MailAddress1 {
    #[yaserde(rename = "Crspdc")]
    #[cfg_attr(feature = "serde", serde(rename = "Crspdc"))]
    pub crspdc: Vec<PostalAddress1>,

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

impl Validate for MailAddress1 {}


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

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

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

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

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct 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.13")]
pub struct Meeting7 {
    #[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: QuorumQuantity2Choice,

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

impl Validate for Meeting7 {}


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

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.13")]
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.13")]
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.13")]
pub struct MeetingNotice10 {
    #[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<ParticipationMethod3>,

    #[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 = "EvtPrcgWebSiteAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "EvtPrcgWebSiteAdr"))]
    pub evt_prcg_web_site_adr: Max2048Text,

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

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

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

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

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

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

impl Validate for MeetingNotice10 {}


#[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.13")]
pub struct MeetingNotificationV13 {
    #[yaserde(rename = "Pgntn")]
    #[cfg_attr(feature = "serde", serde(rename = "Pgntn"))]
    pub pgntn: Pagination1,

    #[yaserde(rename = "NtfctnGnlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "NtfctnGnlInf"))]
    pub ntfctn_gnl_inf: NotificationGeneralInformation4,

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

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

    #[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<SecurityPosition20>,

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

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

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

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

impl Validate for MeetingNotificationV13 {}


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

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.13")]
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.13")]

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.13")]
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.13")]

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.13")]

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.13")]
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.13")]
pub struct NotificationGeneralInformation4 {
    #[yaserde(rename = "NtfctnId")]
    #[cfg_attr(feature = "serde", serde(rename = "NtfctnId"))]
    pub ntfctn_id: Max35Text,

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

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

impl Validate for NotificationGeneralInformation4 {}


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

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.13")]
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.13")]
pub struct NumberOrPercentage2Choice {
    #[yaserde(rename = "ThrshldPctg")]
    #[cfg_attr(feature = "serde", serde(rename = "ThrshldPctg"))]
    pub thrshld_pctg: Option<Percentage14Rate>,
    #[yaserde(rename = "ThrshldNb")]
    #[cfg_attr(feature = "serde", serde(rename = "ThrshldNb"))]
    pub thrshld_nb: Option<Number>,
}

impl Validate for NumberOrPercentage2Choice {}




#[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.13")]
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.13")]
pub struct Pagination1 {
    #[yaserde(rename = "PgNb")]
    #[cfg_attr(feature = "serde", serde(rename = "PgNb"))]
    pub pg_nb: Max5NumericText,

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

impl Validate for Pagination1 {}


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

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

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

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

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

    #[yaserde(rename = "InvstrTpId")]
    #[cfg_attr(feature = "serde", serde(rename = "InvstrTpId"))]
    pub invstr_tp_id: Vec<InvestorTypeIdentification1>,
}

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

impl Validate for ParticipationMethod3Choice {}
#[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.13")]
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.13")]
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.13")]
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.13")]
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.13")]
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.13")]
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.13")]
pub struct PartyIdentification246Choice {
    #[yaserde(rename = "LglPrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "LglPrsn"))]
    pub lgl_prsn: Option<PartyIdentification269>,
    #[yaserde(rename = "NtrlPrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "NtrlPrsn"))]
    pub ntrl_prsn: Vec<PartyIdentification250>,
}

impl Validate for PartyIdentification246Choice {}




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

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

impl Validate for PartyIdentification250 {}


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

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

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

impl Validate for PartyIdentification269 {}


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

impl Validate for Percentage14Rate {}
#[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.13")]
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.13")]
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.13")]

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.13")]
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.13")]
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.13")]

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.13")]
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.13")]
pub struct PriceRateOrAmount8Choice {
    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: Option<Percentage14Rate>,
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<ActiveOrHistoricCurrencyAnd13DecimalAmount>,
}

impl Validate for PriceRateOrAmount8Choice {}




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

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

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

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

impl Validate for Proxy5Choice {}




#[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.13")]
pub struct ProxyAppointmentInformation6 {
    #[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<Proxy11>,
}

impl Validate for ProxyAppointmentInformation6 {}


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

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.13")]

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

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

impl Validate for ProxyType3Code {}
#[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.13")]
pub struct QuorumQuantity2Choice {
    #[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<Percentage14Rate>,
}

impl Validate for QuorumQuantity2Choice {}




#[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.13")]
pub struct Resolution8 {
    #[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<ItemDescription2>,

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

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

impl Validate for Resolution8 {}


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

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.13")]

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.13")]

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.13")]

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.13")]
pub struct SafekeepingPlaceFormat42Choice {
    #[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 = "DgtlLdgrId")]
    #[cfg_attr(feature = "serde", serde(rename = "DgtlLdgrId"))]
    pub dgtl_ldgr_id: Option<Dti2024Identifier>,
    #[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 SafekeepingPlaceFormat42Choice {}




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

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.13")]
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.13")]
pub struct SecurityPosition20 {
    #[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<EligiblePosition18>,
}

impl Validate for SecurityPosition20 {}


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

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

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

impl Validate for ShortLong1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.001.001.13")]
pub struct SignedQuantityFormat14 {
    #[yaserde(rename = "ShrtLngPos")]
    #[cfg_attr(feature = "serde", serde(rename = "ShrtLngPos"))]
    pub shrt_lng_pos: ShortLong1Code,

    #[yaserde(rename = "Qty")]
    #[cfg_attr(feature = "serde", serde(rename = "Qty"))]
    pub qty: FinancialInstrumentQuantity45Choice,
}

impl Validate for SignedQuantityFormat14 {}


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

impl Validate for SupplementaryDataEnvelope1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.001.001.13")]
pub struct ThresholdBasis1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ThresholdBasis1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification30>,
}

impl Validate for ThresholdBasis1Choice {}




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

pub enum ThresholdBasis1Code {
    #[yaserde(rename = "ALSH")]
    #[cfg_attr(feature = "serde", serde(rename = "ALSH"))]
    Alsh,
    #[yaserde(rename = "ALSM")]
    #[cfg_attr(feature = "serde", serde(rename = "ALSM"))]
    Alsm,
    #[yaserde(rename = "ALVO")]
    #[cfg_attr(feature = "serde", serde(rename = "ALVO"))]
    Alvo,
    __Unknown__(String),
}

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

impl Validate for ThresholdBasis1Code {}



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

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.13")]

pub enum VoteChannel1Code {
    #[yaserde(rename = "VOPI")]
    #[cfg_attr(feature = "serde", serde(rename = "VOPI"))]
    Vopi,
    #[yaserde(rename = "VOCI")]
    #[cfg_attr(feature = "serde", serde(rename = "VOCI"))]
    Voci,
    __Unknown__(String),
}

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

impl Validate for VoteChannel1Code {}



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

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.13")]

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.13")]
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.13")]
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.13")]
pub struct VoteMethods5 {
    #[yaserde(rename = "VoteThrghNtwk")]
    #[cfg_attr(feature = "serde", serde(rename = "VoteThrghNtwk"))]
    pub vote_thrgh_ntwk: VoteThroughNetwork1Choice,

    #[yaserde(rename = "VoteByMail")]
    #[cfg_attr(feature = "serde", serde(rename = "VoteByMail"))]
    pub vote_by_mail: MailAddress1,

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

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

impl Validate for VoteMethods5 {}


#[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.13")]
pub struct VoteParameters10 {
    #[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: VoteMethods5,

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

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

    #[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 = "AddtlDsclsrRqrmnts")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlDsclsrRqrmnts"))]
    pub addtl_dsclsr_rqrmnts: Max350Text,

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

impl Validate for VoteParameters10 {}
#[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.13")]
pub struct VoteThroughNetwork1Choice {
    #[yaserde(rename = "VoteChanl")]
    #[cfg_attr(feature = "serde", serde(rename = "VoteChanl"))]
    pub vote_chanl: Option<VoteChannel1Code>,
    #[yaserde(rename = "VoteDrctlyToIssr")]
    #[cfg_attr(feature = "serde", serde(rename = "VoteDrctlyToIssr"))]
    pub vote_drctly_to_issr: Vec<AnyBICDec2014Identifier>,
}

impl Validate for VoteThroughNetwork1Choice {}




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

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.13")]
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.13")]

pub enum VotingParticipationMethod3Code {
    #[yaserde(rename = "MAIL")]
    #[cfg_attr(feature = "serde", serde(rename = "MAIL"))]
    Mail,
    #[yaserde(rename = "EVOT")]
    #[cfg_attr(feature = "serde", serde(rename = "EVOT"))]
    Evot,
    #[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,
    __Unknown__(String),
}

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

impl Validate for VotingParticipationMethod3Code {}



#[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.13")]
pub struct VotingRightsThreshold2 {
    #[yaserde(rename = "Thrshld")]
    #[cfg_attr(feature = "serde", serde(rename = "Thrshld"))]
    pub thrshld: NumberOrPercentage2Choice,

    #[yaserde(rename = "ThrshldBsis")]
    #[cfg_attr(feature = "serde", serde(rename = "ThrshldBsis"))]
    pub thrshld_bsis: ThresholdBasis1Choice,
}

impl Validate for VotingRightsThreshold2 {}


#[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 = "13";
    const MESSAGE_NAME: &'static str = "seev.001.001.13";
    const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:seev.001.001.13";
}