rust_iso20022 0.1.0

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

// pub type Document = Document;
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:fxtr.035.001.02")]
pub struct AccountIdentification26 {
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: SimpleIdentificationInformation4,
}

impl Validate for AccountIdentification26 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:fxtr.035.001.02")]
pub struct AccountIdentification30 {
    #[yaserde(rename = "AcctTp")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctTp"))]
    pub acct_tp: AccountInformationType1Code,

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

impl Validate for AccountIdentification30 {}


#[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:fxtr.035.001.02")]

pub enum AccountInformationType1Code {
    #[yaserde(rename = "IBND")]
    #[cfg_attr(feature = "serde", serde(rename = "IBND"))]
    Ibnd,
    #[yaserde(rename = "IBCC")]
    #[cfg_attr(feature = "serde", serde(rename = "IBCC"))]
    Ibcc,
    #[yaserde(rename = "IBDC")]
    #[cfg_attr(feature = "serde", serde(rename = "IBDC"))]
    Ibdc,
    #[yaserde(rename = "BIBC")]
    #[cfg_attr(feature = "serde", serde(rename = "BIBC"))]
    Bibc,
    #[yaserde(rename = "BIBD")]
    #[cfg_attr(feature = "serde", serde(rename = "BIBD"))]
    Bibd,
    #[yaserde(rename = "BINC")]
    #[cfg_attr(feature = "serde", serde(rename = "BINC"))]
    Binc,
    #[yaserde(rename = "BIND")]
    #[cfg_attr(feature = "serde", serde(rename = "BIND"))]
    Bind,
    #[yaserde(rename = "BICC")]
    #[cfg_attr(feature = "serde", serde(rename = "BICC"))]
    Bicc,
    #[yaserde(rename = "BIDC")]
    #[cfg_attr(feature = "serde", serde(rename = "BIDC"))]
    Bidc,
    #[yaserde(rename = "CMSA")]
    #[cfg_attr(feature = "serde", serde(rename = "CMSA"))]
    Cmsa,
    #[yaserde(rename = "CBBC")]
    #[cfg_attr(feature = "serde", serde(rename = "CBBC"))]
    Cbbc,
    #[yaserde(rename = "CBBD")]
    #[cfg_attr(feature = "serde", serde(rename = "CBBD"))]
    Cbbd,
    #[yaserde(rename = "CBNC")]
    #[cfg_attr(feature = "serde", serde(rename = "CBNC"))]
    Cbnc,
    #[yaserde(rename = "CBND")]
    #[cfg_attr(feature = "serde", serde(rename = "CBND"))]
    Cbnd,
    #[yaserde(rename = "CBCC")]
    #[cfg_attr(feature = "serde", serde(rename = "CBCC"))]
    Cbcc,
    #[yaserde(rename = "CBDC")]
    #[cfg_attr(feature = "serde", serde(rename = "CBDC"))]
    Cbdc,
    #[yaserde(rename = "CUAC")]
    #[cfg_attr(feature = "serde", serde(rename = "CUAC"))]
    Cuac,
    #[yaserde(rename = "DEAC")]
    #[cfg_attr(feature = "serde", serde(rename = "DEAC"))]
    Deac,
    #[yaserde(rename = "FCAA")]
    #[cfg_attr(feature = "serde", serde(rename = "FCAA"))]
    Fcaa,
    #[yaserde(rename = "FCAN")]
    #[cfg_attr(feature = "serde", serde(rename = "FCAN"))]
    Fcan,
    #[yaserde(rename = "FCBN")]
    #[cfg_attr(feature = "serde", serde(rename = "FCBN"))]
    Fcbn,
    #[yaserde(rename = "IBBC")]
    #[cfg_attr(feature = "serde", serde(rename = "IBBC"))]
    Ibbc,
    #[yaserde(rename = "IBBD")]
    #[cfg_attr(feature = "serde", serde(rename = "IBBD"))]
    Ibbd,
    #[yaserde(rename = "IBNC")]
    #[cfg_attr(feature = "serde", serde(rename = "IBNC"))]
    Ibnc,
    #[yaserde(rename = "MCAA")]
    #[cfg_attr(feature = "serde", serde(rename = "MCAA"))]
    Mcaa,
    #[yaserde(rename = "MCAN")]
    #[cfg_attr(feature = "serde", serde(rename = "MCAN"))]
    Mcan,
    #[yaserde(rename = "MCIC")]
    #[cfg_attr(feature = "serde", serde(rename = "MCIC"))]
    Mcic,
    #[yaserde(rename = "MCIN")]
    #[cfg_attr(feature = "serde", serde(rename = "MCIN"))]
    Mcin,
    #[yaserde(rename = "MSAA")]
    #[cfg_attr(feature = "serde", serde(rename = "MSAA"))]
    Msaa,
    #[yaserde(rename = "MSBN")]
    #[cfg_attr(feature = "serde", serde(rename = "MSBN"))]
    Msbn,
    #[yaserde(rename = "MCAD")]
    #[cfg_attr(feature = "serde", serde(rename = "MCAD"))]
    Mcad,
    #[yaserde(rename = "NODC")]
    #[cfg_attr(feature = "serde", serde(rename = "NODC"))]
    Nodc,
    #[yaserde(rename = "SCAC")]
    #[cfg_attr(feature = "serde", serde(rename = "SCAC"))]
    Scac,
    #[yaserde(rename = "SCAA")]
    #[cfg_attr(feature = "serde", serde(rename = "SCAA"))]
    Scaa,
    #[yaserde(rename = "OMSA")]
    #[cfg_attr(feature = "serde", serde(rename = "OMSA"))]
    Omsa,
    #[yaserde(rename = "NOCC")]
    #[cfg_attr(feature = "serde", serde(rename = "NOCC"))]
    Nocc,
    #[yaserde(rename = "MSBS")]
    #[cfg_attr(feature = "serde", serde(rename = "MSBS"))]
    Msbs,
    #[yaserde(rename = "MSAN")]
    #[cfg_attr(feature = "serde", serde(rename = "MSAN"))]
    Msan,
    #[yaserde(rename = "SCAN")]
    #[cfg_attr(feature = "serde", serde(rename = "SCAN"))]
    Scan,
    #[yaserde(rename = "SCIC")]
    #[cfg_attr(feature = "serde", serde(rename = "SCIC"))]
    Scic,
    #[yaserde(rename = "SCIN")]
    #[cfg_attr(feature = "serde", serde(rename = "SCIN"))]
    Scin,
    #[yaserde(rename = "SOCA")]
    #[cfg_attr(feature = "serde", serde(rename = "SOCA"))]
    Soca,
    #[yaserde(rename = "SSCA")]
    #[cfg_attr(feature = "serde", serde(rename = "SSCA"))]
    Ssca,
    __Unknown__(String),
}

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

impl Validate for AccountInformationType1Code {}



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

impl Validate for ActiveCurrencyAnd13DecimalAmountSimpleType {
    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:fxtr.035.001.02")]
pub struct ActiveCurrencyAnd13DecimalAmount {
    #[yaserde(text)]
    pub value: String,
    #[yaserde(attribute, rename = "Ccy")]
    #[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
    pub ccy: ActiveCurrencyCode,
}

impl Validate for ActiveCurrencyAnd13DecimalAmount {}


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

impl Validate for ActiveCurrencyAndAmountSimpleType {
    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:fxtr.035.001.02")]
pub struct ActiveCurrencyAndAmount {
    #[yaserde(text)]
    pub value: String,
    #[yaserde(attribute, rename = "Ccy")]
    #[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
    pub ccy: ActiveCurrencyCode,
}

impl Validate for ActiveCurrencyAndAmount {}


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

impl Validate for ActiveCurrencyCode {}
#[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:fxtr.035.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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:fxtr.035.001.02")]
pub struct AgreedRate3 {
    #[yaserde(rename = "XchgRate")]
    #[cfg_attr(feature = "serde", serde(rename = "XchgRate"))]
    pub xchg_rate: BaseOneRate,

