rust_iso20022 0.1.1

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

// pub type Document = Document;
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.004.001.11")]
pub struct AccountIdentification84Choice {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Option<Max35Text>,
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Option<Max70Text>,
}

impl Validate for AccountIdentification84Choice {}




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

pub enum AddressType2Code {
    #[yaserde(rename = "ADDR")]
    #[cfg_attr(feature = "serde", serde(rename = "ADDR"))]
    Addr,
    #[yaserde(rename = "PBOX")]
    #[cfg_attr(feature = "serde", serde(rename = "PBOX"))]
    Pbox,
    #[yaserde(rename = "HOME")]
    #[cfg_attr(feature = "serde", serde(rename = "HOME"))]
    Home,
    #[yaserde(rename = "BIZZ")]
    #[cfg_attr(feature = "serde", serde(rename = "BIZZ"))]
    Bizz,
    #[yaserde(rename = "MLTO")]
    #[cfg_attr(feature = "serde", serde(rename = "MLTO"))]
    Mlto,
    #[yaserde(rename = "DLVY")]
    #[cfg_attr(feature = "serde", serde(rename = "DLVY"))]
    Dlvy,
    __Unknown__(String),
}

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

impl Validate for AddressType2Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct 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.004.001.11")]
pub struct AttendanceCard3 {
    #[yaserde(rename = "AttndncCardLbllg")]
    #[cfg_attr(feature = "serde", serde(rename = "AttndncCardLbllg"))]
    pub attndnc_card_lbllg: Max105Text,

    #[yaserde(rename = "DlvryMtd")]
    #[cfg_attr(feature = "serde", serde(rename = "DlvryMtd"))]
    pub dlvry_mtd: DeliveryPlace3Code,

    #[yaserde(rename = "OthrAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrAdr"))]
    pub othr_adr: NameAndAddress9,
}

impl Validate for AttendanceCard3 {}


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

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

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

pub enum DeliveryPlace3Code {
    #[yaserde(rename = "EMAL")]
    #[cfg_attr(feature = "serde", serde(rename = "EMAL"))]
    Emal,
    #[yaserde(rename = "EMPL")]
    #[cfg_attr(feature = "serde", serde(rename = "EMPL"))]
    Empl,
    #[yaserde(rename = "INDI")]
    #[cfg_attr(feature = "serde", serde(rename = "INDI"))]
    Indi,
    #[yaserde(rename = "ENTR")]
    #[cfg_attr(feature = "serde", serde(rename = "ENTR"))]
    Entr,
    #[yaserde(rename = "OADR")]
    #[cfg_attr(feature = "serde", serde(rename = "OADR"))]
    Oadr,
    __Unknown__(String),
}

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

impl Validate for DeliveryPlace3Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.004.001.11")]
pub struct Document {
    #[yaserde(rename = "MtgInstr")]
    #[cfg_attr(feature = "serde", serde(rename = "MtgInstr"))]
    pub mtg_instr: MeetingInstructionV11,
}

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

    #[yaserde(rename = "DocNb")]
    #[cfg_attr(feature = "serde", serde(rename = "DocNb"))]
    pub doc_nb: DocumentNumber5Choice,

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

impl Validate for DocumentIdentification32 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.004.001.11")]
pub struct DocumentIdentification3Choice {
    #[yaserde(rename = "AcctSvcrDocId")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctSvcrDocId"))]
    pub acct_svcr_doc_id: Option<Max35Text>,
    #[yaserde(rename = "AcctOwnrDocId")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctOwnrDocId"))]
    pub acct_ownr_doc_id: Option<Max35Text>,
}

impl Validate for DocumentIdentification3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.004.001.11")]
pub struct DocumentNumber5Choice {
    #[yaserde(rename = "ShrtNb")]
    #[cfg_attr(feature = "serde", serde(rename = "ShrtNb"))]
    pub shrt_nb: Option<Exact3NumericText>,
    #[yaserde(rename = "LngNb")]
    #[cfg_attr(feature = "serde", serde(rename = "LngNb"))]
    pub lng_nb: Option<Iso20022MessageIdentificationText>,
    #[yaserde(rename = "PrtryNb")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryNb"))]
    pub prtry_nb: Option<GenericIdentification36>,
}

