rust_iso20022 0.1.0

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

// pub type Document = Document;
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.094.001.02")]

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

pub enum AnyMIC1Code {
    #[yaserde(rename = "ANYM")]
    #[cfg_attr(feature = "serde", serde(rename = "ANYM"))]
    Anym,
    __Unknown__(String),
}

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

impl Validate for AnyMIC1Code {}



#[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:auth.094.001.02")]

pub enum CollateralType6Code {
    #[yaserde(rename = "GBBK")]
    #[cfg_attr(feature = "serde", serde(rename = "GBBK"))]
    Gbbk,
    #[yaserde(rename = "BOND")]
    #[cfg_attr(feature = "serde", serde(rename = "BOND"))]
    Bond,
    #[yaserde(rename = "CASH")]
    #[cfg_attr(feature = "serde", serde(rename = "CASH"))]
    Cash,
    #[yaserde(rename = "COMM")]
    #[cfg_attr(feature = "serde", serde(rename = "COMM"))]
    Comm,
    #[yaserde(rename = "INSU")]
    #[cfg_attr(feature = "serde", serde(rename = "INSU"))]
    Insu,
    #[yaserde(rename = "LCRE")]
    #[cfg_attr(feature = "serde", serde(rename = "LCRE"))]
    Lcre,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "PHYS")]
    #[cfg_attr(feature = "serde", serde(rename = "PHYS"))]
    Phys,
    #[yaserde(rename = "SECU")]
    #[cfg_attr(feature = "serde", serde(rename = "SECU"))]
    Secu,
    #[yaserde(rename = "STCF")]
    #[cfg_attr(feature = "serde", serde(rename = "STCF"))]
    Stcf,
    __Unknown__(String),
}

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

impl Validate for CollateralType6Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.094.001.02")]
pub struct CorporateSectorCriteria5 {
    #[yaserde(rename = "FISctr")]
    #[cfg_attr(feature = "serde", serde(rename = "FISctr"))]
    pub fi_sctr: Vec<FinancialPartySectorType2Code>,

    #[yaserde(rename = "NFISctr")]
    #[cfg_attr(feature = "serde", serde(rename = "NFISctr"))]
    pub nfi_sctr: Vec<NacedomainIdentifier>,

    #[yaserde(rename = "NotRptd")]
    #[cfg_attr(feature = "serde", serde(rename = "NotRptd"))]
    pub not_rptd: NotReported1Code,
}

impl Validate for CorporateSectorCriteria5 {}


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

impl Validate for CountryCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.094.001.02")]
pub struct DateOrBlankQuery2Choice {
    #[yaserde(rename = "Rg")]
    #[cfg_attr(feature = "serde", serde(rename = "Rg"))]
    pub rg: Option<DatePeriod1>,
    #[yaserde(rename = "NotRptd")]
    #[cfg_attr(feature = "serde", serde(rename = "NotRptd"))]
    pub not_rptd: Option<NotReported1Code>,
}