    #[yaserde(rename = "UnitCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitCcy"))]
    pub unit_ccy: ActiveCurrencyCode,

    #[yaserde(rename = "QtdCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "QtdCcy"))]
    pub qtd_ccy: ActiveCurrencyCode,
}

impl Validate for AgreedRate3 {}


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

    #[yaserde(rename = "IdSrc")]
    #[cfg_attr(feature = "serde", serde(rename = "IdSrc"))]
    pub id_src: IdentificationSource1Choice,
}

impl Validate for AlternateIdentification1 {}


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

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

impl Validate for Bloomberg2Identifier {}
#[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:fxtr.035.001.02")]

pub enum ClearingMethod1Code {
    #[yaserde(rename = "GRNE")]
    #[cfg_attr(feature = "serde", serde(rename = "GRNE"))]
    Grne,
    #[yaserde(rename = "NEMA")]
    #[cfg_attr(feature = "serde", serde(rename = "NEMA"))]
    Nema,
    #[yaserde(rename = "NENE")]
    #[cfg_attr(feature = "serde", serde(rename = "NENE"))]
    Nene,
    __Unknown__(String),
}

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

impl Validate for ClearingMethod1Code {}



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

impl Validate for ConsolidatedTapeAssociationIdentifier {
    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 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:fxtr.035.001.02")]
pub struct DateAndDateTime2Choice {
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Option<Isodate>,
    #[yaserde(rename = "DtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "DtTm"))]
    pub dt_tm: Option<IsodateTime>,
}

impl Validate for DateAndDateTime2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:fxtr.035.001.02")]
pub struct DateFormat45Choice {
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Option<DateAndDateTime2Choice>,
    #[yaserde(rename = "NotSpcfdDt")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdDt"))]
    pub not_spcfd_dt: Option<DateType8Code>,
}

impl Validate for DateFormat45Choice {}




#[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:fxtr.035.001.02")]

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

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

impl Validate for DateType8Code {}



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

impl Validate for DecimalNumber {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:fxtr.035.001.02")]
pub struct Document {
    #[yaserde(rename = "FXTradConfReqAmdmntReq")]
    #[cfg_attr(feature = "serde", serde(rename = "FXTradConfReqAmdmntReq"))]
    pub fx_trad_conf_req_amdmnt_req: ForeignExchangeTradeConfirmationRequestAmendmentRequestV02,
}

impl Validate for Document {}


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

impl Validate for EuroclearClearstreamIdentifier {
    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() > 12 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 12 \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:fxtr.035.001.02")]
pub struct ForeignExchangeTradeConfirmationRequestAmendmentRequestV02 {
    #[yaserde(rename = "Hdr")]
    #[cfg_attr(feature = "serde", serde(rename = "Hdr"))]
    pub hdr: Header23,

    #[yaserde(rename = "AmdmntReqId")]
    #[cfg_attr(feature = "serde", serde(rename = "AmdmntReqId"))]
    pub amdmnt_req_id: MessageIdentification1,

    #[yaserde(rename = "TradgSdId")]
    #[cfg_attr(feature = "serde", serde(rename = "TradgSdId"))]
    pub tradg_sd_id: TradePartyIdentification9,

