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:tsmt.014.001.05")]
pub struct AccountIdentification4Choice {
    #[yaserde(rename = "IBAN")]
    #[cfg_attr(feature = "serde", serde(rename = "IBAN"))]
    pub iban: Option<Iban2007Identifier>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<GenericAccountIdentification1>,
}

impl Validate for AccountIdentification4Choice {}
#[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:tsmt.014.001.05")]
pub struct AccountSchemeName1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ExternalAccountIdentification1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max35Text>,
}

impl Validate for AccountSchemeName1Choice {}




#[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:tsmt.014.001.05")]
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)]
pub struct ActiveOrHistoricCurrencyCode (pub String);
crate::simple_type!(ActiveOrHistoricCurrencyCode);

impl Validate for ActiveOrHistoricCurrencyCode {}
#[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:tsmt.014.001.05")]
pub struct Adjustment6 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: AdjustmentType1Choice,

    #[yaserde(rename = "Drctn")]
    #[cfg_attr(feature = "serde", serde(rename = "Drctn"))]
    pub drctn: AdjustmentDirection1Code,

    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: CurrencyAndAmount,
}

impl Validate for Adjustment6 {}


#[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:tsmt.014.001.05")]

pub enum AdjustmentDirection1Code {
    #[yaserde(rename = "ADDD")]
    #[cfg_attr(feature = "serde", serde(rename = "ADDD"))]
    Addd,
    #[yaserde(rename = "SUBS")]
    #[cfg_attr(feature = "serde", serde(rename = "SUBS"))]
    Subs,
    __Unknown__(String),
}

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

impl Validate for AdjustmentDirection1Code {}
#[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:tsmt.014.001.05")]
pub struct AdjustmentType1Choice {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: Option<AdjustmentType2Code>,
    #[yaserde(rename = "OthrAdjstmntTp")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrAdjstmntTp"))]
    pub othr_adjstmnt_tp: Option<Max35Text>,
}

impl Validate for AdjustmentType1Choice {}




#[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:tsmt.014.001.05")]

pub enum AdjustmentType2Code {
    #[yaserde(rename = "REBA")]
    #[cfg_attr(feature = "serde", serde(rename = "REBA"))]
    Reba,
    #[yaserde(rename = "DISC")]
    #[cfg_attr(feature = "serde", serde(rename = "DISC"))]
    Disc,
    #[yaserde(rename = "CREN")]
    #[cfg_attr(feature = "serde", serde(rename = "CREN"))]
    Cren,
    #[yaserde(rename = "SURC")]
    #[cfg_attr(feature = "serde", serde(rename = "SURC"))]
    Surc,
    __Unknown__(String),
}

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

impl Validate for AdjustmentType2Code {}



#[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:tsmt.014.001.05")]
pub struct AirportDescription1 {
    #[yaserde(rename = "Twn")]
    #[cfg_attr(feature = "serde", serde(rename = "Twn"))]
    pub twn: Max35Text,

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

impl Validate for AirportDescription1 {}
#[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:tsmt.014.001.05")]
pub struct AirportName1Choice {
    #[yaserde(rename = "AirprtCd")]
    #[cfg_attr(feature = "serde", serde(rename = "AirprtCd"))]
    pub airprt_cd: Option<Max6Text>,
    #[yaserde(rename = "OthrAirprtDesc")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrAirprtDesc"))]
    pub othr_airprt_desc: Option<AirportDescription1>,
}

impl Validate for AirportName1Choice {}
#[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:tsmt.014.001.05")]
pub struct AmountOrPercentage2Choice {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<ActiveCurrencyAndAmount>,
    #[yaserde(rename = "Pctg")]
    #[cfg_attr(feature = "serde", serde(rename = "Pctg"))]
    pub pctg: Option<PercentageRate>,
}

impl Validate for AmountOrPercentage2Choice {}




#[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:tsmt.014.001.05")]
pub struct Bicidentification1 {
    #[yaserde(rename = "BIC")]
    #[cfg_attr(feature = "serde", serde(rename = "BIC"))]
    pub bic: Bicidentifier,
}

impl Validate for Bicidentification1 {}


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

impl Validate for Bicidentifier {}
#[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:tsmt.014.001.05")]
pub struct CashAccount24 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: AccountIdentification4Choice,

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

    #[yaserde(rename = "Ccy")]
    #[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
    pub ccy: ActiveOrHistoricCurrencyCode,

    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max70Text,
}

impl Validate for CashAccount24 {}
#[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:tsmt.014.001.05")]
pub struct CashAccountType2Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ExternalCashAccountType1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<Max35Text>,
}

impl Validate for CashAccountType2Choice {}




#[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:tsmt.014.001.05")]
pub struct CertificateDataSet2 {
    #[yaserde(rename = "DataSetId")]
    #[cfg_attr(feature = "serde", serde(rename = "DataSetId"))]
    pub data_set_id: DocumentIdentification1,

    #[yaserde(rename = "CertTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CertTp"))]
    pub cert_tp: TradeCertificateType1Code,

    #[yaserde(rename = "LineItm")]
    #[cfg_attr(feature = "serde", serde(rename = "LineItm"))]
    pub line_itm: Vec<LineItemAndPOIdentification1>,

    #[yaserde(rename = "CertfdChrtcs")]
    #[cfg_attr(feature = "serde", serde(rename = "CertfdChrtcs"))]
    pub certfd_chrtcs: CertifiedCharacteristics2Choice,

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

    #[yaserde(rename = "PlcOfIsse")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcOfIsse"))]
    pub plc_of_isse: PostalAddress5,

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

    #[yaserde(rename = "InspctnDt")]
    #[cfg_attr(feature = "serde", serde(rename = "InspctnDt"))]
    pub inspctn_dt: DatePeriodDetails,

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

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

    #[yaserde(rename = "Trnsprt")]
    #[cfg_attr(feature = "serde", serde(rename = "Trnsprt"))]
    pub trnsprt: SingleTransport3,

    #[yaserde(rename = "GoodsDesc")]
    #[cfg_attr(feature = "serde", serde(rename = "GoodsDesc"))]
    pub goods_desc: Max70Text,

    #[yaserde(rename = "Consgnr")]
    #[cfg_attr(feature = "serde", serde(rename = "Consgnr"))]
    pub consgnr: PartyIdentification26,

    #[yaserde(rename = "Consgn")]
    #[cfg_attr(feature = "serde", serde(rename = "Consgn"))]
    pub consgn: PartyIdentification26,

    #[yaserde(rename = "Manfctr")]
    #[cfg_attr(feature = "serde", serde(rename = "Manfctr"))]
    pub manfctr: PartyIdentification26,

    #[yaserde(rename = "AddtlInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlInf"))]
    pub addtl_inf: Vec<Max350Text>,
}

impl Validate for CertificateDataSet2 {}
#[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:tsmt.014.001.05")]
pub struct CertifiedCharacteristics2Choice {
    #[yaserde(rename = "Orgn")]
    #[cfg_attr(feature = "serde", serde(rename = "Orgn"))]
    pub orgn: Option<CountryCode>,
    #[yaserde(rename = "Qlty")]
    #[cfg_attr(feature = "serde", serde(rename = "Qlty"))]
    pub qlty: Option<Max70Text>,
    #[yaserde(rename = "Anlys")]
    #[cfg_attr(feature = "serde", serde(rename = "Anlys"))]
    pub anlys: Option<Max70Text>,
    #[yaserde(rename = "Wght")]
    #[cfg_attr(feature = "serde", serde(rename = "Wght"))]
    pub wght: Option<Quantity9>,
    #[yaserde(rename = "Qty")]
    #[cfg_attr(feature = "serde", serde(rename = "Qty"))]
    pub qty: Option<Quantity9>,
    #[yaserde(rename = "HlthIndctn")]
    #[cfg_attr(feature = "serde", serde(rename = "HlthIndctn"))]
    pub hlth_indctn: Option<YesNoIndicator>,
    #[yaserde(rename = "PhytosntryIndctn")]
    #[cfg_attr(feature = "serde", serde(rename = "PhytosntryIndctn"))]
    pub phytosntry_indctn: Option<YesNoIndicator>,
}

impl Validate for CertifiedCharacteristics2Choice {}