impl Validate for DocumentNumber5Choice {}




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

impl Validate for Exact3NumericText {}
#[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.004.001.11")]
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.004.001.11")]
pub struct FinancialInstrumentQuantity46Choice {
    #[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>,
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<Quantity1Code>,
}

impl Validate for FinancialInstrumentQuantity46Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.004.001.11")]
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.004.001.11")]
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.004.001.11")]
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.004.001.11")]
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.004.001.11")]
pub struct HoldingBalance15 {
    #[yaserde(rename = "Bal")]
    #[cfg_attr(feature = "serde", serde(rename = "Bal"))]
    pub bal: SignedQuantityFormat15,

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

impl Validate for HoldingBalance15 {}


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

impl Validate for Iso20022MessageIdentificationText {}
#[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.004.001.11")]
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.004.001.11")]
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.004.001.11")]
pub struct IndividualPerson41 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: PartyIdentification232Choice,

    #[yaserde(rename = "PrtcptnMtd")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtcptnMtd"))]
    pub prtcptn_mtd: VotingParticipationMethod2Code,

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

    #[yaserde(rename = "AttndncCardDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "AttndncCardDtls"))]
    pub attndnc_card_dtls: AttendanceCard3,
}

impl Validate for IndividualPerson41 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.004.001.11")]
pub struct IndividualPerson42 {
    #[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,

    #[yaserde(rename = "AttndncCardDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "AttndncCardDtls"))]
    pub attndnc_card_dtls: AttendanceCard3,
}

impl Validate for IndividualPerson42 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.004.001.11")]
pub struct Instruction9 {
    #[yaserde(rename = "SnglInstrId")]
    #[cfg_attr(feature = "serde", serde(rename = "SnglInstrId"))]
    pub sngl_instr_id: Max35Text,

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

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

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

    #[yaserde(rename = "Prxy")]
    #[cfg_attr(feature = "serde", serde(rename = "Prxy"))]
    pub prxy: Proxy12,

    #[yaserde(rename = "VoteDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "VoteDtls"))]
    pub vote_dtls: VoteDetails7,

    #[yaserde(rename = "MtgAttndee")]
    #[cfg_attr(feature = "serde", serde(rename = "MtgAttndee"))]
    pub mtg_attndee: Vec<IndividualPerson41>,

    #[yaserde(rename = "SpcfcInstrReq")]
    #[cfg_attr(feature = "serde", serde(rename = "SpcfcInstrReq"))]
    pub spcfc_instr_req: SpecificInstructionRequest4,

    #[yaserde(rename = "AddtlDsclsrInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlDsclsrInf"))]
    pub addtl_dsclsr_inf: Vec<PartyIdentification338>,
}

impl Validate for Instruction9 {}


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

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.004.001.11")]
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)]
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.004.001.11")]
pub struct LongPostalAddress2Choice {
    #[yaserde(rename = "Ustrd")]
    #[cfg_attr(feature = "serde", serde(rename = "Ustrd"))]
    pub ustrd: Option<Max350Text>,
    #[yaserde(rename = "Strd")]
    #[cfg_attr(feature = "serde", serde(rename = "Strd"))]
    pub strd: Option<PostalAddress1>,
}

impl Validate for LongPostalAddress2Choice {}




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

impl Validate for Max105Text {
    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() > 105 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 105 \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 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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.004.001.11")]
pub struct MeetingInstructionCancellation1 {
    #[yaserde(rename = "MtgInstrCxlReqId")]
    #[cfg_attr(feature = "serde", serde(rename = "MtgInstrCxlReqId"))]
    pub mtg_instr_cxl_req_id: Max35Text,

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

impl Validate for MeetingInstructionCancellation1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.004.001.11")]
pub struct MeetingInstructionIdentification1 {
    #[yaserde(rename = "MtgInstrId")]
    #[cfg_attr(feature = "serde", serde(rename = "MtgInstrId"))]
    pub mtg_instr_id: Max35Text,

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

impl Validate for MeetingInstructionIdentification1 {}


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

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