    #[yaserde(rename = "CtrPtySdId")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrPtySdId"))]
    pub ctr_pty_sd_id: TradePartyIdentification9,

    #[yaserde(rename = "TradDtl")]
    #[cfg_attr(feature = "serde", serde(rename = "TradDtl"))]
    pub trad_dtl: Trade9,

    #[yaserde(rename = "QryPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "QryPrd"))]
    pub qry_prd: Period12,

    #[yaserde(rename = "QryStartNb")]
    #[cfg_attr(feature = "serde", serde(rename = "QryStartNb"))]
    pub qry_start_nb: Max35NumericText,

    #[yaserde(rename = "QryTradSts")]
    #[cfg_attr(feature = "serde", serde(rename = "QryTradSts"))]
    pub qry_trad_sts: QueryTradeStatus1Code,

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

impl Validate for ForeignExchangeTradeConfirmationRequestAmendmentRequestV02 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:fxtr.035.001.02")]
pub struct FundIdentification6 {
    #[yaserde(rename = "FndId")]
    #[cfg_attr(feature = "serde", serde(rename = "FndId"))]
    pub fnd_id: Max35Text,

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

    #[yaserde(rename = "CtdnId")]
    #[cfg_attr(feature = "serde", serde(rename = "CtdnId"))]
    pub ctdn_id: PartyIdentification251Choice,
}

impl Validate for FundIdentification6 {}


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

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

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

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

impl Validate for GenericIdentification32 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:fxtr.035.001.02")]
pub struct Header23 {
    #[yaserde(rename = "FrmtVrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "FrmtVrsn"))]
    pub frmt_vrsn: Max6Text,

    #[yaserde(rename = "XchgId")]
    #[cfg_attr(feature = "serde", serde(rename = "XchgId"))]
    pub xchg_id: Max3NumericText,

    #[yaserde(rename = "InitgPty")]
    #[cfg_attr(feature = "serde", serde(rename = "InitgPty"))]
    pub initg_pty: GenericIdentification32,

    #[yaserde(rename = "RcptPty")]
    #[cfg_attr(feature = "serde", serde(rename = "RcptPty"))]
    pub rcpt_pty: GenericIdentification32,

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

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

impl Validate for Header23 {}


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

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

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

impl Validate for IsodateTime {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:fxtr.035.001.02")]
pub struct IdentificationSource1Choice {
    #[yaserde(rename = "Dmst")]
    #[cfg_attr(feature = "serde", serde(rename = "Dmst"))]
    pub dmst: Option<CountryCode>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max35Text>,
}

impl Validate for IdentificationSource1Choice {}




#[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:fxtr.035.001.02")]

pub enum IdentificationType1Code {
    #[yaserde(rename = "BASC")]
    #[cfg_attr(feature = "serde", serde(rename = "BASC"))]
    Basc,
    #[yaserde(rename = "BICO")]
    #[cfg_attr(feature = "serde", serde(rename = "BICO"))]
    Bico,
    #[yaserde(rename = "CFET")]
    #[cfg_attr(feature = "serde", serde(rename = "CFET"))]
    Cfet,
    __Unknown__(String),
}

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

impl Validate for IdentificationType1Code {}



#[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:fxtr.035.001.02")]

pub enum IdentificationType2Code {
    #[yaserde(rename = "CDCO")]
    #[cfg_attr(feature = "serde", serde(rename = "CDCO"))]
    Cdco,
    #[yaserde(rename = "CFET")]
    #[cfg_attr(feature = "serde", serde(rename = "CFET"))]
    Cfet,
    #[yaserde(rename = "RICC")]
    #[cfg_attr(feature = "serde", serde(rename = "RICC"))]
    Ricc,
    #[yaserde(rename = "USDE")]
    #[cfg_attr(feature = "serde", serde(rename = "USDE"))]
    Usde,
    __Unknown__(String),
}

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

impl Validate for IdentificationType2Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:fxtr.035.001.02")]
pub struct InstrumentLeg7 {
    #[yaserde(rename = "LegSd")]
    #[cfg_attr(feature = "serde", serde(rename = "LegSd"))]
    pub leg_sd: Side1Code,

    #[yaserde(rename = "LegSttlmTp")]
    #[cfg_attr(feature = "serde", serde(rename = "LegSttlmTp"))]
    pub leg_sttlm_tp: SettlementDate8Code,

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

    #[yaserde(rename = "LegLastPric")]
    #[cfg_attr(feature = "serde", serde(rename = "LegLastPric"))]
    pub leg_last_pric: ActiveCurrencyAnd13DecimalAmount,

    #[yaserde(rename = "LegSttlmCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "LegSttlmCcy"))]
    pub leg_sttlm_ccy: ActiveCurrencyCode,

    #[yaserde(rename = "LegOrdrQty")]
    #[cfg_attr(feature = "serde", serde(rename = "LegOrdrQty"))]
    pub leg_ordr_qty: ActiveCurrencyAndAmount,

    #[yaserde(rename = "LegFwdPts")]
    #[cfg_attr(feature = "serde", serde(rename = "LegFwdPts"))]
    pub leg_fwd_pts: DecimalNumber,

    #[yaserde(rename = "LegClctdCtrPtyCcyLastQty")]
    #[cfg_attr(feature = "serde", serde(rename = "LegClctdCtrPtyCcyLastQty"))]
    pub leg_clctd_ctr_pty_ccy_last_qty: ActiveCurrencyAndAmount,

    #[yaserde(rename = "LegRskAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "LegRskAmt"))]
    pub leg_rsk_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "LegValtnRate")]
    #[cfg_attr(feature = "serde", serde(rename = "LegValtnRate"))]
    pub leg_valtn_rate: AgreedRate3,