#[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:tsmt.014.001.05")]
pub struct Charge25 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: FreightCharges1Code,

    #[yaserde(rename = "Chrgs")]
    #[cfg_attr(feature = "serde", serde(rename = "Chrgs"))]
    pub chrgs: Vec<ChargesDetails4>,
}

impl Validate for Charge25 {}


#[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:tsmt.014.001.05")]

pub enum ChargeType8Code {
    #[yaserde(rename = "SIGN")]
    #[cfg_attr(feature = "serde", serde(rename = "SIGN"))]
    Sign,
    #[yaserde(rename = "STDE")]
    #[cfg_attr(feature = "serde", serde(rename = "STDE"))]
    Stde,
    #[yaserde(rename = "STOR")]
    #[cfg_attr(feature = "serde", serde(rename = "STOR"))]
    Stor,
    #[yaserde(rename = "PACK")]
    #[cfg_attr(feature = "serde", serde(rename = "PACK"))]
    Pack,
    #[yaserde(rename = "PICK")]
    #[cfg_attr(feature = "serde", serde(rename = "PICK"))]
    Pick,
    #[yaserde(rename = "DNGR")]
    #[cfg_attr(feature = "serde", serde(rename = "DNGR"))]
    Dngr,
    #[yaserde(rename = "SECU")]
    #[cfg_attr(feature = "serde", serde(rename = "SECU"))]
    Secu,
    #[yaserde(rename = "INSU")]
    #[cfg_attr(feature = "serde", serde(rename = "INSU"))]
    Insu,
    #[yaserde(rename = "COLF")]
    #[cfg_attr(feature = "serde", serde(rename = "COLF"))]
    Colf,
    #[yaserde(rename = "CHOR")]
    #[cfg_attr(feature = "serde", serde(rename = "CHOR"))]
    Chor,
    #[yaserde(rename = "CHDE")]
    #[cfg_attr(feature = "serde", serde(rename = "CHDE"))]
    Chde,
    #[yaserde(rename = "AIRF")]
    #[cfg_attr(feature = "serde", serde(rename = "AIRF"))]
    Airf,
    #[yaserde(rename = "TRPT")]
    #[cfg_attr(feature = "serde", serde(rename = "TRPT"))]
    Trpt,
    __Unknown__(String),
}

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

impl Validate for ChargeType8Code {}



#[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:tsmt.014.001.05")]
pub struct ChargesDetails4 {
    #[yaserde(rename = "ChrgsTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ChrgsTp"))]
    pub chrgs_tp: ChargesType1Choice,

    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: CurrencyAndAmount,
}

impl Validate for ChargesDetails4 {}
#[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:tsmt.014.001.05")]
pub struct ChargesType1Choice {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: Option<ChargeType8Code>,
    #[yaserde(rename = "OthrChrgsTp")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrChrgsTp"))]
    pub othr_chrgs_tp: Option<Max35Text>,
}

impl Validate for ChargesType1Choice {}




#[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:tsmt.014.001.05")]
pub struct CommercialDataSet5 {
    #[yaserde(rename = "DataSetId")]
    #[cfg_attr(feature = "serde", serde(rename = "DataSetId"))]
    pub data_set_id: DocumentIdentification1,

    #[yaserde(rename = "ComrclDocRef")]
    #[cfg_attr(feature = "serde", serde(rename = "ComrclDocRef"))]
    pub comrcl_doc_ref: InvoiceIdentification1,

    #[yaserde(rename = "Buyr")]
    #[cfg_attr(feature = "serde", serde(rename = "Buyr"))]
    pub buyr: PartyIdentification26,

    #[yaserde(rename = "Sellr")]
    #[cfg_attr(feature = "serde", serde(rename = "Sellr"))]
    pub sellr: PartyIdentification26,

    #[yaserde(rename = "BllTo")]
    #[cfg_attr(feature = "serde", serde(rename = "BllTo"))]
    pub bll_to: PartyIdentification26,

    #[yaserde(rename = "Goods")]
    #[cfg_attr(feature = "serde", serde(rename = "Goods"))]
    pub goods: Vec<LineItem15>,

    #[yaserde(rename = "PmtTerms")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtTerms"))]
    pub pmt_terms: Vec<PaymentTerms4>,

    #[yaserde(rename = "SttlmTerms")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmTerms"))]
    pub sttlm_terms: SettlementTerms3,
}

impl Validate for CommercialDataSet5 {}


#[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:tsmt.014.001.05")]
pub struct Consignment3 {
    #[yaserde(rename = "TtlQty")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlQty"))]
    pub ttl_qty: Quantity10,

    #[yaserde(rename = "TtlVol")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlVol"))]
    pub ttl_vol: Quantity10,

    #[yaserde(rename = "TtlWght")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlWght"))]
    pub ttl_wght: Quantity10,
}

impl Validate for Consignment3 {}


#[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:tsmt.014.001.05")]
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:tsmt.014.001.05")]
pub struct DataSetSubmissionReferences3 {
    #[yaserde(rename = "TxId")]
    #[cfg_attr(feature = "serde", serde(rename = "TxId"))]
    pub tx_id: Max35Text,

    #[yaserde(rename = "PurchsOrdrRef")]
    #[cfg_attr(feature = "serde", serde(rename = "PurchsOrdrRef"))]
    pub purchs_ordr_ref: DocumentIdentification7,

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

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

impl Validate for DataSetSubmissionReferences3 {}


#[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:tsmt.014.001.05")]
pub struct DataSetSubmissionV05 {
    #[yaserde(rename = "SubmissnId")]
    #[cfg_attr(feature = "serde", serde(rename = "SubmissnId"))]
    pub submissn_id: MessageIdentification1,

    #[yaserde(rename = "RltdTxRefs")]
    #[cfg_attr(feature = "serde", serde(rename = "RltdTxRefs"))]
    pub rltd_tx_refs: Vec<DataSetSubmissionReferences3>,

    #[yaserde(rename = "CmonSubmissnRef")]
    #[cfg_attr(feature = "serde", serde(rename = "CmonSubmissnRef"))]
    pub cmon_submissn_ref: SimpleIdentificationInformation,

    #[yaserde(rename = "Instr")]
    #[cfg_attr(feature = "serde", serde(rename = "Instr"))]
    pub instr: InstructionType3,

    #[yaserde(rename = "BuyrBk")]
    #[cfg_attr(feature = "serde", serde(rename = "BuyrBk"))]
    pub buyr_bk: Bicidentification1,

    #[yaserde(rename = "SellrBk")]
    #[cfg_attr(feature = "serde", serde(rename = "SellrBk"))]
    pub sellr_bk: Bicidentification1,

    #[yaserde(rename = "ComrclDataSet")]
    #[cfg_attr(feature = "serde", serde(rename = "ComrclDataSet"))]
    pub comrcl_data_set: CommercialDataSet5,

    #[yaserde(rename = "TrnsprtDataSet")]
    #[cfg_attr(feature = "serde", serde(rename = "TrnsprtDataSet"))]
    pub trnsprt_data_set: TransportDataSet5,

    #[yaserde(rename = "InsrncDataSet")]
    #[cfg_attr(feature = "serde", serde(rename = "InsrncDataSet"))]
    pub insrnc_data_set: InsuranceDataSet1,

    #[yaserde(rename = "CertDataSet")]
    #[cfg_attr(feature = "serde", serde(rename = "CertDataSet"))]
    pub cert_data_set: Vec<CertificateDataSet2>,

    #[yaserde(rename = "OthrCertDataSet")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrCertDataSet"))]
    pub othr_cert_data_set: Vec<OtherCertificateDataSet2>,
}

impl Validate for DataSetSubmissionV05 {}


#[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:tsmt.014.001.05")]
pub struct DatePeriodDetails {
    #[yaserde(rename = "FrDt")]
    #[cfg_attr(feature = "serde", serde(rename = "FrDt"))]
    pub fr_dt: Isodate,

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

impl Validate for DatePeriodDetails {}


#[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:tsmt.014.001.05")]
pub struct Document {
    #[yaserde(rename = "DataSetSubmissn")]
    #[cfg_attr(feature = "serde", serde(rename = "DataSetSubmissn"))]
    pub data_set_submissn: DataSetSubmissionV05,
}

impl Validate for Document {}


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

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