    #[yaserde(rename = "MtgRef")]
    #[cfg_attr(feature = "serde", serde(rename = "MtgRef"))]
    pub mtg_ref: MeetingReference11,

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

    #[yaserde(rename = "InstrCxlReqId")]
    #[cfg_attr(feature = "serde", serde(rename = "InstrCxlReqId"))]
    pub instr_cxl_req_id: Vec<MeetingInstructionCancellation1>,

    #[yaserde(rename = "CancInstrId")]
    #[cfg_attr(feature = "serde", serde(rename = "CancInstrId"))]
    pub canc_instr_id: Vec<MeetingInstructionIdentification1>,

    #[yaserde(rename = "OthrDocId")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrDocId"))]
    pub othr_doc_id: Vec<DocumentIdentification32>,

    #[yaserde(rename = "Instr")]
    #[cfg_attr(feature = "serde", serde(rename = "Instr"))]
    pub instr: Vec<Instruction9>,

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

impl Validate for MeetingInstructionV11 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.004.001.11")]
pub struct MeetingReference11 {
    #[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 = "MtgDtAndTm")]
    #[cfg_attr(feature = "serde", serde(rename = "MtgDtAndTm"))]
    pub mtg_dt_and_tm: IsodateTime,

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

    #[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 = "Lctn")]
    #[cfg_attr(feature = "serde", serde(rename = "Lctn"))]
    pub lctn: Vec<PostalAddress1>,

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

impl Validate for MeetingReference11 {}


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

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

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

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

impl Validate for NameAndAddress5 {}


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

impl Validate for NameAndAddress9 {}


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

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.004.001.11")]
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.004.001.11")]
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.004.001.11")]
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.004.001.11")]
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.004.001.11")]
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.004.001.11")]
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.004.001.11")]
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.004.001.11")]
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.004.001.11")]
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.004.001.11")]
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.004.001.11")]
pub struct PartyIdentification264Choice {
    #[yaserde(rename = "LglPrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "LglPrsn"))]
    pub lgl_prsn: Option<PartyIdentification341>,
    #[yaserde(rename = "NtrlPrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "NtrlPrsn"))]
    pub ntrl_prsn: Vec<PartyIdentification342>,
}

impl Validate for PartyIdentification264Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.004.001.11")]
pub struct PartyIdentification335Choice {
    #[yaserde(rename = "Acct")]
    #[cfg_attr(feature = "serde", serde(rename = "Acct"))]
    pub acct: Option<AccountIdentification84Choice>,
    #[yaserde(rename = "Pty")]
    #[cfg_attr(feature = "serde", serde(rename = "Pty"))]
    pub pty: Option<PartyIdentification336Choice>,
}

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

impl Validate for PartyIdentification336Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.004.001.11")]
pub struct PartyIdentification338 {
    #[yaserde(rename = "LglPrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "LglPrsn"))]
    pub lgl_prsn: PartyIdentification335Choice,

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

impl Validate for PartyIdentification338 {}


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

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

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


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

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

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


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

pub enum PartyRole3Code {
    #[yaserde(rename = "GATR")]
    #[cfg_attr(feature = "serde", serde(rename = "GATR"))]
    Gatr,
    __Unknown__(String),
}

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

impl Validate for PartyRole3Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.004.001.11")]
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.004.001.11")]
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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:seev.004.001.11")]
pub struct PledgeInformation1 {
    #[yaserde(rename = "Pldgr")]
    #[cfg_attr(feature = "serde", serde(rename = "Pldgr"))]
    pub pldgr: PartyIdentification232Choice,

    #[yaserde(rename = "ThrdPty")]
    #[cfg_attr(feature = "serde", serde(rename = "ThrdPty"))]
    pub thrd_pty: ThirdPartyIdentification1,