    #[yaserde(rename = "LegValDt")]
    #[cfg_attr(feature = "serde", serde(rename = "LegValDt"))]
    pub leg_val_dt: Isodate,

    #[yaserde(rename = "LegCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "LegCcy"))]
    pub leg_ccy: ActiveCurrencyCode,

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

    #[yaserde(rename = "LegSctyId")]
    #[cfg_attr(feature = "serde", serde(rename = "LegSctyId"))]
    pub leg_scty_id: SecurityIdentification18,
}

impl Validate for InstrumentLeg7 {}


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

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

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

impl Validate for Max6Text {
    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() > 6 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 6 \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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:fxtr.035.001.02")]
pub struct MessageIdentification1 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

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

impl Validate for MessageIdentification1 {}


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

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

impl Validate for NameAndAddress8 {}


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

impl Validate for Number {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:fxtr.035.001.02")]

pub enum OptionParty1Code {
    #[yaserde(rename = "SLLR")]
    #[cfg_attr(feature = "serde", serde(rename = "SLLR"))]
    Sllr,
    #[yaserde(rename = "BYER")]
    #[cfg_attr(feature = "serde", serde(rename = "BYER"))]
    Byer,
    __Unknown__(String),
}

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

impl Validate for OptionParty1Code {}



#[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:fxtr.035.001.02")]

pub enum OptionParty3Code {
    #[yaserde(rename = "MAKE")]
    #[cfg_attr(feature = "serde", serde(rename = "MAKE"))]
    Make,
    #[yaserde(rename = "TAKE")]
    #[cfg_attr(feature = "serde", serde(rename = "TAKE"))]
    Take,
    __Unknown__(String),
}

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

impl Validate for OptionParty3Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:fxtr.035.001.02")]
pub struct PartyIdentification251Choice {
    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: Option<NameAndAddress8>,
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_b_i_c: Option<PartyIdentification265>,
}

impl Validate for PartyIdentification251Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:fxtr.035.001.02")]
pub struct PartyIdentification265 {
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_bic: AnyBICDec2014Identifier,

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

impl Validate for PartyIdentification265 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:fxtr.035.001.02")]
pub struct PartyIdentification78 {
    #[yaserde(rename = "PtySrc")]
    #[cfg_attr(feature = "serde", serde(rename = "PtySrc"))]
    pub pty_src: IdentificationType1Code,

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

impl Validate for PartyIdentification78 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:fxtr.035.001.02")]
pub struct PartyIdentification90 {
    #[yaserde(rename = "IdTp")]
    #[cfg_attr(feature = "serde", serde(rename = "IdTp"))]
    pub id_tp: PartyIdentificationType1Code,

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

impl Validate for PartyIdentification90 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:fxtr.035.001.02")]
pub struct PartyIdentificationAndAccount119 {
    #[yaserde(rename = "PtyId")]
    #[cfg_attr(feature = "serde", serde(rename = "PtyId"))]
    pub pty_id: Vec<PartyIdentification90>,