    #[yaserde(rename = "Submitr")]
    #[cfg_attr(feature = "serde", serde(rename = "Submitr"))]
    pub submitr: Bicidentification1,
}

impl Validate for DocumentIdentification1 {}


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

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

impl Validate for DocumentIdentification7 {}


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

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

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

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

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

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

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

impl Validate for ExternalIncoterms1Code {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 4 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 4 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsmt.014.001.05")]
pub struct FinancialInstitutionIdentification4Choice {
    #[yaserde(rename = "BIC")]
    #[cfg_attr(feature = "serde", serde(rename = "BIC"))]
    pub bic: Option<Bicidentifier>,
    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: Option<NameAndAddress6>,
}

impl Validate for FinancialInstitutionIdentification4Choice {}




#[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:tsmt.014.001.05")]

pub enum FreightCharges1Code {
    #[yaserde(rename = "CLCT")]
    #[cfg_attr(feature = "serde", serde(rename = "CLCT"))]
    Clct,
    #[yaserde(rename = "PRPD")]
    #[cfg_attr(feature = "serde", serde(rename = "PRPD"))]
    Prpd,
    __Unknown__(String),
}

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

impl Validate for FreightCharges1Code {}



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

    #[yaserde(rename = "SchmeNm")]
    #[cfg_attr(feature = "serde", serde(rename = "SchmeNm"))]
    pub schme_nm: AccountSchemeName1Choice,

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

impl Validate for GenericAccountIdentification1 {}


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

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

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

impl Validate for GenericIdentification13 {}


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

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

impl Validate for GenericIdentification4 {}


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

impl Validate for Iban2007Identifier {}
#[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:tsmt.014.001.05")]
pub struct Incoterms4 {
    #[yaserde(rename = "IncotrmsCd")]
    #[cfg_attr(feature = "serde", serde(rename = "IncotrmsCd"))]
    pub incotrms_cd: Incoterms4Choice,

    #[yaserde(rename = "Lctn")]
    #[cfg_attr(feature = "serde", serde(rename = "Lctn"))]
    pub lctn: Max70Text,
}

impl Validate for Incoterms4 {}
#[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:tsmt.014.001.05")]
pub struct Incoterms4Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ExternalIncoterms1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification13>,
}

impl Validate for Incoterms4Choice {}




#[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:tsmt.014.001.05")]
pub struct InstructionType3 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: InstructionType3Code,
}

impl Validate for InstructionType3 {}


#[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:tsmt.014.001.05")]

pub enum InstructionType3Code {
    #[yaserde(rename = "MTCH")]
    #[cfg_attr(feature = "serde", serde(rename = "MTCH"))]
    Mtch,
    #[yaserde(rename = "PMTC")]
    #[cfg_attr(feature = "serde", serde(rename = "PMTC"))]
    Pmtc,
    __Unknown__(String),
}

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

impl Validate for InstructionType3Code {}



#[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:tsmt.014.001.05")]

pub enum InsuranceClauses1Code {
    #[yaserde(rename = "ICCA")]
    #[cfg_attr(feature = "serde", serde(rename = "ICCA"))]
    Icca,
    #[yaserde(rename = "ICCB")]
    #[cfg_attr(feature = "serde", serde(rename = "ICCB"))]
    Iccb,
    #[yaserde(rename = "ICCC")]
    #[cfg_attr(feature = "serde", serde(rename = "ICCC"))]
    Iccc,
    #[yaserde(rename = "ICAI")]
    #[cfg_attr(feature = "serde", serde(rename = "ICAI"))]
    Icai,
    #[yaserde(rename = "IWCC")]
    #[cfg_attr(feature = "serde", serde(rename = "IWCC"))]
    Iwcc,
    #[yaserde(rename = "ISCC")]
    #[cfg_attr(feature = "serde", serde(rename = "ISCC"))]
    Iscc,
    #[yaserde(rename = "IREC")]
    #[cfg_attr(feature = "serde", serde(rename = "IREC"))]
    Irec,
    #[yaserde(rename = "ICLC")]
    #[cfg_attr(feature = "serde", serde(rename = "ICLC"))]
    Iclc,
    #[yaserde(rename = "ISMC")]
    #[cfg_attr(feature = "serde", serde(rename = "ISMC"))]
    Ismc,
    #[yaserde(rename = "CMCC")]
    #[cfg_attr(feature = "serde", serde(rename = "CMCC"))]
    Cmcc,
    #[yaserde(rename = "IRCE")]
    #[cfg_attr(feature = "serde", serde(rename = "IRCE"))]
    Irce,
    __Unknown__(String),
}

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

impl Validate for InsuranceClauses1Code {}



#[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:tsmt.014.001.05")]
pub struct InsuranceDataSet1 {
    #[yaserde(rename = "DataSetId")]
    #[cfg_attr(feature = "serde", serde(rename = "DataSetId"))]
    pub data_set_id: DocumentIdentification1,

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

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

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

    #[yaserde(rename = "PlcOfIsse")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcOfIsse"))]
    pub plc_of_isse: PostalAddress5,

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

    #[yaserde(rename = "Trnsprt")]
    #[cfg_attr(feature = "serde", serde(rename = "Trnsprt"))]
    pub trnsprt: SingleTransport3,

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

    #[yaserde(rename = "InsrdGoodsDesc")]
    #[cfg_attr(feature = "serde", serde(rename = "InsrdGoodsDesc"))]
    pub insrd_goods_desc: Max70Text,

    #[yaserde(rename = "InsrncConds")]
    #[cfg_attr(feature = "serde", serde(rename = "InsrncConds"))]
    pub insrnc_conds: Vec<Max350Text>,

    #[yaserde(rename = "InsrncClauses")]
    #[cfg_attr(feature = "serde", serde(rename = "InsrncClauses"))]
    pub insrnc_clauses: Vec<InsuranceClauses1Code>,

    #[yaserde(rename = "Assrd")]
    #[cfg_attr(feature = "serde", serde(rename = "Assrd"))]
    pub assrd: PartyIdentification29Choice,

    #[yaserde(rename = "ClmsPyblAt")]
    #[cfg_attr(feature = "serde", serde(rename = "ClmsPyblAt"))]
    pub clms_pybl_at: PostalAddress5,

    #[yaserde(rename = "ClmsPyblIn")]
    #[cfg_attr(feature = "serde", serde(rename = "ClmsPyblIn"))]
    pub clms_pybl_in: CurrencyCode,
}

impl Validate for InsuranceDataSet1 {}


#[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:tsmt.014.001.05")]
pub struct InvoiceIdentification1 {
    #[yaserde(rename = "InvcNb")]
    #[cfg_attr(feature = "serde", serde(rename = "InvcNb"))]
    pub invc_nb: Max35Text,

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

impl Validate for InvoiceIdentification1 {}


#[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:tsmt.014.001.05")]
pub struct LineItem15 {
    #[yaserde(rename = "PurchsOrdrRef")]
    #[cfg_attr(feature = "serde", serde(rename = "PurchsOrdrRef"))]
    pub purchs_ordr_ref: DocumentIdentification7,

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

    #[yaserde(rename = "ComrclLineItms")]
    #[cfg_attr(feature = "serde", serde(rename = "ComrclLineItms"))]
    pub comrcl_line_itms: Vec<LineItemDetails14>,

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

    #[yaserde(rename = "Adjstmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "Adjstmnt"))]
    pub adjstmnt: Vec<Adjustment6>,

    #[yaserde(rename = "FrghtChrgs")]
    #[cfg_attr(feature = "serde", serde(rename = "FrghtChrgs"))]
    pub frght_chrgs: Charge25,

    #[yaserde(rename = "Tax")]
    #[cfg_attr(feature = "serde", serde(rename = "Tax"))]
    pub tax: Vec<Tax22>,

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

    #[yaserde(rename = "BuyrDfndInf")]
    #[cfg_attr(feature = "serde", serde(rename = "BuyrDfndInf"))]
    pub buyr_dfnd_inf: Vec<UserDefinedInformation1>,