    #[yaserde(rename = "PldgTp")]
    #[cfg_attr(feature = "serde", serde(rename = "PldgTp"))]
    pub pldg_tp: GenericIdentification36,

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

impl Validate for PledgeInformation1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.004.001.11")]
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.004.001.11")]
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.004.001.11")]

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

impl Validate for ProcessingPosition7Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.004.001.11")]
pub struct ProprietaryVote1 {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: GenericIdentification30,

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

impl Validate for ProprietaryVote1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.004.001.11")]
pub struct Proxy12 {
    #[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: IndividualPerson42,
}

impl Validate for Proxy12 {}


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

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

pub enum Quantity1Code {
    #[yaserde(rename = "QALL")]
    #[cfg_attr(feature = "serde", serde(rename = "QALL"))]
    Qall,
    __Unknown__(String),
}

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

impl Validate for Quantity1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.004.001.11")]
pub struct QuantityOrCode1Choice {
    #[yaserde(rename = "Qty")]
    #[cfg_attr(feature = "serde", serde(rename = "Qty"))]
    pub qty: Option<FinancialInstrumentQuantity18Choice>,
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<Quantity1Code>,
}

impl Validate for QuantityOrCode1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.004.001.11")]
pub struct SafekeepingAccount20 {
    #[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 = "SubAcctId")]
    #[cfg_attr(feature = "serde", serde(rename = "SubAcctId"))]
    pub sub_acct_id: Max35Text,

    #[yaserde(rename = "InstdBal")]
    #[cfg_attr(feature = "serde", serde(rename = "InstdBal"))]
    pub instd_bal: Vec<HoldingBalance15>,

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

    #[yaserde(rename = "PldgDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "PldgDtls"))]
    pub pldg_dtls: PledgeInformation1,
}

impl Validate for SafekeepingAccount20 {}


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

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

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

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

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.004.001.11")]
pub struct SignedQuantityFormat15 {
    #[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: FinancialInstrumentQuantity46Choice,
}

impl Validate for SignedQuantityFormat15 {}


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

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

impl Validate for SpecificInstructionRequest4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.004.001.11")]
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.004.001.11")]
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.004.001.11")]
pub struct ThirdPartyIdentification1 {
    #[yaserde(rename = "Role")]
    #[cfg_attr(feature = "serde", serde(rename = "Role"))]
    pub role: PartyRole3Code,

    #[yaserde(rename = "LglPrsnId")]
    #[cfg_attr(feature = "serde", serde(rename = "LglPrsnId"))]
    pub lgl_prsn_id: PartyIdentification221,
}

impl Validate for ThirdPartyIdentification1 {}


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

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

    #[yaserde(rename = "VoteOptn")]
    #[cfg_attr(feature = "serde", serde(rename = "VoteOptn"))]
    pub vote_optn: VoteInstructionType2Choice,
}

impl Validate for Vote15 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.004.001.11")]
pub struct Vote17Choice {
    #[yaserde(rename = "VotePerAgndRsltn")]
    #[cfg_attr(feature = "serde", serde(rename = "VotePerAgndRsltn"))]
    pub vote_per_agnd_rsltn: Option<Vote18Choice>,
    #[yaserde(rename = "VoteForAllAgndRsltns")]
    #[cfg_attr(feature = "serde", serde(rename = "VoteForAllAgndRsltns"))]
    pub vote_for_all_agnd_rsltns: Option<VoteInstructionType3Choice>,
}

impl Validate for Vote17Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.004.001.11")]
pub struct Vote18Choice {
    #[yaserde(rename = "VoteInstr")]
    #[cfg_attr(feature = "serde", serde(rename = "VoteInstr"))]
    pub vote_instr: Vec<Vote21>,
    #[yaserde(rename = "GblVoteInstr")]
    #[cfg_attr(feature = "serde", serde(rename = "GblVoteInstr"))]
    pub gbl_vote_instr: Vec<Vote15>,
}

impl Validate for Vote18Choice {}




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

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

    #[yaserde(rename = "For")]
    #[cfg_attr(feature = "serde", serde(rename = "For"))]
    pub _for: QuantityOrCode1Choice,

    #[yaserde(rename = "Agnst")]
    #[cfg_attr(feature = "serde", serde(rename = "Agnst"))]
    pub agnst: QuantityOrCode1Choice,