    #[yaserde(rename = "AcctId")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctId"))]
    pub acct_id: Vec<AccountIdentification30>,
}

impl Validate for PartyIdentificationAndAccount119 {}


#[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:fxtr.035.001.02")]

pub enum PartyIdentificationType1Code {
    #[yaserde(rename = "FXID")]
    #[cfg_attr(feature = "serde", serde(rename = "FXID"))]
    Fxid,
    #[yaserde(rename = "FXSN")]
    #[cfg_attr(feature = "serde", serde(rename = "FXSN"))]
    Fxsn,
    #[yaserde(rename = "INGN")]
    #[cfg_attr(feature = "serde", serde(rename = "INGN"))]
    Ingn,
    #[yaserde(rename = "IICS")]
    #[cfg_attr(feature = "serde", serde(rename = "IICS"))]
    Iics,
    #[yaserde(rename = "IGBT")]
    #[cfg_attr(feature = "serde", serde(rename = "IGBT"))]
    Igbt,
    #[yaserde(rename = "MAMA")]
    #[cfg_attr(feature = "serde", serde(rename = "MAMA"))]
    Mama,
    #[yaserde(rename = "MEOC")]
    #[cfg_attr(feature = "serde", serde(rename = "MEOC"))]
    Meoc,
    #[yaserde(rename = "METY")]
    #[cfg_attr(feature = "serde", serde(rename = "METY"))]
    Mety,
    #[yaserde(rename = "NOMM")]
    #[cfg_attr(feature = "serde", serde(rename = "NOMM"))]
    Nomm,
    #[yaserde(rename = "OSCO")]
    #[cfg_attr(feature = "serde", serde(rename = "OSCO"))]
    Osco,
    #[yaserde(rename = "PASS")]
    #[cfg_attr(feature = "serde", serde(rename = "PASS"))]
    Pass,
    #[yaserde(rename = "PONU")]
    #[cfg_attr(feature = "serde", serde(rename = "PONU"))]
    Ponu,
    #[yaserde(rename = "POAD")]
    #[cfg_attr(feature = "serde", serde(rename = "POAD"))]
    Poad,
    #[yaserde(rename = "RMID")]
    #[cfg_attr(feature = "serde", serde(rename = "RMID"))]
    Rmid,
    #[yaserde(rename = "SLCN")]
    #[cfg_attr(feature = "serde", serde(rename = "SLCN"))]
    Slcn,
    #[yaserde(rename = "SLNF")]
    #[cfg_attr(feature = "serde", serde(rename = "SLNF"))]
    Slnf,
    #[yaserde(rename = "TACN")]
    #[cfg_attr(feature = "serde", serde(rename = "TACN"))]
    Tacn,
    #[yaserde(rename = "TRCO")]
    #[cfg_attr(feature = "serde", serde(rename = "TRCO"))]
    Trco,
    #[yaserde(rename = "TANA")]
    #[cfg_attr(feature = "serde", serde(rename = "TANA"))]
    Tana,
    #[yaserde(rename = "USIT")]
    #[cfg_attr(feature = "serde", serde(rename = "USIT"))]
    Usit,
    #[yaserde(rename = "USNA")]
    #[cfg_attr(feature = "serde", serde(rename = "USNA"))]
    Usna,
    #[yaserde(rename = "AUIT")]
    #[cfg_attr(feature = "serde", serde(rename = "AUIT"))]
    Auit,
    #[yaserde(rename = "BRID")]
    #[cfg_attr(feature = "serde", serde(rename = "BRID"))]
    Brid,
    #[yaserde(rename = "CLIN")]
    #[cfg_attr(feature = "serde", serde(rename = "CLIN"))]
    Clin,
    #[yaserde(rename = "CMID")]
    #[cfg_attr(feature = "serde", serde(rename = "CMID"))]
    Cmid,
    #[yaserde(rename = "COIN")]
    #[cfg_attr(feature = "serde", serde(rename = "COIN"))]
    Coin,
    #[yaserde(rename = "CMOT")]
    #[cfg_attr(feature = "serde", serde(rename = "CMOT"))]
    Cmot,
    #[yaserde(rename = "CONU")]
    #[cfg_attr(feature = "serde", serde(rename = "CONU"))]
    Conu,
    #[yaserde(rename = "CMIN")]
    #[cfg_attr(feature = "serde", serde(rename = "CMIN"))]
    Cmin,
    #[yaserde(rename = "DECN")]
    #[cfg_attr(feature = "serde", serde(rename = "DECN"))]
    Decn,
    #[yaserde(rename = "DEPA")]
    #[cfg_attr(feature = "serde", serde(rename = "DEPA"))]
    Depa,
    #[yaserde(rename = "ELCO")]
    #[cfg_attr(feature = "serde", serde(rename = "ELCO"))]
    Elco,
    #[yaserde(rename = "EXVE")]
    #[cfg_attr(feature = "serde", serde(rename = "EXVE"))]
    Exve,
    #[yaserde(rename = "FICO")]
    #[cfg_attr(feature = "serde", serde(rename = "FICO"))]
    Fico,
    #[yaserde(rename = "FIID")]
    #[cfg_attr(feature = "serde", serde(rename = "FIID"))]
    Fiid,
    #[yaserde(rename = "FLCN")]
    #[cfg_attr(feature = "serde", serde(rename = "FLCN"))]
    Flcn,
    #[yaserde(rename = "FLNF")]
    #[cfg_attr(feature = "serde", serde(rename = "FLNF"))]
    Flnf,
    __Unknown__(String),
}

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

impl Validate for PartyIdentificationType1Code {}



#[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:fxtr.035.001.02")]

pub enum PartyType3Code {
    #[yaserde(rename = "OPOI")]
    #[cfg_attr(feature = "serde", serde(rename = "OPOI"))]
    Opoi,
    #[yaserde(rename = "MERC")]
    #[cfg_attr(feature = "serde", serde(rename = "MERC"))]
    Merc,
    #[yaserde(rename = "ACCP")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCP"))]
    Accp,
    #[yaserde(rename = "ITAG")]
    #[cfg_attr(feature = "serde", serde(rename = "ITAG"))]
    Itag,
    #[yaserde(rename = "ACQR")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
    Acqr,
    #[yaserde(rename = "CISS")]
    #[cfg_attr(feature = "serde", serde(rename = "CISS"))]
    Ciss,
    #[yaserde(rename = "DLIS")]
    #[cfg_attr(feature = "serde", serde(rename = "DLIS"))]
    Dlis,
    __Unknown__(String),
}

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

impl Validate for PartyType3Code {}



#[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:fxtr.035.001.02")]

pub enum PartyType4Code {
    #[yaserde(rename = "MERC")]
    #[cfg_attr(feature = "serde", serde(rename = "MERC"))]
    Merc,
    #[yaserde(rename = "ACCP")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCP"))]
    Accp,
    #[yaserde(rename = "ITAG")]
    #[cfg_attr(feature = "serde", serde(rename = "ITAG"))]
    Itag,
    #[yaserde(rename = "ACQR")]
    #[cfg_attr(feature = "serde", serde(rename = "ACQR"))]
    Acqr,
    #[yaserde(rename = "CISS")]
    #[cfg_attr(feature = "serde", serde(rename = "CISS"))]
    Ciss,
    #[yaserde(rename = "TAXH")]
    #[cfg_attr(feature = "serde", serde(rename = "TAXH"))]
    Taxh,
    __Unknown__(String),
}

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

impl Validate for PartyType4Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:fxtr.035.001.02")]
pub struct Period12 {
    #[yaserde(rename = "StartDt")]
    #[cfg_attr(feature = "serde", serde(rename = "StartDt"))]
    pub start_dt: DateFormat45Choice,