    #[yaserde(rename = "SellrDfndInf")]
    #[cfg_attr(feature = "serde", serde(rename = "SellrDfndInf"))]
    pub sellr_dfnd_inf: Vec<UserDefinedInformation1>,

    #[yaserde(rename = "Incotrms")]
    #[cfg_attr(feature = "serde", serde(rename = "Incotrms"))]
    pub incotrms: Incoterms4,
}

impl Validate for LineItem15 {}


#[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:tsmt.014.001.05")]
pub struct LineItemAndPOIdentification1 {
    #[yaserde(rename = "LineItmId")]
    #[cfg_attr(feature = "serde", serde(rename = "LineItmId"))]
    pub line_itm_id: Vec<Max70Text>,

    #[yaserde(rename = "PurchsOrdrRef")]
    #[cfg_attr(feature = "serde", serde(rename = "PurchsOrdrRef"))]
    pub purchs_ordr_ref: DocumentIdentification7,
}

impl Validate for LineItemAndPOIdentification1 {}


#[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:tsmt.014.001.05")]
pub struct LineItemDetails14 {
    #[yaserde(rename = "LineItmId")]
    #[cfg_attr(feature = "serde", serde(rename = "LineItmId"))]
    pub line_itm_id: Max70Text,

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

    #[yaserde(rename = "UnitPric")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitPric"))]
    pub unit_pric: UnitPrice18,

    #[yaserde(rename = "PdctNm")]
    #[cfg_attr(feature = "serde", serde(rename = "PdctNm"))]
    pub pdct_nm: Max70Text,

    #[yaserde(rename = "PdctIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "PdctIdr"))]
    pub pdct_idr: Vec<ProductIdentifier2Choice>,

    #[yaserde(rename = "PdctChrtcs")]
    #[cfg_attr(feature = "serde", serde(rename = "PdctChrtcs"))]
    pub pdct_chrtcs: Vec<ProductCharacteristics1Choice>,

    #[yaserde(rename = "PdctCtgy")]
    #[cfg_attr(feature = "serde", serde(rename = "PdctCtgy"))]
    pub pdct_ctgy: Vec<ProductCategory1Choice>,

    #[yaserde(rename = "PdctOrgn")]
    #[cfg_attr(feature = "serde", serde(rename = "PdctOrgn"))]
    pub pdct_orgn: CountryCode,

    #[yaserde(rename = "Adjstmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "Adjstmnt"))]
    pub adjstmnt: Vec<Adjustment6>,

    #[yaserde(rename = "FrghtChrgs")]
    #[cfg_attr(feature = "serde", serde(rename = "FrghtChrgs"))]
    pub frght_chrgs: Charge25,

    #[yaserde(rename = "Tax")]
    #[cfg_attr(feature = "serde", serde(rename = "Tax"))]
    pub tax: Vec<Tax22>,

    #[yaserde(rename = "TtlAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlAmt"))]
    pub ttl_amt: CurrencyAndAmount,
}

impl Validate for LineItemDetails14 {}


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

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

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

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

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

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

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

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

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

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

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

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct 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:tsmt.014.001.05")]
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:tsmt.014.001.05")]
pub struct MultimodalTransport3 {
    #[yaserde(rename = "TakngInChrg")]
    #[cfg_attr(feature = "serde", serde(rename = "TakngInChrg"))]
    pub takng_in_chrg: Max35Text,

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

impl Validate for MultimodalTransport3 {}


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

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

impl Validate for NameAndAddress6 {}


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

impl Validate for Number {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:tsmt.014.001.05")]
pub struct OtherCertificateDataSet2 {
    #[yaserde(rename = "DataSetId")]
    #[cfg_attr(feature = "serde", serde(rename = "DataSetId"))]
    pub data_set_id: DocumentIdentification1,

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

    #[yaserde(rename = "CertTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CertTp"))]
    pub cert_tp: Exact4AlphaNumericText,

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

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

    #[yaserde(rename = "CertInf")]
    #[cfg_attr(feature = "serde", serde(rename = "CertInf"))]
    pub cert_inf: Vec<Max350Text>,
}

impl Validate for OtherCertificateDataSet2 {}


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

    #[yaserde(rename = "PrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
    pub prtry_id: GenericIdentification4,

    #[yaserde(rename = "PstlAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "PstlAdr"))]
    pub pstl_adr: PostalAddress5,
}

impl Validate for PartyIdentification26 {}
#[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:tsmt.014.001.05")]
pub struct PartyIdentification29Choice {
    #[yaserde(rename = "BIC")]
    #[cfg_attr(feature = "serde", serde(rename = "BIC"))]
    pub bic: Option<Bicidentifier>,
    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: Option<PartyIdentification26>,
}

impl Validate for PartyIdentification29Choice {}
#[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:tsmt.014.001.05")]
pub struct PaymentCodeOrOther1Choice {
    #[yaserde(rename = "PmtCd")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtCd"))]
    pub pmt_cd: Option<PaymentPeriod3>,
    #[yaserde(rename = "PmtDueDt")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtDueDt"))]
    pub pmt_due_dt: Option<Isodate>,
    #[yaserde(rename = "OthrPmtTerms")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrPmtTerms"))]
    pub othr_pmt_terms: Option<Max140Text>,
}

impl Validate for PaymentCodeOrOther1Choice {}




#[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:tsmt.014.001.05")]
pub struct PaymentPeriod3 {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: PaymentTime3Code,

    #[yaserde(rename = "NbOfDays")]
    #[cfg_attr(feature = "serde", serde(rename = "NbOfDays"))]
    pub nb_of_days: Number,
}

impl Validate for PaymentPeriod3 {}


#[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:tsmt.014.001.05")]
pub struct PaymentTerms4 {
    #[yaserde(rename = "PmtTerms")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtTerms"))]
    pub pmt_terms: PaymentCodeOrOther1Choice,

    #[yaserde(rename = "AmtOrPctg")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtOrPctg"))]
    pub amt_or_pctg: AmountOrPercentage2Choice,
}

impl Validate for PaymentTerms4 {}


#[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:tsmt.014.001.05")]

pub enum PaymentTime3Code {
    #[yaserde(rename = "EMTD")]
    #[cfg_attr(feature = "serde", serde(rename = "EMTD"))]
    Emtd,
    #[yaserde(rename = "EMTR")]
    #[cfg_attr(feature = "serde", serde(rename = "EMTR"))]
    Emtr,
    #[yaserde(rename = "EPBE")]
    #[cfg_attr(feature = "serde", serde(rename = "EPBE"))]
    Epbe,
    #[yaserde(rename = "EPRD")]
    #[cfg_attr(feature = "serde", serde(rename = "EPRD"))]
    Eprd,
    #[yaserde(rename = "PRMD")]
    #[cfg_attr(feature = "serde", serde(rename = "PRMD"))]
    Prmd,
    #[yaserde(rename = "PRMR")]
    #[cfg_attr(feature = "serde", serde(rename = "PRMR"))]
    Prmr,
    #[yaserde(rename = "EPIN")]
    #[cfg_attr(feature = "serde", serde(rename = "EPIN"))]
    Epin,
    #[yaserde(rename = "EPAM")]
    #[cfg_attr(feature = "serde", serde(rename = "EPAM"))]
    Epam,
    #[yaserde(rename = "EPPO")]
    #[cfg_attr(feature = "serde", serde(rename = "EPPO"))]
    Eppo,
    #[yaserde(rename = "EPRR")]
    #[cfg_attr(feature = "serde", serde(rename = "EPRR"))]
    Eprr,
    #[yaserde(rename = "EPSD")]
    #[cfg_attr(feature = "serde", serde(rename = "EPSD"))]
    Epsd,
    #[yaserde(rename = "CASH")]
    #[cfg_attr(feature = "serde", serde(rename = "CASH"))]
    Cash,
    #[yaserde(rename = "IREC")]
    #[cfg_attr(feature = "serde", serde(rename = "IREC"))]
    Irec,
    __Unknown__(String),
}

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

impl Validate for PaymentTime3Code {}



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

impl Validate for PercentageRate {}
#[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:tsmt.014.001.05")]
pub struct PostalAddress2 {
    #[yaserde(rename = "StrtNm")]
    #[cfg_attr(feature = "serde", serde(rename = "StrtNm"))]
    pub strt_nm: Max70Text,