impl Validate for DateOrBlankQuery2Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.094.001.02")]
pub struct DatePeriod1 {
    #[yaserde(rename = "FrDt")]
    #[cfg_attr(feature = "serde", serde(rename = "FrDt"))]
    pub fr_dt: Isodate,

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

impl Validate for DatePeriod1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.094.001.02")]
pub struct DateTimePeriod1 {
    #[yaserde(rename = "FrDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "FrDtTm"))]
    pub fr_dt_tm: IsodateTime,

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

impl Validate for DateTimePeriod1 {}


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

impl Validate for DayOfMonthNumber {
    fn validate(&self) -> Result<(), String> { 
        if self.0 < "1".parse::<String>().unwrap() {
            return Err(format!("MinInclusive validation error: invalid value of 0! \nExpected: 0 >= 1.\nActual: 0 == {}", self.0));
        }
        if self.0 > "31".parse::<String>().unwrap() {
            return Err(format!("MaxInclusive validation error: invalid value of 0! \nExpected: 0 <= 31.\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:auth.094.001.02")]
pub struct Document {
    #[yaserde(rename = "SctiesFincgRptgTxQry")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesFincgRptgTxQry"))]
    pub scties_fincg_rptg_tx_qry: SecuritiesFinancingReportingTransactionQueryV02,
}

impl Validate for Document {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.094.001.02")]

pub enum ExposureType10Code {
    #[yaserde(rename = "SBSC")]
    #[cfg_attr(feature = "serde", serde(rename = "SBSC"))]
    Sbsc,
    #[yaserde(rename = "MGLD")]
    #[cfg_attr(feature = "serde", serde(rename = "MGLD"))]
    Mgld,
    #[yaserde(rename = "SLEB")]
    #[cfg_attr(feature = "serde", serde(rename = "SLEB"))]
    Sleb,
    #[yaserde(rename = "REPO")]
    #[cfg_attr(feature = "serde", serde(rename = "REPO"))]
    Repo,
    __Unknown__(String),
}

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

impl Validate for ExposureType10Code {}



#[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:auth.094.001.02")]

pub enum FinancialPartySectorType2Code {
    #[yaserde(rename = "AIFD")]
    #[cfg_attr(feature = "serde", serde(rename = "AIFD"))]
    Aifd,
    #[yaserde(rename = "CSDS")]
    #[cfg_attr(feature = "serde", serde(rename = "CSDS"))]
    Csds,
    #[yaserde(rename = "CCPS")]
    #[cfg_attr(feature = "serde", serde(rename = "CCPS"))]
    Ccps,
    #[yaserde(rename = "CDTI")]
    #[cfg_attr(feature = "serde", serde(rename = "CDTI"))]
    Cdti,
    #[yaserde(rename = "INUN")]
    #[cfg_attr(feature = "serde", serde(rename = "INUN"))]
    Inun,
    #[yaserde(rename = "ORPI")]
    #[cfg_attr(feature = "serde", serde(rename = "ORPI"))]
    Orpi,
    #[yaserde(rename = "INVF")]
    #[cfg_attr(feature = "serde", serde(rename = "INVF"))]
    Invf,
    #[yaserde(rename = "REIN")]
    #[cfg_attr(feature = "serde", serde(rename = "REIN"))]
    Rein,
    #[yaserde(rename = "UCIT")]
    #[cfg_attr(feature = "serde", serde(rename = "UCIT"))]
    Ucit,
    __Unknown__(String),
}

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

impl Validate for FinancialPartySectorType2Code {}



#[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:auth.094.001.02")]

pub enum Frequency14Code {
    #[yaserde(rename = "DAIL")]
    #[cfg_attr(feature = "serde", serde(rename = "DAIL"))]
    Dail,
    #[yaserde(rename = "WEEK")]
    #[cfg_attr(feature = "serde", serde(rename = "WEEK"))]
    Week,
    #[yaserde(rename = "MNTH")]
    #[cfg_attr(feature = "serde", serde(rename = "MNTH"))]
    Mnth,
    #[yaserde(rename = "ADHO")]
    #[cfg_attr(feature = "serde", serde(rename = "ADHO"))]
    Adho,
    __Unknown__(String),
}

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

impl Validate for Frequency14Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.094.001.02")]
pub struct GenericIdentification1 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

impl Validate for NacedomainIdentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.094.001.02")]
pub struct NameAndAddress5 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max350Text,

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

impl Validate for NameAndAddress5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.094.001.02")]

pub enum NotReported1Code {
    #[yaserde(rename = "NORP")]
    #[cfg_attr(feature = "serde", serde(rename = "NORP"))]
    Norp,
    __Unknown__(String),
}

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

impl Validate for NotReported1Code {}



#[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:auth.094.001.02")]

pub enum Operation3Code {
    #[yaserde(rename = "ANDD")]
    #[cfg_attr(feature = "serde", serde(rename = "ANDD"))]
    Andd,
    #[yaserde(rename = "ORRR")]
    #[cfg_attr(feature = "serde", serde(rename = "ORRR"))]
    Orrr,
    __Unknown__(String),
}

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

impl Validate for Operation3Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.094.001.02")]
pub struct PartyIdentification121Choice {
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_b_i_c: Option<AnyBICDec2014Identifier>,
    #[yaserde(rename = "LglNttyIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "LglNttyIdr"))]
    pub lgl_ntty_idr: Option<Leiidentifier>,
    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: Option<NameAndAddress5>,
    #[yaserde(rename = "PrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
    pub prtry_id: Option<GenericIdentification1>,
}

impl Validate for PartyIdentification121Choice {}




#[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:auth.094.001.02")]

pub enum PartyNatureType1Code {
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "NFIN")]
    #[cfg_attr(feature = "serde", serde(rename = "NFIN"))]
    Nfin,
    #[yaserde(rename = "FIIN")]
    #[cfg_attr(feature = "serde", serde(rename = "FIIN"))]
    Fiin,
    #[yaserde(rename = "CCPS")]
    #[cfg_attr(feature = "serde", serde(rename = "CCPS"))]
    Ccps,
    __Unknown__(String),
}

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

impl Validate for PartyNatureType1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.094.001.02")]
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:auth.094.001.02")]
pub struct SecuritiesFinancingReportingTransactionQueryV02 {
    #[yaserde(rename = "RqstngAuthrty")]
    #[cfg_attr(feature = "serde", serde(rename = "RqstngAuthrty"))]
    pub rqstng_authrty: PartyIdentification121Choice,

    #[yaserde(rename = "TradQryData")]
    #[cfg_attr(feature = "serde", serde(rename = "TradQryData"))]
    pub trad_qry_data: TradeReportQuery13Choice,

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

impl Validate for SecuritiesFinancingReportingTransactionQueryV02 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.094.001.02")]
pub struct SecuritiesTradeVenueCriteria1Choice {
    #[yaserde(rename = "MIC")]
    #[cfg_attr(feature = "serde", serde(rename = "MIC"))]
    pub mic: Vec<Micidentifier>,
    #[yaserde(rename = "AnyMIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyMIC"))]
    pub any_m_i_c: Option<AnyMIC1Code>,
}

impl Validate for SecuritiesTradeVenueCriteria1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.094.001.02")]
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:auth.094.001.02")]
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:auth.094.001.02")]
pub struct TradeAdditionalQueryCriteria7 {
    #[yaserde(rename = "ActnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ActnTp"))]
    pub actn_tp: Vec<TransactionOperationType6Code>,

    #[yaserde(rename = "ExctnVn")]
    #[cfg_attr(feature = "serde", serde(rename = "ExctnVn"))]
    pub exctn_vn: SecuritiesTradeVenueCriteria1Choice,

    #[yaserde(rename = "NtrOfCtrPty")]
    #[cfg_attr(feature = "serde", serde(rename = "NtrOfCtrPty"))]
    pub ntr_of_ctr_pty: Vec<PartyNatureType1Code>,

    #[yaserde(rename = "CorpSctr")]
    #[cfg_attr(feature = "serde", serde(rename = "CorpSctr"))]
    pub corp_sctr: Vec<CorporateSectorCriteria5>,
}

impl Validate for TradeAdditionalQueryCriteria7 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.094.001.02")]
pub struct TradeDateTimeQueryCriteria2 {
    #[yaserde(rename = "RptgDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "RptgDtTm"))]
    pub rptg_dt_tm: DateTimePeriod1,

    #[yaserde(rename = "ExctnDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "ExctnDtTm"))]
    pub exctn_dt_tm: DateTimePeriod1,

    #[yaserde(rename = "MtrtyDt")]
    #[cfg_attr(feature = "serde", serde(rename = "MtrtyDt"))]
    pub mtrty_dt: DateOrBlankQuery2Choice,

    #[yaserde(rename = "TermntnDt")]
    #[cfg_attr(feature = "serde", serde(rename = "TermntnDt"))]
    pub termntn_dt: DateOrBlankQuery2Choice,
}

impl Validate for TradeDateTimeQueryCriteria2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.094.001.02")]
pub struct TradePartyIdentificationQuery8 {
    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Vec<Leiidentifier>,

    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_bic: Vec<AnyBICDec2014Identifier>,

    #[yaserde(rename = "ClntId")]
    #[cfg_attr(feature = "serde", serde(rename = "ClntId"))]
    pub clnt_id: Vec<Max50Text>,

    #[yaserde(rename = "NotRptd")]
    #[cfg_attr(feature = "serde", serde(rename = "NotRptd"))]
    pub not_rptd: NotReported1Code,
}

impl Validate for TradePartyIdentificationQuery8 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.094.001.02")]
pub struct TradePartyIdentificationQuery9 {
    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Vec<Leiidentifier>,

    #[yaserde(rename = "CtryCd")]
    #[cfg_attr(feature = "serde", serde(rename = "CtryCd"))]
    pub ctry_cd: Vec<CountryCode>,

    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_bic: Vec<AnyBICDec2014Identifier>,

    #[yaserde(rename = "ClntId")]
    #[cfg_attr(feature = "serde", serde(rename = "ClntId"))]
    pub clnt_id: Vec<Max50Text>,

    #[yaserde(rename = "NotRptd")]
    #[cfg_attr(feature = "serde", serde(rename = "NotRptd"))]
    pub not_rptd: NotReported1Code,
}

impl Validate for TradePartyIdentificationQuery9 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.094.001.02")]
pub struct TradePartyQueryCriteria5 {
    #[yaserde(rename = "Oprtr")]
    #[cfg_attr(feature = "serde", serde(rename = "Oprtr"))]
    pub oprtr: Operation3Code,

    #[yaserde(rename = "RptgCtrPty")]
    #[cfg_attr(feature = "serde", serde(rename = "RptgCtrPty"))]
    pub rptg_ctr_pty: TradePartyIdentificationQuery8,

    #[yaserde(rename = "RptgCtrPtyBrnch")]
    #[cfg_attr(feature = "serde", serde(rename = "RptgCtrPtyBrnch"))]
    pub rptg_ctr_pty_brnch: TradePartyIdentificationQuery9,

    #[yaserde(rename = "OthrCtrPty")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrCtrPty"))]
    pub othr_ctr_pty: TradePartyIdentificationQuery8,

    #[yaserde(rename = "OthrCtrPtyBrnch")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrCtrPtyBrnch"))]
    pub othr_ctr_pty_brnch: TradePartyIdentificationQuery9,

    #[yaserde(rename = "Bnfcry")]
    #[cfg_attr(feature = "serde", serde(rename = "Bnfcry"))]
    pub bnfcry: TradePartyIdentificationQuery8,

    #[yaserde(rename = "SubmitgAgt")]
    #[cfg_attr(feature = "serde", serde(rename = "SubmitgAgt"))]
    pub submitg_agt: TradePartyIdentificationQuery8,

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

    #[yaserde(rename = "CCP")]
    #[cfg_attr(feature = "serde", serde(rename = "CCP"))]
    pub ccp: TradePartyIdentificationQuery8,

    #[yaserde(rename = "AgtLndr")]
    #[cfg_attr(feature = "serde", serde(rename = "AgtLndr"))]
    pub agt_lndr: TradePartyIdentificationQuery8,

    #[yaserde(rename = "TrptyAgt")]
    #[cfg_attr(feature = "serde", serde(rename = "TrptyAgt"))]
    pub trpty_agt: TradePartyIdentificationQuery8,
}

impl Validate for TradePartyQueryCriteria5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.094.001.02")]
pub struct TradeQueryCriteria10 {
    #[yaserde(rename = "TradLifeCyclHstry")]
    #[cfg_attr(feature = "serde", serde(rename = "TradLifeCyclHstry"))]
    pub trad_life_cycl_hstry: TrueFalseIndicator,

    #[yaserde(rename = "OutsdngTradInd")]
    #[cfg_attr(feature = "serde", serde(rename = "OutsdngTradInd"))]
    pub outsdng_trad_ind: TrueFalseIndicator,

    #[yaserde(rename = "TradPtyCrit")]
    #[cfg_attr(feature = "serde", serde(rename = "TradPtyCrit"))]
    pub trad_pty_crit: TradePartyQueryCriteria5,

    #[yaserde(rename = "TradTpCrit")]
    #[cfg_attr(feature = "serde", serde(rename = "TradTpCrit"))]
    pub trad_tp_crit: TradeTypeQueryCriteria2,

    #[yaserde(rename = "TmCrit")]
    #[cfg_attr(feature = "serde", serde(rename = "TmCrit"))]
    pub tm_crit: TradeDateTimeQueryCriteria2,

    #[yaserde(rename = "OthrCrit")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrCrit"))]
    pub othr_crit: TradeAdditionalQueryCriteria7,
}

impl Validate for TradeQueryCriteria10 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.094.001.02")]
pub struct TradeQueryExecutionFrequency3 {
    #[yaserde(rename = "FrqcyTp")]
    #[cfg_attr(feature = "serde", serde(rename = "FrqcyTp"))]
    pub frqcy_tp: Frequency14Code,

    #[yaserde(rename = "DlvryDay")]
    #[cfg_attr(feature = "serde", serde(rename = "DlvryDay"))]
    pub dlvry_day: Vec<WeekDay3Code>,

    #[yaserde(rename = "DayOfMnth")]
    #[cfg_attr(feature = "serde", serde(rename = "DayOfMnth"))]
    pub day_of_mnth: Vec<DayOfMonthNumber>,
}

impl Validate for TradeQueryExecutionFrequency3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.094.001.02")]
pub struct TradeRecurrentQuery5 {
    #[yaserde(rename = "QryTp")]
    #[cfg_attr(feature = "serde", serde(rename = "QryTp"))]
    pub qry_tp: Max1000Text,

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

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

impl Validate for TradeRecurrentQuery5 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.094.001.02")]
pub struct TradeReportQuery13Choice {
    #[yaserde(rename = "AdHocQry")]
    #[cfg_attr(feature = "serde", serde(rename = "AdHocQry"))]
    pub ad_hoc_qry: Option<TradeQueryCriteria10>,
    #[yaserde(rename = "RcrntQry")]
    #[cfg_attr(feature = "serde", serde(rename = "RcrntQry"))]
    pub rcrnt_qry: Option<TradeRecurrentQuery5>,
}

impl Validate for TradeReportQuery13Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:auth.094.001.02")]
pub struct TradeTypeQueryCriteria2 {
    #[yaserde(rename = "Oprtr")]
    #[cfg_attr(feature = "serde", serde(rename = "Oprtr"))]
    pub oprtr: Operation3Code,

    #[yaserde(rename = "SctiesFincgTxTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesFincgTxTp"))]
    pub scties_fincg_tx_tp: Vec<ExposureType10Code>,

    #[yaserde(rename = "CollCmpntTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CollCmpntTp"))]
    pub coll_cmpnt_tp: Vec<CollateralType6Code>,
}

impl Validate for TradeTypeQueryCriteria2 {}


#[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:auth.094.001.02")]

pub enum TransactionOperationType6Code {
    #[yaserde(rename = "REUU")]
    #[cfg_attr(feature = "serde", serde(rename = "REUU"))]
    Reuu,
    #[yaserde(rename = "COLU")]
    #[cfg_attr(feature = "serde", serde(rename = "COLU"))]
    Colu,
    #[yaserde(rename = "CORR")]
    #[cfg_attr(feature = "serde", serde(rename = "CORR"))]
    Corr,
    #[yaserde(rename = "ETRM")]
    #[cfg_attr(feature = "serde", serde(rename = "ETRM"))]
    Etrm,
    #[yaserde(rename = "VALU")]
    #[cfg_attr(feature = "serde", serde(rename = "VALU"))]
    Valu,
    #[yaserde(rename = "POSC")]
    #[cfg_attr(feature = "serde", serde(rename = "POSC"))]
    Posc,
    #[yaserde(rename = "NEWT")]
    #[cfg_attr(feature = "serde", serde(rename = "NEWT"))]
    Newt,
    #[yaserde(rename = "MODI")]
    #[cfg_attr(feature = "serde", serde(rename = "MODI"))]
    Modi,
    #[yaserde(rename = "MARU")]
    #[cfg_attr(feature = "serde", serde(rename = "MARU"))]
    Maru,
    #[yaserde(rename = "EROR")]
    #[cfg_attr(feature = "serde", serde(rename = "EROR"))]
    Eror,
    __Unknown__(String),
}

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

impl Validate for TransactionOperationType6Code {}



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

impl Validate for TrueFalseIndicator {}
#[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:auth.094.001.02")]

pub enum WeekDay3Code {
    #[yaserde(rename = "ALLD")]
    #[cfg_attr(feature = "serde", serde(rename = "ALLD"))]
    Alld,
    #[yaserde(rename = "XBHL")]
    #[cfg_attr(feature = "serde", serde(rename = "XBHL"))]
    Xbhl,
    #[yaserde(rename = "IBHL")]
    #[cfg_attr(feature = "serde", serde(rename = "IBHL"))]
    Ibhl,
    #[yaserde(rename = "FRID")]
    #[cfg_attr(feature = "serde", serde(rename = "FRID"))]
    Frid,
    #[yaserde(rename = "MOND")]
    #[cfg_attr(feature = "serde", serde(rename = "MOND"))]
    Mond,
    #[yaserde(rename = "SATD")]
    #[cfg_attr(feature = "serde", serde(rename = "SATD"))]
    Satd,
    #[yaserde(rename = "SUND")]
    #[cfg_attr(feature = "serde", serde(rename = "SUND"))]
    Sund,
    #[yaserde(rename = "THUD")]
    #[cfg_attr(feature = "serde", serde(rename = "THUD"))]
    Thud,
    #[yaserde(rename = "TUED")]
    #[cfg_attr(feature = "serde", serde(rename = "TUED"))]
    Tued,
    #[yaserde(rename = "WEDD")]
    #[cfg_attr(feature = "serde", serde(rename = "WEDD"))]
    Wedd,
    #[yaserde(rename = "WDAY")]
    #[cfg_attr(feature = "serde", serde(rename = "WDAY"))]
    Wday,
    #[yaserde(rename = "WEND")]
    #[cfg_attr(feature = "serde", serde(rename = "WEND"))]
    Wend,
    __Unknown__(String),
}

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

impl Validate for WeekDay3Code {}

impl crate::MxMessage for Document {
    const BUSINESS_AREA: crate::BusinessArea = crate::BusinessArea::auth;
    const FUNCTIONALITY: &'static str = "094";
    const VARIANT: &'static str = "001";
    const VERSION: &'static str = "02";
    const MESSAGE_NAME: &'static str = "auth.094.001.02";
    const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:auth.094.001.02";
}