    #[yaserde(rename = "EndDt")]
    #[cfg_attr(feature = "serde", serde(rename = "EndDt"))]
    pub end_dt: DateFormat45Choice,
}

impl Validate for Period12 {}


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

pub enum QueryTradeStatus1Code {
    #[yaserde(rename = "QAST")]
    #[cfg_attr(feature = "serde", serde(rename = "QAST"))]
    Qast,
    #[yaserde(rename = "QCTR")]
    #[cfg_attr(feature = "serde", serde(rename = "QCTR"))]
    Qctr,
    #[yaserde(rename = "QCIR")]
    #[cfg_attr(feature = "serde", serde(rename = "QCIR"))]
    Qcir,
    #[yaserde(rename = "QETR")]
    #[cfg_attr(feature = "serde", serde(rename = "QETR"))]
    Qetr,
    #[yaserde(rename = "QNTR")]
    #[cfg_attr(feature = "serde", serde(rename = "QNTR"))]
    Qntr,
    #[yaserde(rename = "QRTR")]
    #[cfg_attr(feature = "serde", serde(rename = "QRTR"))]
    Qrtr,
    __Unknown__(String),
}

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

impl Validate for QueryTradeStatus1Code {}



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

impl Validate for Ricidentifier {
    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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:fxtr.035.001.02")]
pub struct SecurityIdentification18 {
    #[yaserde(rename = "SctyIdSrc")]
    #[cfg_attr(feature = "serde", serde(rename = "SctyIdSrc"))]
    pub scty_id_src: IdentificationType2Code,

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

impl Validate for SecurityIdentification18 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:fxtr.035.001.02")]
pub struct SecurityIdentification38Choice {
    #[yaserde(rename = "ISIN")]
    #[cfg_attr(feature = "serde", serde(rename = "ISIN"))]
    pub isin: Option<Isinoct2015Identifier>,
    #[yaserde(rename = "AltrnId")]
    #[cfg_attr(feature = "serde", serde(rename = "AltrnId"))]
    pub altrn_id: Option<AlternateIdentification1>,
    #[yaserde(rename = "RIC")]
    #[cfg_attr(feature = "serde", serde(rename = "RIC"))]
    pub ric: Option<Ricidentifier>,
    #[yaserde(rename = "TckrSymb")]
    #[cfg_attr(feature = "serde", serde(rename = "TckrSymb"))]
    pub tckr_symb: Option<TickerIdentifier>,
    #[yaserde(rename = "Blmbrg")]
    #[cfg_attr(feature = "serde", serde(rename = "Blmbrg"))]
    pub blmbrg: Option<Bloomberg2Identifier>,
    #[yaserde(rename = "CTA")]
    #[cfg_attr(feature = "serde", serde(rename = "CTA"))]
    pub cta: Option<ConsolidatedTapeAssociationIdentifier>,
    #[yaserde(rename = "Cmon")]
    #[cfg_attr(feature = "serde", serde(rename = "Cmon"))]
    pub cmon: Option<EuroclearClearstreamIdentifier>,
}

impl Validate for SecurityIdentification38Choice {}




#[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:fxtr.035.001.02")]

pub enum SettlementDate8Code {
    #[yaserde(rename = "ASAP")]
    #[cfg_attr(feature = "serde", serde(rename = "ASAP"))]
    Asap,
    #[yaserde(rename = "ENDC")]
    #[cfg_attr(feature = "serde", serde(rename = "ENDC"))]
    Endc,
    #[yaserde(rename = "CASH")]
    #[cfg_attr(feature = "serde", serde(rename = "CASH"))]
    Cash,
    #[yaserde(rename = "CLEA")]
    #[cfg_attr(feature = "serde", serde(rename = "CLEA"))]
    Clea,
    #[yaserde(rename = "MONT")]
    #[cfg_attr(feature = "serde", serde(rename = "MONT"))]
    Mont,
    #[yaserde(rename = "FUTU")]
    #[cfg_attr(feature = "serde", serde(rename = "FUTU"))]
    Futu,
    #[yaserde(rename = "PRVD")]
    #[cfg_attr(feature = "serde", serde(rename = "PRVD"))]
    Prvd,
    #[yaserde(rename = "REGU")]
    #[cfg_attr(feature = "serde", serde(rename = "REGU"))]
    Regu,
    #[yaserde(rename = "SAVE")]
    #[cfg_attr(feature = "serde", serde(rename = "SAVE"))]
    Save,
    #[yaserde(rename = "SELL")]
    #[cfg_attr(feature = "serde", serde(rename = "SELL"))]
    Sell,
    #[yaserde(rename = "TBAT")]
    #[cfg_attr(feature = "serde", serde(rename = "TBAT"))]
    Tbat,
    #[yaserde(rename = "TFIV")]
    #[cfg_attr(feature = "serde", serde(rename = "TFIV"))]
    Tfiv,
    #[yaserde(rename = "TFOR")]
    #[cfg_attr(feature = "serde", serde(rename = "TFOR"))]
    Tfor,
    #[yaserde(rename = "TONE")]
    #[cfg_attr(feature = "serde", serde(rename = "TONE"))]
    Tone,
    #[yaserde(rename = "TTRE")]
    #[cfg_attr(feature = "serde", serde(rename = "TTRE"))]
    Ttre,
    #[yaserde(rename = "TTWO")]
    #[cfg_attr(feature = "serde", serde(rename = "TTWO"))]
    Ttwo,
    #[yaserde(rename = "WHIF")]
    #[cfg_attr(feature = "serde", serde(rename = "WHIF"))]
    Whif,
    #[yaserde(rename = "WDIS")]
    #[cfg_attr(feature = "serde", serde(rename = "WDIS"))]
    Wdis,
    #[yaserde(rename = "WISS")]
    #[cfg_attr(feature = "serde", serde(rename = "WISS"))]
    Wiss,
    #[yaserde(rename = "WHID")]
    #[cfg_attr(feature = "serde", serde(rename = "WHID"))]
    Whid,
    __Unknown__(String),
}

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

impl Validate for SettlementDate8Code {}



#[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:fxtr.035.001.02")]

pub enum Side1Code {
    #[yaserde(rename = "BUYI")]
    #[cfg_attr(feature = "serde", serde(rename = "BUYI"))]
    Buyi,
    #[yaserde(rename = "SELL")]
    #[cfg_attr(feature = "serde", serde(rename = "SELL"))]
    Sell,
    #[yaserde(rename = "TWOS")]
    #[cfg_attr(feature = "serde", serde(rename = "TWOS"))]
    Twos,
    #[yaserde(rename = "BUMI")]
    #[cfg_attr(feature = "serde", serde(rename = "BUMI"))]
    Bumi,
    #[yaserde(rename = "SEPL")]
    #[cfg_attr(feature = "serde", serde(rename = "SEPL"))]
    Sepl,
    #[yaserde(rename = "SESH")]
    #[cfg_attr(feature = "serde", serde(rename = "SESH"))]
    Sesh,
    #[yaserde(rename = "SSEX")]
    #[cfg_attr(feature = "serde", serde(rename = "SSEX"))]
    Ssex,
    #[yaserde(rename = "CROS")]
    #[cfg_attr(feature = "serde", serde(rename = "CROS"))]
    Cros,
    #[yaserde(rename = "CRSH")]
    #[cfg_attr(feature = "serde", serde(rename = "CRSH"))]
    Crsh,
    #[yaserde(rename = "CSHE")]
    #[cfg_attr(feature = "serde", serde(rename = "CSHE"))]
    Cshe,
    #[yaserde(rename = "DEFI")]
    #[cfg_attr(feature = "serde", serde(rename = "DEFI"))]
    Defi,
    #[yaserde(rename = "OPPO")]
    #[cfg_attr(feature = "serde", serde(rename = "OPPO"))]
    Oppo,
    #[yaserde(rename = "UNDI")]
    #[cfg_attr(feature = "serde", serde(rename = "UNDI"))]
    Undi,
    __Unknown__(String),
}

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

impl Validate for Side1Code {}



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

impl Validate for SimpleIdentificationInformation4 {}


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

impl Validate for SupplementaryDataEnvelope1 {}


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

impl Validate for TickerIdentifier {
    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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:fxtr.035.001.02")]
pub struct Trade10 {
    #[yaserde(rename = "ExctnPric")]
    #[cfg_attr(feature = "serde", serde(rename = "ExctnPric"))]
    pub exctn_pric: ActiveCurrencyAnd13DecimalAmount,