    #[yaserde(rename = "PstCdId")]
    #[cfg_attr(feature = "serde", serde(rename = "PstCdId"))]
    pub pst_cd_id: 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 PostalAddress2 {}


#[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:tsmt.014.001.05")]
pub struct PostalAddress5 {
    #[yaserde(rename = "StrtNm")]
    #[cfg_attr(feature = "serde", serde(rename = "StrtNm"))]
    pub strt_nm: Max70Text,

    #[yaserde(rename = "PstCdId")]
    #[cfg_attr(feature = "serde", serde(rename = "PstCdId"))]
    pub pst_cd_id: 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 PostalAddress5 {}


#[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:tsmt.014.001.05")]
pub struct ProductCategory1 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: ProductCategory1Code,

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

impl Validate for ProductCategory1 {}
#[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:tsmt.014.001.05")]
pub struct ProductCategory1Choice {
    #[yaserde(rename = "StrdPdctCtgy")]
    #[cfg_attr(feature = "serde", serde(rename = "StrdPdctCtgy"))]
    pub strd_pdct_ctgy: Option<ProductCategory1>,
    #[yaserde(rename = "OthrPdctCtgy")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrPdctCtgy"))]
    pub othr_pdct_ctgy: Option<GenericIdentification4>,
}

impl Validate for ProductCategory1Choice {}




#[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:tsmt.014.001.05")]

pub enum ProductCategory1Code {
    #[yaserde(rename = "HRTR")]
    #[cfg_attr(feature = "serde", serde(rename = "HRTR"))]
    Hrtr,
    #[yaserde(rename = "QOTA")]
    #[cfg_attr(feature = "serde", serde(rename = "QOTA"))]
    Qota,
    #[yaserde(rename = "PRGP")]
    #[cfg_attr(feature = "serde", serde(rename = "PRGP"))]
    Prgp,
    #[yaserde(rename = "LOBU")]
    #[cfg_attr(feature = "serde", serde(rename = "LOBU"))]
    Lobu,
    #[yaserde(rename = "GNDR")]
    #[cfg_attr(feature = "serde", serde(rename = "GNDR"))]
    Gndr,
    __Unknown__(String),
}

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

impl Validate for ProductCategory1Code {}



#[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:tsmt.014.001.05")]
pub struct ProductCharacteristics1 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: ProductCharacteristics1Code,

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

impl Validate for ProductCharacteristics1 {}
#[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:tsmt.014.001.05")]
pub struct ProductCharacteristics1Choice {
    #[yaserde(rename = "StrdPdctChrtcs")]
    #[cfg_attr(feature = "serde", serde(rename = "StrdPdctChrtcs"))]
    pub strd_pdct_chrtcs: Option<ProductCharacteristics1>,
    #[yaserde(rename = "OthrPdctChrtcs")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrPdctChrtcs"))]
    pub othr_pdct_chrtcs: Option<GenericIdentification4>,
}

impl Validate for ProductCharacteristics1Choice {}




#[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:tsmt.014.001.05")]

pub enum ProductCharacteristics1Code {
    #[yaserde(rename = "BISP")]
    #[cfg_attr(feature = "serde", serde(rename = "BISP"))]
    Bisp,
    #[yaserde(rename = "CHNR")]
    #[cfg_attr(feature = "serde", serde(rename = "CHNR"))]
    Chnr,
    #[yaserde(rename = "CLOR")]
    #[cfg_attr(feature = "serde", serde(rename = "CLOR"))]
    Clor,
    #[yaserde(rename = "EDSP")]
    #[cfg_attr(feature = "serde", serde(rename = "EDSP"))]
    Edsp,
    #[yaserde(rename = "ENNR")]
    #[cfg_attr(feature = "serde", serde(rename = "ENNR"))]
    Ennr,
    #[yaserde(rename = "OPTN")]
    #[cfg_attr(feature = "serde", serde(rename = "OPTN"))]
    Optn,
    #[yaserde(rename = "ORCR")]
    #[cfg_attr(feature = "serde", serde(rename = "ORCR"))]
    Orcr,
    #[yaserde(rename = "PCTV")]
    #[cfg_attr(feature = "serde", serde(rename = "PCTV"))]
    Pctv,
    #[yaserde(rename = "SISP")]
    #[cfg_attr(feature = "serde", serde(rename = "SISP"))]
    Sisp,
    #[yaserde(rename = "SIZE")]
    #[cfg_attr(feature = "serde", serde(rename = "SIZE"))]
    Size,
    #[yaserde(rename = "SZRG")]
    #[cfg_attr(feature = "serde", serde(rename = "SZRG"))]
    Szrg,
    #[yaserde(rename = "SPRM")]
    #[cfg_attr(feature = "serde", serde(rename = "SPRM"))]
    Sprm,
    #[yaserde(rename = "STOR")]
    #[cfg_attr(feature = "serde", serde(rename = "STOR"))]
    Stor,
    #[yaserde(rename = "VINR")]
    #[cfg_attr(feature = "serde", serde(rename = "VINR"))]
    Vinr,
    __Unknown__(String),
}

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

impl Validate for ProductCharacteristics1Code {}



#[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:tsmt.014.001.05")]
pub struct ProductIdentifier2 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: ProductIdentifier2Code,

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

impl Validate for ProductIdentifier2 {}
#[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:tsmt.014.001.05")]
pub struct ProductIdentifier2Choice {
    #[yaserde(rename = "StrdPdctIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "StrdPdctIdr"))]
    pub strd_pdct_idr: Option<ProductIdentifier2>,
    #[yaserde(rename = "OthrPdctIdr")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrPdctIdr"))]
    pub othr_pdct_idr: Option<GenericIdentification4>,
}

impl Validate for ProductIdentifier2Choice {}




#[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:tsmt.014.001.05")]

pub enum ProductIdentifier2Code {
    #[yaserde(rename = "BINR")]
    #[cfg_attr(feature = "serde", serde(rename = "BINR"))]
    Binr,
    #[yaserde(rename = "COMD")]
    #[cfg_attr(feature = "serde", serde(rename = "COMD"))]
    Comd,
    #[yaserde(rename = "EANC")]
    #[cfg_attr(feature = "serde", serde(rename = "EANC"))]
    Eanc,
    #[yaserde(rename = "HRTR")]
    #[cfg_attr(feature = "serde", serde(rename = "HRTR"))]
    Hrtr,
    #[yaserde(rename = "MANI")]
    #[cfg_attr(feature = "serde", serde(rename = "MANI"))]
    Mani,
    #[yaserde(rename = "MODL")]
    #[cfg_attr(feature = "serde", serde(rename = "MODL"))]
    Modl,
    #[yaserde(rename = "PART")]
    #[cfg_attr(feature = "serde", serde(rename = "PART"))]
    Part,
    #[yaserde(rename = "QOTA")]
    #[cfg_attr(feature = "serde", serde(rename = "QOTA"))]
    Qota,
    #[yaserde(rename = "STYL")]
    #[cfg_attr(feature = "serde", serde(rename = "STYL"))]
    Styl,
    #[yaserde(rename = "SUPI")]
    #[cfg_attr(feature = "serde", serde(rename = "SUPI"))]
    Supi,
    #[yaserde(rename = "UPCC")]
    #[cfg_attr(feature = "serde", serde(rename = "UPCC"))]
    Upcc,
    __Unknown__(String),
}

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

impl Validate for ProductIdentifier2Code {}



#[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:tsmt.014.001.05")]
pub struct Quantity10 {
    #[yaserde(rename = "UnitOfMeasr")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitOfMeasr"))]
    pub unit_of_measr: UnitOfMeasure3Choice,

    #[yaserde(rename = "Val")]
    #[cfg_attr(feature = "serde", serde(rename = "Val"))]
    pub val: DecimalNumber,
}

impl Validate for Quantity10 {}


#[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:tsmt.014.001.05")]
pub struct Quantity9 {
    #[yaserde(rename = "UnitOfMeasr")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitOfMeasr"))]
    pub unit_of_measr: UnitOfMeasure3Choice,

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

