rust_iso20022 0.1.1

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

// pub type Document = Document;
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct 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.034.001.01")]
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.034.001.01")]
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(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:fxtr.034.001.01")]
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.034.001.01")]
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 AnyBICIdentifier (pub String);
crate::simple_type!(AnyBICIdentifier);

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

impl Validate for BloombergIdentifier {
    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(PartialEq, Debug, Clone, YaSerialize, YaDeserialize)]#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:fxtr.034.001.01")]

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

pub enum ConfirmationRequest1Code {
    #[yaserde(rename = "CONF")]
    #[cfg_attr(feature = "serde", serde(rename = "CONF"))]
    Conf,
    #[yaserde(rename = "CNRR")]
    #[cfg_attr(feature = "serde", serde(rename = "CNRR"))]
    Cnrr,
    #[yaserde(rename = "STAT")]
    #[cfg_attr(feature = "serde", serde(rename = "STAT"))]
    Stat,
    __Unknown__(String),
}

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

impl Validate for ConfirmationRequest1Code {}



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

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

impl Validate for CurrencyAndAmount {}


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

impl Validate for CurrencyCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.034.001.01")]
pub struct DateAndDateTimeChoice {
    #[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 DateAndDateTimeChoice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, 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.034.001.01")]
pub struct DateFormat18Choice {
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Option<DateAndDateTimeChoice>,
    #[yaserde(rename = "NotSpcfdDt")]
    #[cfg_attr(feature = "serde", serde(rename = "NotSpcfdDt"))]
    pub not_spcfd_dt: Option<DateType8Code>,
}

impl Validate for DateFormat18Choice {}




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

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.034.001.01")]
pub struct Document {
    #[yaserde(rename = "FXTradConfReq")]
    #[cfg_attr(feature = "serde", serde(rename = "FXTradConfReq"))]
    pub fx_trad_conf_req: ForeignExchangeTradeConfirmationRequestV01,
}

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.034.001.01")]
pub struct ForeignExchangeTradeConfirmationRequestV01 {
    #[yaserde(rename = "Hdr")]
    #[cfg_attr(feature = "serde", serde(rename = "Hdr"))]
    pub hdr: Header23,

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

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

    #[yaserde(rename = "ConfTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ConfTp"))]
    pub conf_tp: ConfirmationRequest1Code,

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

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


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

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.034.001.01")]
pub struct InstrumentLeg6 {
    #[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: SettlementDateCode,

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

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

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

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

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


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

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

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.034.001.01")]
pub struct Period4 {
    #[yaserde(rename = "StartDt")]
    #[cfg_attr(feature = "serde", serde(rename = "StartDt"))]
    pub start_dt: DateFormat18Choice,

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

impl Validate for Period4 {}


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

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.034.001.01")]
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.034.001.01")]
pub struct SecurityIdentification22Choice {
    #[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<BloombergIdentifier>,
    #[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 SecurityIdentification22Choice {}




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

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

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

impl Validate for SettlementDateCode {}



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

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.034.001.01")]
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.034.001.01")]
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.034.001.01")]
pub struct Trade2 {
    #[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: CurrencyCode,

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

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

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

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

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

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

impl Validate for Trade2 {}


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

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

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

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

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

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

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

impl Validate for Trade3 {}


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

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

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

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 {}



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

impl Validate for YesNoIndicator {}

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