    #[yaserde(rename = "LastQty")]
    #[cfg_attr(feature = "serde", serde(rename = "LastQty"))]
    pub last_qty: ActiveCurrencyAndAmount,

    #[yaserde(rename = "SttlmTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmTp"))]
    pub sttlm_tp: SettlementDate8Code,

    #[yaserde(rename = "SttlmDt")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmDt"))]
    pub sttlm_dt: Isodate,

    #[yaserde(rename = "ValtnRate")]
    #[cfg_attr(feature = "serde", serde(rename = "ValtnRate"))]
    pub valtn_rate: AgreedRate3,

    #[yaserde(rename = "FwdPts")]
    #[cfg_attr(feature = "serde", serde(rename = "FwdPts"))]
    pub fwd_pts: DecimalNumber,

    #[yaserde(rename = "ClctdCtrPtyCcyLastQty")]
    #[cfg_attr(feature = "serde", serde(rename = "ClctdCtrPtyCcyLastQty"))]
    pub clctd_ctr_pty_ccy_last_qty: ActiveCurrencyAndAmount,

    #[yaserde(rename = "ValDt")]
    #[cfg_attr(feature = "serde", serde(rename = "ValDt"))]
    pub val_dt: Isodate,

    #[yaserde(rename = "RskAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "RskAmt"))]
    pub rsk_amt: ActiveCurrencyAndAmount,

    #[yaserde(rename = "SctyId")]
    #[cfg_attr(feature = "serde", serde(rename = "SctyId"))]
    pub scty_id: SecurityIdentification18,

    #[yaserde(rename = "FxgCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "FxgCcy"))]
    pub fxg_ccy: ActiveCurrencyCode,

    #[yaserde(rename = "FxgDt")]
    #[cfg_attr(feature = "serde", serde(rename = "FxgDt"))]
    pub fxg_dt: Isodate,

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

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

    #[yaserde(rename = "AssoctdTradRef")]
    #[cfg_attr(feature = "serde", serde(rename = "AssoctdTradRef"))]
    pub assoctd_trad_ref: Vec<Max70Text>,
}

impl Validate for Trade10 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:fxtr.035.001.02")]
pub struct Trade9 {
    #[yaserde(rename = "TradId")]
    #[cfg_attr(feature = "serde", serde(rename = "TradId"))]
    pub trad_id: Max35Text,

    #[yaserde(rename = "TradDt")]
    #[cfg_attr(feature = "serde", serde(rename = "TradDt"))]
    pub trad_dt: Isodate,

    #[yaserde(rename = "FXTradPdct")]
    #[cfg_attr(feature = "serde", serde(rename = "FXTradPdct"))]
    pub fx_trad_pdct: UnderlyingProductIdentifier1Code,

    #[yaserde(rename = "TradgCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "TradgCcy"))]
    pub tradg_ccy: ActiveCurrencyCode,

    #[yaserde(rename = "SttlmCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmCcy"))]
    pub sttlm_ccy: ActiveCurrencyCode,

    #[yaserde(rename = "TradgMtd")]
    #[cfg_attr(feature = "serde", serde(rename = "TradgMtd"))]
    pub tradg_mtd: TradingMethodType1Code,

    #[yaserde(rename = "TradgMd")]
    #[cfg_attr(feature = "serde", serde(rename = "TradgMd"))]
    pub tradg_md: TradingModeType1Code,