    #[yaserde(rename = "Fctr")]
    #[cfg_attr(feature = "serde", serde(rename = "Fctr"))]
    pub fctr: Max15NumericText,
}

impl Validate for Quantity9 {}


#[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:tsmt.014.001.05")]
pub struct SettlementTerms3 {
    #[yaserde(rename = "CdtrAgt")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtrAgt"))]
    pub cdtr_agt: FinancialInstitutionIdentification4Choice,

    #[yaserde(rename = "CdtrAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtrAcct"))]
    pub cdtr_acct: CashAccount24,
}

impl Validate for SettlementTerms3 {}
#[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:tsmt.014.001.05")]
pub struct ShipmentDate1Choice {
    #[yaserde(rename = "PropsdShipmntDt")]
    #[cfg_attr(feature = "serde", serde(rename = "PropsdShipmntDt"))]
    pub propsd_shipmnt_dt: Option<Isodate>,
    #[yaserde(rename = "ActlShipmntDt")]
    #[cfg_attr(feature = "serde", serde(rename = "ActlShipmntDt"))]
    pub actl_shipmnt_dt: Option<Isodate>,
}

impl Validate for ShipmentDate1Choice {}




#[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:tsmt.014.001.05")]
pub struct SimpleIdentificationInformation {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,
}

impl Validate for SimpleIdentificationInformation {}


#[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:tsmt.014.001.05")]
pub struct SingleTransport3 {
    #[yaserde(rename = "TrnsprtByAir")]
    #[cfg_attr(feature = "serde", serde(rename = "TrnsprtByAir"))]
    pub trnsprt_by_air: TransportByAir2,

    #[yaserde(rename = "TrnsprtBySea")]
    #[cfg_attr(feature = "serde", serde(rename = "TrnsprtBySea"))]
    pub trnsprt_by_sea: TransportBySea4,

    #[yaserde(rename = "TrnsprtByRoad")]
    #[cfg_attr(feature = "serde", serde(rename = "TrnsprtByRoad"))]
    pub trnsprt_by_road: TransportByRoad2,

    #[yaserde(rename = "TrnsprtByRail")]
    #[cfg_attr(feature = "serde", serde(rename = "TrnsprtByRail"))]
    pub trnsprt_by_rail: TransportByRail2,
}

impl Validate for SingleTransport3 {}


#[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:tsmt.014.001.05")]
pub struct SingleTransport8 {
    #[yaserde(rename = "TrnsprtByAir")]
    #[cfg_attr(feature = "serde", serde(rename = "TrnsprtByAir"))]
    pub trnsprt_by_air: Vec<TransportByAir4>,

    #[yaserde(rename = "TrnsprtBySea")]
    #[cfg_attr(feature = "serde", serde(rename = "TrnsprtBySea"))]
    pub trnsprt_by_sea: Vec<TransportBySea5>,

    #[yaserde(rename = "TrnsprtByRoad")]
    #[cfg_attr(feature = "serde", serde(rename = "TrnsprtByRoad"))]
    pub trnsprt_by_road: Vec<TransportByRoad4>,

    #[yaserde(rename = "TrnsprtByRail")]
    #[cfg_attr(feature = "serde", serde(rename = "TrnsprtByRail"))]
    pub trnsprt_by_rail: Vec<TransportByRail4>,
}

impl Validate for SingleTransport8 {}


#[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:tsmt.014.001.05")]
pub struct Tax22 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: TaxType2Choice,

    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: CurrencyAndAmount,
}

impl Validate for Tax22 {}
#[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:tsmt.014.001.05")]
pub struct TaxType2Choice {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: Option<TaxType9Code>,
    #[yaserde(rename = "OthrTaxTp")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrTaxTp"))]
    pub othr_tax_tp: Option<Max35Text>,
}

impl Validate for TaxType2Choice {}




#[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:tsmt.014.001.05")]

pub enum TaxType9Code {
    #[yaserde(rename = "PROV")]
    #[cfg_attr(feature = "serde", serde(rename = "PROV"))]
    Prov,
    #[yaserde(rename = "NATI")]
    #[cfg_attr(feature = "serde", serde(rename = "NATI"))]
    Nati,
    #[yaserde(rename = "STAT")]
    #[cfg_attr(feature = "serde", serde(rename = "STAT"))]
    Stat,
    #[yaserde(rename = "WITH")]
    #[cfg_attr(feature = "serde", serde(rename = "WITH"))]
    With,
    #[yaserde(rename = "STAM")]
    #[cfg_attr(feature = "serde", serde(rename = "STAM"))]
    Stam,
    #[yaserde(rename = "COAX")]
    #[cfg_attr(feature = "serde", serde(rename = "COAX"))]
    Coax,
    #[yaserde(rename = "VATA")]
    #[cfg_attr(feature = "serde", serde(rename = "VATA"))]
    Vata,
    #[yaserde(rename = "CUST")]
    #[cfg_attr(feature = "serde", serde(rename = "CUST"))]
    Cust,
    __Unknown__(String),
}

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

impl Validate for TaxType9Code {}



#[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:tsmt.014.001.05")]

pub enum TradeCertificateType1Code {
    #[yaserde(rename = "ANLY")]
    #[cfg_attr(feature = "serde", serde(rename = "ANLY"))]
    Anly,
    #[yaserde(rename = "QUAL")]
    #[cfg_attr(feature = "serde", serde(rename = "QUAL"))]
    Qual,
    #[yaserde(rename = "QUAN")]
    #[cfg_attr(feature = "serde", serde(rename = "QUAN"))]
    Quan,
    #[yaserde(rename = "WEIG")]
    #[cfg_attr(feature = "serde", serde(rename = "WEIG"))]
    Weig,
    #[yaserde(rename = "ORIG")]
    #[cfg_attr(feature = "serde", serde(rename = "ORIG"))]
    Orig,
    #[yaserde(rename = "HEAL")]
    #[cfg_attr(feature = "serde", serde(rename = "HEAL"))]
    Heal,
    #[yaserde(rename = "PHYT")]
    #[cfg_attr(feature = "serde", serde(rename = "PHYT"))]
    Phyt,
    __Unknown__(String),
}

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

impl Validate for TradeCertificateType1Code {}



#[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:tsmt.014.001.05")]
pub struct TransportByAir2 {
    #[yaserde(rename = "DprtureAirprt")]
    #[cfg_attr(feature = "serde", serde(rename = "DprtureAirprt"))]
    pub dprture_airprt: AirportName1Choice,

    #[yaserde(rename = "DstnAirprt")]
    #[cfg_attr(feature = "serde", serde(rename = "DstnAirprt"))]
    pub dstn_airprt: AirportName1Choice,

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

impl Validate for TransportByAir2 {}


#[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:tsmt.014.001.05")]
pub struct TransportByAir4 {
    #[yaserde(rename = "DprtureAirprt")]
    #[cfg_attr(feature = "serde", serde(rename = "DprtureAirprt"))]
    pub dprture_airprt: AirportName1Choice,

    #[yaserde(rename = "DstnAirprt")]
    #[cfg_attr(feature = "serde", serde(rename = "DstnAirprt"))]
    pub dstn_airprt: AirportName1Choice,

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

    #[yaserde(rename = "AirCrrierNm")]
    #[cfg_attr(feature = "serde", serde(rename = "AirCrrierNm"))]
    pub air_crrier_nm: Max70Text,

    #[yaserde(rename = "AirCrrierCtry")]
    #[cfg_attr(feature = "serde", serde(rename = "AirCrrierCtry"))]
    pub air_crrier_ctry: CountryCode,

    #[yaserde(rename = "CrrierAgtNm")]
    #[cfg_attr(feature = "serde", serde(rename = "CrrierAgtNm"))]
    pub crrier_agt_nm: Max70Text,

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

impl Validate for TransportByAir4 {}


#[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:tsmt.014.001.05")]
pub struct TransportByRail2 {
    #[yaserde(rename = "PlcOfRct")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcOfRct"))]
    pub plc_of_rct: Max35Text,

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

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

impl Validate for TransportByRail2 {}


#[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:tsmt.014.001.05")]
pub struct TransportByRail4 {
    #[yaserde(rename = "PlcOfRct")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcOfRct"))]
    pub plc_of_rct: Max35Text,

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