    #[yaserde(rename = "Abstn")]
    #[cfg_attr(feature = "serde", serde(rename = "Abstn"))]
    pub abstn: QuantityOrCode1Choice,

    #[yaserde(rename = "Wthhld")]
    #[cfg_attr(feature = "serde", serde(rename = "Wthhld"))]
    pub wthhld: QuantityOrCode1Choice,

    #[yaserde(rename = "WthMgmt")]
    #[cfg_attr(feature = "serde", serde(rename = "WthMgmt"))]
    pub wth_mgmt: QuantityOrCode1Choice,

    #[yaserde(rename = "AgnstMgmt")]
    #[cfg_attr(feature = "serde", serde(rename = "AgnstMgmt"))]
    pub agnst_mgmt: QuantityOrCode1Choice,

    #[yaserde(rename = "Dscrtnry")]
    #[cfg_attr(feature = "serde", serde(rename = "Dscrtnry"))]
    pub dscrtnry: QuantityOrCode1Choice,

    #[yaserde(rename = "OneYr")]
    #[cfg_attr(feature = "serde", serde(rename = "OneYr"))]
    pub one_yr: QuantityOrCode1Choice,

    #[yaserde(rename = "TwoYrs")]
    #[cfg_attr(feature = "serde", serde(rename = "TwoYrs"))]
    pub two_yrs: QuantityOrCode1Choice,

    #[yaserde(rename = "ThreeYrs")]
    #[cfg_attr(feature = "serde", serde(rename = "ThreeYrs"))]
    pub three_yrs: QuantityOrCode1Choice,

    #[yaserde(rename = "NoActn")]
    #[cfg_attr(feature = "serde", serde(rename = "NoActn"))]
    pub no_actn: QuantityOrCode1Choice,

    #[yaserde(rename = "Blnk")]
    #[cfg_attr(feature = "serde", serde(rename = "Blnk"))]
    pub blnk: QuantityOrCode1Choice,

    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Vec<ProprietaryVote1>,
}

impl Validate for Vote21 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.004.001.11")]
pub struct VoteDetails7 {
    #[yaserde(rename = "VoteInstrForAgndRsltn")]
    #[cfg_attr(feature = "serde", serde(rename = "VoteInstrForAgndRsltn"))]
    pub vote_instr_for_agnd_rsltn: Vote17Choice,

    #[yaserde(rename = "VoteInstrForMtgRsltn")]
    #[cfg_attr(feature = "serde", serde(rename = "VoteInstrForMtgRsltn"))]
    pub vote_instr_for_mtg_rsltn: VoteInstructionForMeetingResolution3Choice,

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

impl Validate for VoteDetails7 {}


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

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

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

impl Validate for VoteInstruction7Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.004.001.11")]
pub struct VoteInstructionForMeetingResolution3Choice {
    #[yaserde(rename = "VoteIndctn")]
    #[cfg_attr(feature = "serde", serde(rename = "VoteIndctn"))]
    pub vote_indctn: Option<VoteInstructionType1Choice>,
    #[yaserde(rename = "Shrhldr")]
    #[cfg_attr(feature = "serde", serde(rename = "Shrhldr"))]
    pub shrhldr: Option<NameAndAddress9>,
}

impl Validate for VoteInstructionForMeetingResolution3Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.004.001.11")]
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.004.001.11")]
pub struct VoteInstructionType2Choice {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: Option<VoteInstruction7Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification30>,
}

impl Validate for VoteInstructionType2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.004.001.11")]
pub struct VoteInstructionType3Choice {
    #[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 VoteInstructionType3Choice {}




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

pub enum VotingParticipationMethod2Code {
    #[yaserde(rename = "PHNV")]
    #[cfg_attr(feature = "serde", serde(rename = "PHNV"))]
    Phnv,
    __Unknown__(String),
}

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

impl Validate for VotingParticipationMethod2Code {}



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

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)]
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 = "004";
    const VARIANT: &'static str = "001";
    const VERSION: &'static str = "11";
    const MESSAGE_NAME: &'static str = "seev.004.001.11";
    const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:seev.004.001.11";
}