    #[yaserde(rename = "ClrMtd")]
    #[cfg_attr(feature = "serde", serde(rename = "ClrMtd"))]
    pub clr_mtd: ClearingMethod1Code,

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

    #[yaserde(rename = "PlcOfConf")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcOfConf"))]
    pub plc_of_conf: AnyBICDec2014Identifier,

    #[yaserde(rename = "FXDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "FXDtls"))]
    pub fx_dtls: Trade10,

    #[yaserde(rename = "SwpLeg")]
    #[cfg_attr(feature = "serde", serde(rename = "SwpLeg"))]
    pub swp_leg: Vec<InstrumentLeg7>,

    #[yaserde(rename = "PdctId")]
    #[cfg_attr(feature = "serde", serde(rename = "PdctId"))]
    pub pdct_id: SecurityIdentification38Choice,

    #[yaserde(rename = "AssoctdTradRef")]
    #[cfg_attr(feature = "serde", serde(rename = "AssoctdTradRef"))]
    pub assoctd_trad_ref: Vec<Max70Text>,
}

impl Validate for Trade9 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:fxtr.035.001.02")]
pub struct TradePartyIdentification9 {
    #[yaserde(rename = "FndInf")]
    #[cfg_attr(feature = "serde", serde(rename = "FndInf"))]
    pub fnd_inf: FundIdentification6,

    #[yaserde(rename = "BuyrOrSellrInd")]
    #[cfg_attr(feature = "serde", serde(rename = "BuyrOrSellrInd"))]
    pub buyr_or_sellr_ind: OptionParty1Code,

    #[yaserde(rename = "InitrInd")]
    #[cfg_attr(feature = "serde", serde(rename = "InitrInd"))]
    pub initr_ind: OptionParty3Code,

    #[yaserde(rename = "TradPtyId")]
    #[cfg_attr(feature = "serde", serde(rename = "TradPtyId"))]
    pub trad_pty_id: PartyIdentification78,

    #[yaserde(rename = "SubmitgPty")]
    #[cfg_attr(feature = "serde", serde(rename = "SubmitgPty"))]
    pub submitg_pty: PartyIdentificationAndAccount119,
}

impl Validate for TradePartyIdentification9 {}


#[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:fxtr.035.001.02")]

pub enum TradingMethodType1Code {
    #[yaserde(rename = "BITR")]
    #[cfg_attr(feature = "serde", serde(rename = "BITR"))]
    Bitr,
    #[yaserde(rename = "CERB")]
    #[cfg_attr(feature = "serde", serde(rename = "CERB"))]
    Cerb,
    #[yaserde(rename = "CUMA")]
    #[cfg_attr(feature = "serde", serde(rename = "CUMA"))]
    Cuma,
    #[yaserde(rename = "LIOR")]
    #[cfg_attr(feature = "serde", serde(rename = "LIOR"))]
    Lior,
    #[yaserde(rename = "NETR")]
    #[cfg_attr(feature = "serde", serde(rename = "NETR"))]
    Netr,
    #[yaserde(rename = "ONCT")]
    #[cfg_attr(feature = "serde", serde(rename = "ONCT"))]
    Onct,
    #[yaserde(rename = "QUAU")]
    #[cfg_attr(feature = "serde", serde(rename = "QUAU"))]
    Quau,
    #[yaserde(rename = "TEAU")]
    #[cfg_attr(feature = "serde", serde(rename = "TEAU"))]
    Teau,
    #[yaserde(rename = "ANCL")]
    #[cfg_attr(feature = "serde", serde(rename = "ANCL"))]
    Ancl,
    __Unknown__(String),
}

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

impl Validate for TradingMethodType1Code {}



#[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:fxtr.035.001.02")]

pub enum TradingModeType1Code {
    #[yaserde(rename = "QUDR")]
    #[cfg_attr(feature = "serde", serde(rename = "QUDR"))]
    Qudr,
    #[yaserde(rename = "ORDR")]
    #[cfg_attr(feature = "serde", serde(rename = "ORDR"))]
    Ordr,
    #[yaserde(rename = "NETR")]
    #[cfg_attr(feature = "serde", serde(rename = "NETR"))]
    Netr,
    #[yaserde(rename = "AUCT")]
    #[cfg_attr(feature = "serde", serde(rename = "AUCT"))]
    Auct,
    #[yaserde(rename = "MARC")]
    #[cfg_attr(feature = "serde", serde(rename = "MARC"))]
    Marc,
    #[yaserde(rename = "BILA")]
    #[cfg_attr(feature = "serde", serde(rename = "BILA"))]
    Bila,
    #[yaserde(rename = "ANON")]
    #[cfg_attr(feature = "serde", serde(rename = "ANON"))]
    Anon,
    __Unknown__(String),
}

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

impl Validate for TradingModeType1Code {}



#[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:fxtr.035.001.02")]

pub enum UnderlyingProductIdentifier1Code {
    #[yaserde(rename = "FORW")]
    #[cfg_attr(feature = "serde", serde(rename = "FORW"))]
    Forw,
    #[yaserde(rename = "NDFO")]
    #[cfg_attr(feature = "serde", serde(rename = "NDFO"))]
    Ndfo,
    #[yaserde(rename = "SPOT")]
    #[cfg_attr(feature = "serde", serde(rename = "SPOT"))]
    Spot,
    #[yaserde(rename = "SWAP")]
    #[cfg_attr(feature = "serde", serde(rename = "SWAP"))]
    Swap,
    __Unknown__(String),
}

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

impl Validate for UnderlyingProductIdentifier1Code {}

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