    #[yaserde(rename = "RailCrrierNm")]
    #[cfg_attr(feature = "serde", serde(rename = "RailCrrierNm"))]
    pub rail_crrier_nm: Max70Text,

    #[yaserde(rename = "RailCrrierCtry")]
    #[cfg_attr(feature = "serde", serde(rename = "RailCrrierCtry"))]
    pub rail_crrier_ctry: CountryCode,

    #[yaserde(rename = "CrrierAgtNm")]
    #[cfg_attr(feature = "serde", serde(rename = "CrrierAgtNm"))]
    pub crrier_agt_nm: Max70Text,

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

impl Validate for TransportByRail4 {}


#[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:tsmt.014.001.05")]
pub struct TransportByRoad2 {
    #[yaserde(rename = "PlcOfRct")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcOfRct"))]
    pub plc_of_rct: Max35Text,

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

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

impl Validate for TransportByRoad2 {}


#[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:tsmt.014.001.05")]
pub struct TransportByRoad4 {
    #[yaserde(rename = "PlcOfRct")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcOfRct"))]
    pub plc_of_rct: Max35Text,

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

    #[yaserde(rename = "RoadCrrierNm")]
    #[cfg_attr(feature = "serde", serde(rename = "RoadCrrierNm"))]
    pub road_crrier_nm: Max70Text,

    #[yaserde(rename = "RoadCrrierCtry")]
    #[cfg_attr(feature = "serde", serde(rename = "RoadCrrierCtry"))]
    pub road_crrier_ctry: CountryCode,

    #[yaserde(rename = "CrrierAgtNm")]
    #[cfg_attr(feature = "serde", serde(rename = "CrrierAgtNm"))]
    pub crrier_agt_nm: Max70Text,

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

impl Validate for TransportByRoad4 {}


#[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:tsmt.014.001.05")]
pub struct TransportBySea4 {
    #[yaserde(rename = "PortOfLoadng")]
    #[cfg_attr(feature = "serde", serde(rename = "PortOfLoadng"))]
    pub port_of_loadng: Max35Text,

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

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

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

impl Validate for TransportBySea4 {}


#[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:tsmt.014.001.05")]
pub struct TransportBySea5 {
    #[yaserde(rename = "PortOfLoadng")]
    #[cfg_attr(feature = "serde", serde(rename = "PortOfLoadng"))]
    pub port_of_loadng: Max35Text,

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

    #[yaserde(rename = "VsslNm")]
    #[cfg_attr(feature = "serde", serde(rename = "VsslNm"))]
    pub vssl_nm: Max70Text,

    #[yaserde(rename = "SeaCrrierNm")]
    #[cfg_attr(feature = "serde", serde(rename = "SeaCrrierNm"))]
    pub sea_crrier_nm: Max70Text,

    #[yaserde(rename = "SeaCrrierCtry")]
    #[cfg_attr(feature = "serde", serde(rename = "SeaCrrierCtry"))]
    pub sea_crrier_ctry: CountryCode,

    #[yaserde(rename = "CrrierAgtNm")]
    #[cfg_attr(feature = "serde", serde(rename = "CrrierAgtNm"))]
    pub crrier_agt_nm: Max70Text,

    #[yaserde(rename = "CrrierAgtCtry")]
    #[cfg_attr(feature = "serde", serde(rename = "CrrierAgtCtry"))]
    pub crrier_agt_ctry: CountryCode,

    #[yaserde(rename = "MstrNm")]
    #[cfg_attr(feature = "serde", serde(rename = "MstrNm"))]
    pub mstr_nm: Max70Text,

    #[yaserde(rename = "ChrtrrNm")]
    #[cfg_attr(feature = "serde", serde(rename = "ChrtrrNm"))]
    pub chrtrr_nm: Max70Text,

    #[yaserde(rename = "OwnrNm")]
    #[cfg_attr(feature = "serde", serde(rename = "OwnrNm"))]
    pub ownr_nm: Max70Text,

    #[yaserde(rename = "IMONb")]
    #[cfg_attr(feature = "serde", serde(rename = "IMONb"))]
    pub imo_nb: Exact7NumericText,

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

impl Validate for TransportBySea5 {}


#[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:tsmt.014.001.05")]
pub struct TransportDataSet5 {
    #[yaserde(rename = "DataSetId")]
    #[cfg_attr(feature = "serde", serde(rename = "DataSetId"))]
    pub data_set_id: DocumentIdentification1,

    #[yaserde(rename = "Buyr")]
    #[cfg_attr(feature = "serde", serde(rename = "Buyr"))]
    pub buyr: PartyIdentification26,

    #[yaserde(rename = "Sellr")]
    #[cfg_attr(feature = "serde", serde(rename = "Sellr"))]
    pub sellr: PartyIdentification26,

    #[yaserde(rename = "Consgnr")]
    #[cfg_attr(feature = "serde", serde(rename = "Consgnr"))]
    pub consgnr: PartyIdentification26,

    #[yaserde(rename = "Consgn")]
    #[cfg_attr(feature = "serde", serde(rename = "Consgn"))]
    pub consgn: PartyIdentification26,

    #[yaserde(rename = "ShipTo")]
    #[cfg_attr(feature = "serde", serde(rename = "ShipTo"))]
    pub ship_to: PartyIdentification26,

    #[yaserde(rename = "TrnsprtInf")]
    #[cfg_attr(feature = "serde", serde(rename = "TrnsprtInf"))]
    pub trnsprt_inf: TransportDetails4,
}

impl Validate for TransportDataSet5 {}


#[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:tsmt.014.001.05")]
pub struct TransportDetails4 {
    #[yaserde(rename = "TrnsprtDocRef")]
    #[cfg_attr(feature = "serde", serde(rename = "TrnsprtDocRef"))]
    pub trnsprt_doc_ref: Vec<DocumentIdentification7>,

    #[yaserde(rename = "TrnsprtdGoods")]
    #[cfg_attr(feature = "serde", serde(rename = "TrnsprtdGoods"))]
    pub trnsprtd_goods: Vec<TransportedGoods1>,

    #[yaserde(rename = "Consgnmt")]
    #[cfg_attr(feature = "serde", serde(rename = "Consgnmt"))]
    pub consgnmt: Consignment3,

    #[yaserde(rename = "RtgSummry")]
    #[cfg_attr(feature = "serde", serde(rename = "RtgSummry"))]
    pub rtg_summry: TransportMeans6,

    #[yaserde(rename = "ShipmntDt")]
    #[cfg_attr(feature = "serde", serde(rename = "ShipmntDt"))]
    pub shipmnt_dt: ShipmentDate1Choice,

    #[yaserde(rename = "FrghtChrgs")]
    #[cfg_attr(feature = "serde", serde(rename = "FrghtChrgs"))]
    pub frght_chrgs: Charge25,

    #[yaserde(rename = "Incotrms")]
    #[cfg_attr(feature = "serde", serde(rename = "Incotrms"))]
    pub incotrms: Incoterms4,
}

impl Validate for TransportDetails4 {}


#[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:tsmt.014.001.05")]
pub struct TransportMeans6 {
    #[yaserde(rename = "IndvTrnsprt")]
    #[cfg_attr(feature = "serde", serde(rename = "IndvTrnsprt"))]
    pub indv_trnsprt: SingleTransport8,

    #[yaserde(rename = "MltmdlTrnsprt")]
    #[cfg_attr(feature = "serde", serde(rename = "MltmdlTrnsprt"))]
    pub mltmdl_trnsprt: MultimodalTransport3,
}

impl Validate for TransportMeans6 {}


#[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:tsmt.014.001.05")]
pub struct TransportedGoods1 {
    #[yaserde(rename = "PurchsOrdrRef")]
    #[cfg_attr(feature = "serde", serde(rename = "PurchsOrdrRef"))]
    pub purchs_ordr_ref: DocumentIdentification7,

    #[yaserde(rename = "GoodsDesc")]
    #[cfg_attr(feature = "serde", serde(rename = "GoodsDesc"))]
    pub goods_desc: Max70Text,

    #[yaserde(rename = "BuyrDfndInf")]
    #[cfg_attr(feature = "serde", serde(rename = "BuyrDfndInf"))]
    pub buyr_dfnd_inf: Vec<UserDefinedInformation1>,

    #[yaserde(rename = "SellrDfndInf")]
    #[cfg_attr(feature = "serde", serde(rename = "SellrDfndInf"))]
    pub sellr_dfnd_inf: Vec<UserDefinedInformation1>,
}

impl Validate for TransportedGoods1 {}
#[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:tsmt.014.001.05")]
pub struct UnitOfMeasure3Choice {
    #[yaserde(rename = "UnitOfMeasrCd")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitOfMeasrCd"))]
    pub unit_of_measr_cd: Option<UnitOfMeasure4Code>,
    #[yaserde(rename = "OthrUnitOfMeasr")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrUnitOfMeasr"))]
    pub othr_unit_of_measr: Option<Max35Text>,
}

impl Validate for UnitOfMeasure3Choice {}




#[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:tsmt.014.001.05")]

pub enum UnitOfMeasure4Code {
    #[yaserde(rename = "KGM")]
    #[cfg_attr(feature = "serde", serde(rename = "KGM"))]
    Kgm,
    #[yaserde(rename = "EA")]
    #[cfg_attr(feature = "serde", serde(rename = "EA"))]
    Ea,
    #[yaserde(rename = "LTN")]
    #[cfg_attr(feature = "serde", serde(rename = "LTN"))]
    Ltn,
    #[yaserde(rename = "MTR")]
    #[cfg_attr(feature = "serde", serde(rename = "MTR"))]
    Mtr,
    #[yaserde(rename = "INH")]
    #[cfg_attr(feature = "serde", serde(rename = "INH"))]
    Inh,
    #[yaserde(rename = "LY")]
    #[cfg_attr(feature = "serde", serde(rename = "LY"))]
    Ly,
    #[yaserde(rename = "GLI")]
    #[cfg_attr(feature = "serde", serde(rename = "GLI"))]
    Gli,
    #[yaserde(rename = "GRM")]
    #[cfg_attr(feature = "serde", serde(rename = "GRM"))]
    Grm,
    #[yaserde(rename = "CMT")]
    #[cfg_attr(feature = "serde", serde(rename = "CMT"))]
    Cmt,
    #[yaserde(rename = "MTK")]
    #[cfg_attr(feature = "serde", serde(rename = "MTK"))]
    Mtk,
    #[yaserde(rename = "FOT")]
    #[cfg_attr(feature = "serde", serde(rename = "FOT"))]
    Fot,
    #[yaserde(rename = "1A")]
    #[cfg_attr(feature = "serde", serde(rename = "1A"))]
    _1A,
    #[yaserde(rename = "INK")]
    #[cfg_attr(feature = "serde", serde(rename = "INK"))]
    Ink,
    #[yaserde(rename = "FTK")]
    #[cfg_attr(feature = "serde", serde(rename = "FTK"))]
    Ftk,
    #[yaserde(rename = "MIK")]
    #[cfg_attr(feature = "serde", serde(rename = "MIK"))]
    Mik,
    #[yaserde(rename = "ONZ")]
    #[cfg_attr(feature = "serde", serde(rename = "ONZ"))]
    Onz,
    #[yaserde(rename = "PTI")]
    #[cfg_attr(feature = "serde", serde(rename = "PTI"))]
    Pti,
    #[yaserde(rename = "PT")]
    #[cfg_attr(feature = "serde", serde(rename = "PT"))]
    Pt,
    #[yaserde(rename = "QTI")]
    #[cfg_attr(feature = "serde", serde(rename = "QTI"))]
    Qti,
    #[yaserde(rename = "QT")]
    #[cfg_attr(feature = "serde", serde(rename = "QT"))]
    Qt,
    #[yaserde(rename = "GLL")]
    #[cfg_attr(feature = "serde", serde(rename = "GLL"))]
    Gll,
    #[yaserde(rename = "MMT")]
    #[cfg_attr(feature = "serde", serde(rename = "MMT"))]
    Mmt,
    #[yaserde(rename = "KTM")]
    #[cfg_attr(feature = "serde", serde(rename = "KTM"))]
    Ktm,
    #[yaserde(rename = "YDK")]
    #[cfg_attr(feature = "serde", serde(rename = "YDK"))]
    Ydk,
    #[yaserde(rename = "MMK")]
    #[cfg_attr(feature = "serde", serde(rename = "MMK"))]
    Mmk,
    #[yaserde(rename = "CMK")]
    #[cfg_attr(feature = "serde", serde(rename = "CMK"))]
    Cmk,
    #[yaserde(rename = "KMK")]
    #[cfg_attr(feature = "serde", serde(rename = "KMK"))]
    Kmk,
    #[yaserde(rename = "MMQ")]
    #[cfg_attr(feature = "serde", serde(rename = "MMQ"))]
    Mmq,
    #[yaserde(rename = "CLT")]
    #[cfg_attr(feature = "serde", serde(rename = "CLT"))]
    Clt,
    #[yaserde(rename = "LTR")]
    #[cfg_attr(feature = "serde", serde(rename = "LTR"))]
    Ltr,
    #[yaserde(rename = "LBR")]
    #[cfg_attr(feature = "serde", serde(rename = "LBR"))]
    Lbr,
    #[yaserde(rename = "STN")]
    #[cfg_attr(feature = "serde", serde(rename = "STN"))]
    Stn,
    #[yaserde(rename = "BLL")]
    #[cfg_attr(feature = "serde", serde(rename = "BLL"))]
    Bll,
    #[yaserde(rename = "BX")]
    #[cfg_attr(feature = "serde", serde(rename = "BX"))]
    Bx,
    #[yaserde(rename = "BO")]
    #[cfg_attr(feature = "serde", serde(rename = "BO"))]
    Bo,
    #[yaserde(rename = "CT")]
    #[cfg_attr(feature = "serde", serde(rename = "CT"))]
    Ct,
    #[yaserde(rename = "CH")]
    #[cfg_attr(feature = "serde", serde(rename = "CH"))]
    Ch,
    #[yaserde(rename = "CR")]
    #[cfg_attr(feature = "serde", serde(rename = "CR"))]
    Cr,
    #[yaserde(rename = "INQ")]
    #[cfg_attr(feature = "serde", serde(rename = "INQ"))]
    Inq,
    #[yaserde(rename = "MTQ")]
    #[cfg_attr(feature = "serde", serde(rename = "MTQ"))]
    Mtq,
    #[yaserde(rename = "OZI")]
    #[cfg_attr(feature = "serde", serde(rename = "OZI"))]
    Ozi,
    #[yaserde(rename = "OZA")]
    #[cfg_attr(feature = "serde", serde(rename = "OZA"))]
    Oza,
    #[yaserde(rename = "BG")]
    #[cfg_attr(feature = "serde", serde(rename = "BG"))]
    Bg,
    #[yaserde(rename = "BL")]
    #[cfg_attr(feature = "serde", serde(rename = "BL"))]
    Bl,
    #[yaserde(rename = "TNE")]
    #[cfg_attr(feature = "serde", serde(rename = "TNE"))]
    Tne,
    __Unknown__(String),
}

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

impl Validate for UnitOfMeasure4Code {}



#[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:tsmt.014.001.05")]
pub struct UnitPrice18 {
    #[yaserde(rename = "UnitPric")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitPric"))]
    pub unit_pric: UnitOfMeasure3Choice,

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

    #[yaserde(rename = "Fctr")]
    #[cfg_attr(feature = "serde", serde(rename = "Fctr"))]
    pub fctr: Max15NumericText,
}

impl Validate for UnitPrice18 {}


#[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:tsmt.014.001.05")]
pub struct UserDefinedInformation1 {
    #[yaserde(rename = "Labl")]
    #[cfg_attr(feature = "serde", serde(rename = "Labl"))]
    pub labl: Max35Text,

    #[yaserde(rename = "Inf")]
    #[cfg_attr(feature = "serde", serde(rename = "Inf"))]
    pub inf: Max140Text,
}

impl Validate for UserDefinedInformation1 {}


#[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::tsmt;
    const FUNCTIONALITY: &'static str = "014";
    const VARIANT: &'static str = "001";
    const VERSION: &'static str = "05";
    const MESSAGE_NAME: &'static str = "tsmt.014.001.05";
    const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:tsmt.014.001.05";
}