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

    #[yaserde(rename = "AcctSvcr")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctSvcr"))]
    pub acct_svcr: PartyIdentification137Choice,
}

impl Validate for Account30 {}


#[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:semt.017.002.12")]
pub struct AccountIdentification4 {
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: SimpleIdentificationInformation1,
}

impl Validate for AccountIdentification4 {}


#[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:semt.017.002.12")]
pub struct AdditionalReference12 {
    #[yaserde(rename = "Ref")]
    #[cfg_attr(feature = "serde", serde(rename = "Ref"))]
    pub _ref: RestrictedFINXMax35Text,

    #[yaserde(rename = "RefIssr")]
    #[cfg_attr(feature = "serde", serde(rename = "RefIssr"))]
    pub ref_issr: PartyIdentification192,

    #[yaserde(rename = "MsgNm")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgNm"))]
    pub msg_nm: RestrictedFINXMax35Text,
}

impl Validate for AdditionalReference12 {}


#[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:semt.017.002.12")]
pub struct AmountAndDirection18 {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: RestrictedFINActiveOrHistoricCurrencyAndAmount,

    #[yaserde(rename = "CdtDbt")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtDbt"))]
    pub cdt_dbt: CreditDebitCode,
}

impl Validate for AmountAndDirection18 {}


#[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:semt.017.002.12")]
pub struct AmountAndDirection59 {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: RestrictedFINActiveOrHistoricCurrencyAndAmount,

    #[yaserde(rename = "CdtDbtInd")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtDbtInd"))]
    pub cdt_dbt_ind: CreditDebitCode,
}

impl Validate for AmountAndDirection59 {}


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

impl Validate for AnyBICDec2014Identifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.017.002.12")]
pub struct BalanceQuantity17Choice {
    #[yaserde(rename = "Qty")]
    #[cfg_attr(feature = "serde", serde(rename = "Qty"))]
    pub qty: Option<FinancialInstrumentQuantity36Choice>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification144>,
}

impl Validate for BalanceQuantity17Choice {}
#[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:semt.017.002.12")]
pub struct BeneficialOwnership5Choice {
    #[yaserde(rename = "Ind")]
    #[cfg_attr(feature = "serde", serde(rename = "Ind"))]
    pub ind: Option<YesNoIndicator>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for BeneficialOwnership5Choice {}




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

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

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

impl Validate for BlockChainAddressWallet7 {}


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

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

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

    #[yaserde(rename = "Dsgnt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dsgnt"))]
    pub dsgnt: RestrictedFINXMax16Text,
}

impl Validate for BlockChainAddressWallet8 {}


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

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

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

impl Validate for BlockChainAddressWallet9 {}


#[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:semt.017.002.12")]

pub enum BlockTrade1Code {
    #[yaserde(rename = "BLPA")]
    #[cfg_attr(feature = "serde", serde(rename = "BLPA"))]
    Blpa,
    #[yaserde(rename = "BLCH")]
    #[cfg_attr(feature = "serde", serde(rename = "BLCH"))]
    Blch,
    __Unknown__(String),
}

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

impl Validate for BlockTrade1Code {}
#[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:semt.017.002.12")]
pub struct BlockTrade5Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<BlockTrade1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for BlockTrade5Choice {}




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

impl Validate for Cfioct2015Identifier {}
#[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:semt.017.002.12")]

pub enum CashSettlementSystem2Code {
    #[yaserde(rename = "GROS")]
    #[cfg_attr(feature = "serde", serde(rename = "GROS"))]
    Gros,
    #[yaserde(rename = "NETS")]
    #[cfg_attr(feature = "serde", serde(rename = "NETS"))]
    Nets,
    __Unknown__(String),
}

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

impl Validate for CashSettlementSystem2Code {}
#[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:semt.017.002.12")]
pub struct CashSettlementSystem5Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<CashSettlementSystem2Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for CashSettlementSystem5Choice {}
#[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:semt.017.002.12")]
pub struct CentralCounterPartyEligibility5Choice {
    #[yaserde(rename = "Ind")]
    #[cfg_attr(feature = "serde", serde(rename = "Ind"))]
    pub ind: Option<YesNoIndicator>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for CentralCounterPartyEligibility5Choice {}




#[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:semt.017.002.12")]
pub struct ClosingBalance6 {
    #[yaserde(rename = "ShrtLngInd")]
    #[cfg_attr(feature = "serde", serde(rename = "ShrtLngInd"))]
    pub shrt_lng_ind: ShortLong1Code,

    #[yaserde(rename = "ClsgBal")]
    #[cfg_attr(feature = "serde", serde(rename = "ClsgBal"))]
    pub clsg_bal: ClosingBalance7Choice,
}

impl Validate for ClosingBalance6 {}
#[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:semt.017.002.12")]
pub struct ClosingBalance7Choice {
    #[yaserde(rename = "Fnl")]
    #[cfg_attr(feature = "serde", serde(rename = "Fnl"))]
    pub fnl: Option<BalanceQuantity17Choice>,
    #[yaserde(rename = "Intrmy")]
    #[cfg_attr(feature = "serde", serde(rename = "Intrmy"))]
    pub intrmy: Option<BalanceQuantity17Choice>,
}

impl Validate for ClosingBalance7Choice {}
#[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:semt.017.002.12")]
pub struct CorporateActionEventType101Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<CorporateActionEventType33Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for CorporateActionEventType101Choice {}




#[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:semt.017.002.12")]

pub enum CorporateActionEventType33Code {
    #[yaserde(rename = "ACTV")]
    #[cfg_attr(feature = "serde", serde(rename = "ACTV"))]
    Actv,
    #[yaserde(rename = "ATTI")]
    #[cfg_attr(feature = "serde", serde(rename = "ATTI"))]
    Atti,
    #[yaserde(rename = "BRUP")]
    #[cfg_attr(feature = "serde", serde(rename = "BRUP"))]
    Brup,
    #[yaserde(rename = "DFLT")]
    #[cfg_attr(feature = "serde", serde(rename = "DFLT"))]
    Dflt,
    #[yaserde(rename = "BONU")]
    #[cfg_attr(feature = "serde", serde(rename = "BONU"))]
    Bonu,
    #[yaserde(rename = "EXRI")]
    #[cfg_attr(feature = "serde", serde(rename = "EXRI"))]
    Exri,
    #[yaserde(rename = "CAPD")]
    #[cfg_attr(feature = "serde", serde(rename = "CAPD"))]
    Capd,
    #[yaserde(rename = "CAPG")]
    #[cfg_attr(feature = "serde", serde(rename = "CAPG"))]
    Capg,
    #[yaserde(rename = "CAPI")]
    #[cfg_attr(feature = "serde", serde(rename = "CAPI"))]
    Capi,
    #[yaserde(rename = "DRCA")]
    #[cfg_attr(feature = "serde", serde(rename = "DRCA"))]
    Drca,
    #[yaserde(rename = "DVCA")]
    #[cfg_attr(feature = "serde", serde(rename = "DVCA"))]
    Dvca,
    #[yaserde(rename = "CHAN")]
    #[cfg_attr(feature = "serde", serde(rename = "CHAN"))]
    Chan,
    #[yaserde(rename = "COOP")]
    #[cfg_attr(feature = "serde", serde(rename = "COOP"))]
    Coop,
    #[yaserde(rename = "CLSA")]
    #[cfg_attr(feature = "serde", serde(rename = "CLSA"))]
    Clsa,
    #[yaserde(rename = "CONS")]
    #[cfg_attr(feature = "serde", serde(rename = "CONS"))]
    Cons,
    #[yaserde(rename = "CONV")]
    #[cfg_attr(feature = "serde", serde(rename = "CONV"))]
    Conv,
    #[yaserde(rename = "CREV")]
    #[cfg_attr(feature = "serde", serde(rename = "CREV"))]
    Crev,
    #[yaserde(rename = "DECR")]
    #[cfg_attr(feature = "serde", serde(rename = "DECR"))]
    Decr,
    #[yaserde(rename = "DETI")]
    #[cfg_attr(feature = "serde", serde(rename = "DETI"))]
    Deti,
    #[yaserde(rename = "DSCL")]
    #[cfg_attr(feature = "serde", serde(rename = "DSCL"))]
    Dscl,
    #[yaserde(rename = "DVOP")]
    #[cfg_attr(feature = "serde", serde(rename = "DVOP"))]
    Dvop,
    #[yaserde(rename = "DRIP")]
    #[cfg_attr(feature = "serde", serde(rename = "DRIP"))]
    Drip,
    #[yaserde(rename = "DRAW")]
    #[cfg_attr(feature = "serde", serde(rename = "DRAW"))]
    Draw,
    #[yaserde(rename = "DTCH")]
    #[cfg_attr(feature = "serde", serde(rename = "DTCH"))]
    Dtch,
    #[yaserde(rename = "EXOF")]
    #[cfg_attr(feature = "serde", serde(rename = "EXOF"))]
    Exof,
    #[yaserde(rename = "REDM")]
    #[cfg_attr(feature = "serde", serde(rename = "REDM"))]
    Redm,
    #[yaserde(rename = "MCAL")]
    #[cfg_attr(feature = "serde", serde(rename = "MCAL"))]
    Mcal,
    #[yaserde(rename = "INCR")]
    #[cfg_attr(feature = "serde", serde(rename = "INCR"))]
    Incr,
    #[yaserde(rename = "PPMT")]
    #[cfg_attr(feature = "serde", serde(rename = "PPMT"))]
    Ppmt,
    #[yaserde(rename = "INTR")]
    #[cfg_attr(feature = "serde", serde(rename = "INTR"))]
    Intr,
    #[yaserde(rename = "RHDI")]
    #[cfg_attr(feature = "serde", serde(rename = "RHDI"))]
    Rhdi,
    #[yaserde(rename = "LIQU")]
    #[cfg_attr(feature = "serde", serde(rename = "LIQU"))]
    Liqu,
    #[yaserde(rename = "EXTM")]
    #[cfg_attr(feature = "serde", serde(rename = "EXTM"))]
    Extm,
    #[yaserde(rename = "MRGR")]
    #[cfg_attr(feature = "serde", serde(rename = "MRGR"))]
    Mrgr,
    #[yaserde(rename = "NOOF")]
    #[cfg_attr(feature = "serde", serde(rename = "NOOF"))]
    Noof,
    #[yaserde(rename = "CERT")]
    #[cfg_attr(feature = "serde", serde(rename = "CERT"))]
    Cert,
    #[yaserde(rename = "ODLT")]
    #[cfg_attr(feature = "serde", serde(rename = "ODLT"))]
    Odlt,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "PARI")]
    #[cfg_attr(feature = "serde", serde(rename = "PARI"))]
    Pari,
    #[yaserde(rename = "PCAL")]
    #[cfg_attr(feature = "serde", serde(rename = "PCAL"))]
    Pcal,
    #[yaserde(rename = "PRED")]
    #[cfg_attr(feature = "serde", serde(rename = "PRED"))]
    Pred,
    #[yaserde(rename = "PINK")]
    #[cfg_attr(feature = "serde", serde(rename = "PINK"))]
    Pink,
    #[yaserde(rename = "PLAC")]
    #[cfg_attr(feature = "serde", serde(rename = "PLAC"))]
    Plac,
    #[yaserde(rename = "PDEF")]
    #[cfg_attr(feature = "serde", serde(rename = "PDEF"))]
    Pdef,
    #[yaserde(rename = "PRIO")]
    #[cfg_attr(feature = "serde", serde(rename = "PRIO"))]
    Prio,
    #[yaserde(rename = "BPUT")]
    #[cfg_attr(feature = "serde", serde(rename = "BPUT"))]
    Bput,
    #[yaserde(rename = "REDO")]
    #[cfg_attr(feature = "serde", serde(rename = "REDO"))]
    Redo,
    #[yaserde(rename = "REMK")]
    #[cfg_attr(feature = "serde", serde(rename = "REMK"))]
    Remk,
    #[yaserde(rename = "BIDS")]
    #[cfg_attr(feature = "serde", serde(rename = "BIDS"))]
    Bids,
    #[yaserde(rename = "SPLR")]
    #[cfg_attr(feature = "serde", serde(rename = "SPLR"))]
    Splr,
    #[yaserde(rename = "RHTS")]
    #[cfg_attr(feature = "serde", serde(rename = "RHTS"))]
    Rhts,
    #[yaserde(rename = "DVSC")]
    #[cfg_attr(feature = "serde", serde(rename = "DVSC"))]
    Dvsc,
    #[yaserde(rename = "SHPR")]
    #[cfg_attr(feature = "serde", serde(rename = "SHPR"))]
    Shpr,
    #[yaserde(rename = "SMAL")]
    #[cfg_attr(feature = "serde", serde(rename = "SMAL"))]
    Smal,
    #[yaserde(rename = "SOFF")]
    #[cfg_attr(feature = "serde", serde(rename = "SOFF"))]
    Soff,
    #[yaserde(rename = "DVSE")]
    #[cfg_attr(feature = "serde", serde(rename = "DVSE"))]
    Dvse,
    #[yaserde(rename = "SPLF")]
    #[cfg_attr(feature = "serde", serde(rename = "SPLF"))]
    Splf,
    #[yaserde(rename = "TREC")]
    #[cfg_attr(feature = "serde", serde(rename = "TREC"))]
    Trec,
    #[yaserde(rename = "TEND")]
    #[cfg_attr(feature = "serde", serde(rename = "TEND"))]
    Tend,
    #[yaserde(rename = "DLST")]
    #[cfg_attr(feature = "serde", serde(rename = "DLST"))]
    Dlst,
    #[yaserde(rename = "SUSP")]
    #[cfg_attr(feature = "serde", serde(rename = "SUSP"))]
    Susp,
    #[yaserde(rename = "EXWA")]
    #[cfg_attr(feature = "serde", serde(rename = "EXWA"))]
    Exwa,
    #[yaserde(rename = "WTRC")]
    #[cfg_attr(feature = "serde", serde(rename = "WTRC"))]
    Wtrc,
    #[yaserde(rename = "WRTH")]
    #[cfg_attr(feature = "serde", serde(rename = "WRTH"))]
    Wrth,
    #[yaserde(rename = "ACCU")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCU"))]
    Accu,
    #[yaserde(rename = "MTNG")]
    #[cfg_attr(feature = "serde", serde(rename = "MTNG"))]
    Mtng,
    #[yaserde(rename = "INFO")]
    #[cfg_attr(feature = "serde", serde(rename = "INFO"))]
    Info,
    #[yaserde(rename = "TNDP")]
    #[cfg_attr(feature = "serde", serde(rename = "TNDP"))]
    Tndp,
    __Unknown__(String),
}

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

impl Validate for CorporateActionEventType33Code {}



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

pub enum CreditDebitCode {
    #[yaserde(rename = "CRDT")]
    #[cfg_attr(feature = "serde", serde(rename = "CRDT"))]
    Crdt,
    #[yaserde(rename = "DBIT")]
    #[cfg_attr(feature = "serde", serde(rename = "DBIT"))]
    Dbit,
    __Unknown__(String),
}

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

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

impl Validate for DateAndDateTime2Choice {}




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

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

impl Validate for DateTimePeriod1 {}


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

pub enum DateType3Code {
    #[yaserde(rename = "VARI")]
    #[cfg_attr(feature = "serde", serde(rename = "VARI"))]
    Vari,
    __Unknown__(String),
}

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

impl Validate for DateType3Code {}



#[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:semt.017.002.12")]

pub enum DeliveryReceiptType2Code {
    #[yaserde(rename = "FREE")]
    #[cfg_attr(feature = "serde", serde(rename = "FREE"))]
    Free,
    #[yaserde(rename = "APMT")]
    #[cfg_attr(feature = "serde", serde(rename = "APMT"))]
    Apmt,
    __Unknown__(String),
}

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

impl Validate for DeliveryReceiptType2Code {}



#[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:semt.017.002.12")]

pub enum DistributionPolicy1Code {
    #[yaserde(rename = "DIST")]
    #[cfg_attr(feature = "serde", serde(rename = "DIST"))]
    Dist,
    #[yaserde(rename = "ACCU")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCU"))]
    Accu,
    __Unknown__(String),
}

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

impl Validate for DistributionPolicy1Code {}



#[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:semt.017.002.12")]
pub struct Document {
    #[yaserde(rename = "SctiesTxPstngRpt")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesTxPstngRpt"))]
    pub scties_tx_pstng_rpt: SecuritiesTransactionPostingReport002V12,
}

impl Validate for Document {}


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

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

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

impl Validate for EventFrequency4Code {}



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

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

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

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

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

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.017.002.12")]
pub struct FinancialInstrument76 {
    #[yaserde(rename = "SplmtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "SplmtryId"))]
    pub splmtry_id: RestrictedFINXMax35Text,

    #[yaserde(rename = "SctiesForm")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesForm"))]
    pub scties_form: FormOfSecurity1Code,

    #[yaserde(rename = "ClssTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ClssTp"))]
    pub clss_tp: RestrictedFINXMax35Text,

    #[yaserde(rename = "DstrbtnPlcy")]
    #[cfg_attr(feature = "serde", serde(rename = "DstrbtnPlcy"))]
    pub dstrbtn_plcy: DistributionPolicy1Code,

    #[yaserde(rename = "ClssfctnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ClssfctnTp"))]
    pub clssfctn_tp: SecurityClassificationType3Choice,
}

impl Validate for FinancialInstrument76 {}


#[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:semt.017.002.12")]
pub struct FinancialInstrumentDetails43 {
    #[yaserde(rename = "FinInstrmId")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrmId"))]
    pub fin_instrm_id: SecurityIdentification20,

    #[yaserde(rename = "InvstmtFndsFinInstrmAttrbts")]
    #[cfg_attr(feature = "serde", serde(rename = "InvstmtFndsFinInstrmAttrbts"))]
    pub invstmt_fnds_fin_instrm_attrbts: FinancialInstrument76,

    #[yaserde(rename = "PricDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "PricDtls"))]
    pub pric_dtls: PriceInformation24,

    #[yaserde(rename = "SfkpgPlc")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgPlc"))]
    pub sfkpg_plc: SafeKeepingPlace4,

    #[yaserde(rename = "OpngBal")]
    #[cfg_attr(feature = "serde", serde(rename = "OpngBal"))]
    pub opng_bal: OpeningBalance6,

    #[yaserde(rename = "ClsgBal")]
    #[cfg_attr(feature = "serde", serde(rename = "ClsgBal"))]
    pub clsg_bal: ClosingBalance6,

    #[yaserde(rename = "Tx")]
    #[cfg_attr(feature = "serde", serde(rename = "Tx"))]
    pub tx: Vec<Transaction126>,
}

impl Validate for FinancialInstrumentDetails43 {}
#[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:semt.017.002.12")]
pub struct FinancialInstrumentQuantity36Choice {
    #[yaserde(rename = "Unit")]
    #[cfg_attr(feature = "serde", serde(rename = "Unit"))]
    pub unit: Option<RestrictedFINDecimalNumber>,
    #[yaserde(rename = "FaceAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "FaceAmt"))]
    pub face_amt: Option<RestrictedFINImpliedCurrencyAndAmount>,
    #[yaserde(rename = "AmtsdVal")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtsdVal"))]
    pub amtsd_val: Option<RestrictedFINImpliedCurrencyAndAmount>,
    #[yaserde(rename = "DgtlTknUnit")]
    #[cfg_attr(feature = "serde", serde(rename = "DgtlTknUnit"))]
    pub dgtl_tkn_unit: Option<Max30DecimalNumber>,
}

impl Validate for FinancialInstrumentQuantity36Choice {}




#[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:semt.017.002.12")]

pub enum FormOfSecurity1Code {
    #[yaserde(rename = "BEAR")]
    #[cfg_attr(feature = "serde", serde(rename = "BEAR"))]
    Bear,
    #[yaserde(rename = "REGD")]
    #[cfg_attr(feature = "serde", serde(rename = "REGD"))]
    Regd,
    __Unknown__(String),
}

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

impl Validate for FormOfSecurity1Code {}
#[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:semt.017.002.12")]
pub struct Frequency26Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<EventFrequency4Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for Frequency26Choice {}




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

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

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

    #[yaserde(rename = "Bal")]
    #[cfg_attr(feature = "serde", serde(rename = "Bal"))]
    pub bal: RestrictedFINDecimalNumber,
}

impl Validate for GenericIdentification144 {}


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

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

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

impl Validate for GenericIdentification18 {}


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

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

impl Validate for GenericIdentification39 {}


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

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

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

impl Validate for GenericIdentification47 {}


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

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

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

impl Validate for GenericIdentification84 {}


#[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:semt.017.002.12")]
pub struct GenericIdentification85 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: GenericIdentification47,

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

impl Validate for GenericIdentification85 {}


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

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

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

impl Validate for IsodateTime {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.017.002.12")]
pub struct IdentificationSource4Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ExternalFinancialInstrumentIdentificationType1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<RestrictedFINExact2Text>,
}

impl Validate for IdentificationSource4Choice {}




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

    #[yaserde(rename = "Role")]
    #[cfg_attr(feature = "serde", serde(rename = "Role"))]
    pub role: Role7Choice,

    #[yaserde(rename = "Acct")]
    #[cfg_attr(feature = "serde", serde(rename = "Acct"))]
    pub acct: Account30,
}

impl Validate for Intermediary45 {}


#[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:semt.017.002.12")]

pub enum InvestmentFundRole2Code {
    #[yaserde(rename = "FMCO")]
    #[cfg_attr(feature = "serde", serde(rename = "FMCO"))]
    Fmco,
    #[yaserde(rename = "REGI")]
    #[cfg_attr(feature = "serde", serde(rename = "REGI"))]
    Regi,
    #[yaserde(rename = "TRAG")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAG"))]
    Trag,
    #[yaserde(rename = "INTR")]
    #[cfg_attr(feature = "serde", serde(rename = "INTR"))]
    Intr,
    #[yaserde(rename = "DIST")]
    #[cfg_attr(feature = "serde", serde(rename = "DIST"))]
    Dist,
    #[yaserde(rename = "CONC")]
    #[cfg_attr(feature = "serde", serde(rename = "CONC"))]
    Conc,
    #[yaserde(rename = "UCL1")]
    #[cfg_attr(feature = "serde", serde(rename = "UCL1"))]
    Ucl1,
    #[yaserde(rename = "UCL2")]
    #[cfg_attr(feature = "serde", serde(rename = "UCL2"))]
    Ucl2,
    #[yaserde(rename = "TRAN")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAN"))]
    Tran,
    __Unknown__(String),
}

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

impl Validate for InvestmentFundRole2Code {}



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

impl Validate for Leiidentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.017.002.12")]
pub struct LetterOfGuarantee5Choice {
    #[yaserde(rename = "Ind")]
    #[cfg_attr(feature = "serde", serde(rename = "Ind"))]
    pub ind: Option<YesNoIndicator>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for LetterOfGuarantee5Choice {}




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

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

pub enum MarketClientSide1Code {
    #[yaserde(rename = "CLNT")]
    #[cfg_attr(feature = "serde", serde(rename = "CLNT"))]
    Clnt,
    #[yaserde(rename = "MAKT")]
    #[cfg_attr(feature = "serde", serde(rename = "MAKT"))]
    Makt,
    __Unknown__(String),
}

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

impl Validate for MarketClientSide1Code {}
#[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:semt.017.002.12")]
pub struct MarketClientSide7Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<MarketClientSide1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for MarketClientSide7Choice {}
#[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:semt.017.002.12")]
pub struct MarketIdentification2Choice {
    #[yaserde(rename = "MktIdrCd")]
    #[cfg_attr(feature = "serde", serde(rename = "MktIdrCd"))]
    pub mkt_idr_cd: Option<Micidentifier>,
    #[yaserde(rename = "Desc")]
    #[cfg_attr(feature = "serde", serde(rename = "Desc"))]
    pub desc: Option<RestrictedFINXMax30Text>,
}

impl Validate for MarketIdentification2Choice {}




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

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

impl Validate for MarketIdentification90 {}


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

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

impl Validate for MarketIdentification91 {}
#[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:semt.017.002.12")]
pub struct MarketType16Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<MarketType2Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for MarketType16Choice {}
#[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:semt.017.002.12")]
pub struct MarketType17Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<MarketType4Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for MarketType17Choice {}




#[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:semt.017.002.12")]

pub enum MarketType2Code {
    #[yaserde(rename = "PRIM")]
    #[cfg_attr(feature = "serde", serde(rename = "PRIM"))]
    Prim,
    #[yaserde(rename = "SECM")]
    #[cfg_attr(feature = "serde", serde(rename = "SECM"))]
    Secm,
    #[yaserde(rename = "OTCO")]
    #[cfg_attr(feature = "serde", serde(rename = "OTCO"))]
    Otco,
    #[yaserde(rename = "VARI")]
    #[cfg_attr(feature = "serde", serde(rename = "VARI"))]
    Vari,
    #[yaserde(rename = "EXCH")]
    #[cfg_attr(feature = "serde", serde(rename = "EXCH"))]
    Exch,
    __Unknown__(String),
}

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

impl Validate for MarketType2Code {}



#[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:semt.017.002.12")]

pub enum MarketType4Code {
    #[yaserde(rename = "FUND")]
    #[cfg_attr(feature = "serde", serde(rename = "FUND"))]
    Fund,
    #[yaserde(rename = "LMAR")]
    #[cfg_attr(feature = "serde", serde(rename = "LMAR"))]
    Lmar,
    #[yaserde(rename = "THEO")]
    #[cfg_attr(feature = "serde", serde(rename = "THEO"))]
    Theo,
    #[yaserde(rename = "VEND")]
    #[cfg_attr(feature = "serde", serde(rename = "VEND"))]
    Vend,
    __Unknown__(String),
}

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

impl Validate for MarketType4Code {}



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

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

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

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

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

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

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

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.017.002.12")]
pub struct NameAndAddress11 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: RestrictedFINMax35Text,

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

impl Validate for NameAndAddress11 {}


#[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:semt.017.002.12")]
pub struct NameAndAddress12 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: RestrictedFINXMax140Text,
}

impl Validate for NameAndAddress12 {}
#[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:semt.017.002.12")]
pub struct NettingEligibility5Choice {
    #[yaserde(rename = "Ind")]
    #[cfg_attr(feature = "serde", serde(rename = "Ind"))]
    pub ind: Option<YesNoIndicator>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for NettingEligibility5Choice {}
#[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:semt.017.002.12")]
pub struct Number3Choice {
    #[yaserde(rename = "Shrt")]
    #[cfg_attr(feature = "serde", serde(rename = "Shrt"))]
    pub shrt: Option<Exact3NumericText>,
    #[yaserde(rename = "Lng")]
    #[cfg_attr(feature = "serde", serde(rename = "Lng"))]
    pub lng: Option<Exact5NumericText>,
}

impl Validate for Number3Choice {}




#[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:semt.017.002.12")]
pub struct OpeningBalance6 {
    #[yaserde(rename = "ShrtLngInd")]
    #[cfg_attr(feature = "serde", serde(rename = "ShrtLngInd"))]
    pub shrt_lng_ind: ShortLong1Code,

    #[yaserde(rename = "OpngBal")]
    #[cfg_attr(feature = "serde", serde(rename = "OpngBal"))]
    pub opng_bal: OpeningBalance7Choice,
}

impl Validate for OpeningBalance6 {}
#[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:semt.017.002.12")]
pub struct OpeningBalance7Choice {
    #[yaserde(rename = "Frst")]
    #[cfg_attr(feature = "serde", serde(rename = "Frst"))]
    pub frst: Option<BalanceQuantity17Choice>,
    #[yaserde(rename = "Intrmy")]
    #[cfg_attr(feature = "serde", serde(rename = "Intrmy"))]
    pub intrmy: Option<BalanceQuantity17Choice>,
}

impl Validate for OpeningBalance7Choice {}




#[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:semt.017.002.12")]
pub struct OriginalAndCurrentQuantities4 {
    #[yaserde(rename = "FaceAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "FaceAmt"))]
    pub face_amt: RestrictedFINImpliedCurrencyAndAmount,

    #[yaserde(rename = "AmtsdVal")]
    #[cfg_attr(feature = "serde", serde(rename = "AmtsdVal"))]
    pub amtsd_val: RestrictedFINImpliedCurrencyAndAmount,
}

impl Validate for OriginalAndCurrentQuantities4 {}


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

    #[yaserde(rename = "Sfx")]
    #[cfg_attr(feature = "serde", serde(rename = "Sfx"))]
    pub sfx: Max16Text,

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

impl Validate for OtherIdentification2 {}


#[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:semt.017.002.12")]

pub enum OwnershipLegalRestrictions1Code {
    A144,
    #[yaserde(rename = "NRST")]
    #[cfg_attr(feature = "serde", serde(rename = "NRST"))]
    Nrst,
    #[yaserde(rename = "RSTR")]
    #[cfg_attr(feature = "serde", serde(rename = "RSTR"))]
    Rstr,
    __Unknown__(String),
}

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

impl Validate for OwnershipLegalRestrictions1Code {}



#[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:semt.017.002.12")]
pub struct Pagination1 {
    #[yaserde(rename = "PgNb")]
    #[cfg_attr(feature = "serde", serde(rename = "PgNb"))]
    pub pg_nb: Max5NumericText,

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

impl Validate for Pagination1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.017.002.12")]
pub struct PartyIdentification136Choice {
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_b_i_c: Option<AnyBICDec2014Identifier>,
    #[yaserde(rename = "PrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
    pub prtry_id: Option<GenericIdentification84>,
}

impl Validate for PartyIdentification136Choice {}
#[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:semt.017.002.12")]
pub struct PartyIdentification137Choice {
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_b_i_c: Option<AnyBICDec2014Identifier>,
    #[yaserde(rename = "PrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
    pub prtry_id: Option<GenericIdentification84>,
    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: Option<NameAndAddress12>,
}

impl Validate for PartyIdentification137Choice {}
#[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:semt.017.002.12")]
pub struct PartyIdentification145Choice {
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_b_i_c: Option<AnyBICDec2014Identifier>,
    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: Option<NameAndAddress12>,
    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: Option<CountryCode>,
}

impl Validate for PartyIdentification145Choice {}
#[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:semt.017.002.12")]
pub struct PartyIdentification152Choice {
    #[yaserde(rename = "AnyBIC")]
    #[cfg_attr(feature = "serde", serde(rename = "AnyBIC"))]
    pub any_b_i_c: Option<AnyBICDec2014Identifier>,
    #[yaserde(rename = "PrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
    pub prtry_id: Option<GenericIdentification18>,
    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: Option<NameAndAddress11>,
}

impl Validate for PartyIdentification152Choice {}




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

    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Leiidentifier,
}

impl Validate for PartyIdentification156 {}


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

    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Leiidentifier,
}

impl Validate for PartyIdentification157 {}


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

    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Leiidentifier,

    #[yaserde(rename = "PrcgId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrcgId"))]
    pub prcg_id: RestrictedFINXMax16Text,
}

impl Validate for PartyIdentification191 {}


#[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:semt.017.002.12")]
pub struct PartyIdentification192 {
    #[yaserde(rename = "Pty")]
    #[cfg_attr(feature = "serde", serde(rename = "Pty"))]
    pub pty: PartyIdentification152Choice,

    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Leiidentifier,
}

impl Validate for PartyIdentification192 {}


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

    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Leiidentifier,

    #[yaserde(rename = "SfkpgAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgAcct"))]
    pub sfkpg_acct: SecuritiesAccount30,

    #[yaserde(rename = "BlckChainAdrOrWllt")]
    #[cfg_attr(feature = "serde", serde(rename = "BlckChainAdrOrWllt"))]
    pub blck_chain_adr_or_wllt: BlockChainAddressWallet7,

    #[yaserde(rename = "PrcgId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrcgId"))]
    pub prcg_id: RestrictedFINXMax16Text,
}

impl Validate for PartyIdentificationAndAccount215 {}


#[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:semt.017.002.12")]
pub struct Period2 {
    #[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 Period2 {}
#[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:semt.017.002.12")]
pub struct Period7Choice {
    #[yaserde(rename = "FrDtTmToDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "FrDtTmToDtTm"))]
    pub fr_dt_tm_to_dt_tm: Option<DateTimePeriod1>,
    #[yaserde(rename = "FrDtToDt")]
    #[cfg_attr(feature = "serde", serde(rename = "FrDtToDt"))]
    pub fr_dt_to_dt: Option<Period2>,
}

impl Validate for Period7Choice {}




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

    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Leiidentifier,
}

impl Validate for PlaceOfClearingIdentification2 {}


#[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:semt.017.002.12")]
pub struct PlaceOfTradeIdentification2 {
    #[yaserde(rename = "MktTpAndId")]
    #[cfg_attr(feature = "serde", serde(rename = "MktTpAndId"))]
    pub mkt_tp_and_id: MarketIdentification90,

    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Leiidentifier,
}

impl Validate for PlaceOfTradeIdentification2 {}


#[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:semt.017.002.12")]
pub struct PostalAddress7 {
    #[yaserde(rename = "AdrLine")]
    #[cfg_attr(feature = "serde", serde(rename = "AdrLine"))]
    pub adr_line: Vec<RestrictedFINMax35Text>,

    #[yaserde(rename = "PstCd")]
    #[cfg_attr(feature = "serde", serde(rename = "PstCd"))]
    pub pst_cd: RestrictedFINMax8Text,

    #[yaserde(rename = "TwnNm")]
    #[cfg_attr(feature = "serde", serde(rename = "TwnNm"))]
    pub twn_nm: RestrictedFINMax23Text,

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

impl Validate for PostalAddress7 {}


#[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:semt.017.002.12")]
pub struct PriceInformation24 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: TypeOfPrice49Choice,

    #[yaserde(rename = "ValTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ValTp"))]
    pub val_tp: YieldedOrValueType1Choice,

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

    #[yaserde(rename = "SrcOfPric")]
    #[cfg_attr(feature = "serde", serde(rename = "SrcOfPric"))]
    pub src_of_pric: MarketIdentification91,

    #[yaserde(rename = "QtnDt")]
    #[cfg_attr(feature = "serde", serde(rename = "QtnDt"))]
    pub qtn_dt: DateAndDateTime2Choice,
}

impl Validate for PriceInformation24 {}
#[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:semt.017.002.12")]
pub struct PriceRateOrAmountOrUnknown3Choice {
    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: Option<PercentageRate>,
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<RestrictedFINActiveOrHistoricCurrencyAnd13DecimalAmount>,
    #[yaserde(rename = "UknwnInd")]
    #[cfg_attr(feature = "serde", serde(rename = "UknwnInd"))]
    pub uknwn_ind: Option<YesNoIndicator>,
}

impl Validate for PriceRateOrAmountOrUnknown3Choice {}




#[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:semt.017.002.12")]

pub enum PriceValueType1Code {
    #[yaserde(rename = "DISC")]
    #[cfg_attr(feature = "serde", serde(rename = "DISC"))]
    Disc,
    #[yaserde(rename = "PREM")]
    #[cfg_attr(feature = "serde", serde(rename = "PREM"))]
    Prem,
    #[yaserde(rename = "PARV")]
    #[cfg_attr(feature = "serde", serde(rename = "PARV"))]
    Parv,
    __Unknown__(String),
}

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

impl Validate for PriceValueType1Code {}
#[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:semt.017.002.12")]
pub struct PurposeCode8Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<SecuritiesAccountPurposeType1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for PurposeCode8Choice {}
#[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:semt.017.002.12")]
pub struct Quantity54Choice {
    #[yaserde(rename = "Qty")]
    #[cfg_attr(feature = "serde", serde(rename = "Qty"))]
    pub qty: Option<FinancialInstrumentQuantity36Choice>,
    #[yaserde(rename = "OrgnlAndCurFace")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlAndCurFace"))]
    pub orgnl_and_cur_face: Option<OriginalAndCurrentQuantities4>,
}

impl Validate for Quantity54Choice {}




#[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:semt.017.002.12")]

pub enum ReceiveDelivery1Code {
    #[yaserde(rename = "DELI")]
    #[cfg_attr(feature = "serde", serde(rename = "DELI"))]
    Deli,
    #[yaserde(rename = "RECE")]
    #[cfg_attr(feature = "serde", serde(rename = "RECE"))]
    Rece,
    __Unknown__(String),
}

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

impl Validate for ReceiveDelivery1Code {}
#[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:semt.017.002.12")]
pub struct Registration11Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<Registration1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for Registration11Choice {}




#[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:semt.017.002.12")]

pub enum Registration1Code {
    #[yaserde(rename = "NREG")]
    #[cfg_attr(feature = "serde", serde(rename = "NREG"))]
    Nreg,
    #[yaserde(rename = "YREG")]
    #[cfg_attr(feature = "serde", serde(rename = "YREG"))]
    Yreg,
    __Unknown__(String),
}

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

impl Validate for Registration1Code {}
#[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:semt.017.002.12")]
pub struct RepurchaseType24Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<RepurchaseType9Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for RepurchaseType24Choice {}




#[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:semt.017.002.12")]

pub enum RepurchaseType9Code {
    #[yaserde(rename = "PAIR")]
    #[cfg_attr(feature = "serde", serde(rename = "PAIR"))]
    Pair,
    #[yaserde(rename = "PADJ")]
    #[cfg_attr(feature = "serde", serde(rename = "PADJ"))]
    Padj,
    #[yaserde(rename = "RATE")]
    #[cfg_attr(feature = "serde", serde(rename = "RATE"))]
    Rate,
    #[yaserde(rename = "CALL")]
    #[cfg_attr(feature = "serde", serde(rename = "CALL"))]
    Call,
    #[yaserde(rename = "ROLP")]
    #[cfg_attr(feature = "serde", serde(rename = "ROLP"))]
    Rolp,
    #[yaserde(rename = "CADJ")]
    #[cfg_attr(feature = "serde", serde(rename = "CADJ"))]
    Cadj,
    #[yaserde(rename = "TOPU")]
    #[cfg_attr(feature = "serde", serde(rename = "TOPU"))]
    Topu,
    #[yaserde(rename = "WTHD")]
    #[cfg_attr(feature = "serde", serde(rename = "WTHD"))]
    Wthd,
    __Unknown__(String),
}

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

impl Validate for RepurchaseType9Code {}



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

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

impl Validate for RestrictedFINActiveOrHistoricCurrencyAnd13DecimalAmount {}


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

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

impl Validate for RestrictedFINActiveOrHistoricCurrencyAndAmount {}


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

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

impl Validate for RestrictedFINExact2Text {
    fn validate(&self) -> Result<(), String> { 
        if self.0.len() != 2 {
            return Err(format!("Length validation error. \nExpected: 0 length == 2 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}

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

impl Validate for RestrictedFINImpliedCurrencyAndAmount {
    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)]
pub struct RestrictedFINMax23Text (pub String);
crate::simple_type!(RestrictedFINMax23Text);

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

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

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

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

impl Validate for RestrictedFINMax35Text {
    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 RestrictedFINMax8Text (pub String);
crate::simple_type!(RestrictedFINMax8Text);

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

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

impl Validate for RestrictedFINXMax140Text {
    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 RestrictedFINXMax16Text (pub String);
crate::simple_type!(RestrictedFINXMax16Text);

impl Validate for RestrictedFINXMax16Text {
    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 RestrictedFINXMax30Text (pub String);
crate::simple_type!(RestrictedFINXMax30Text);

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

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

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

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

impl Validate for RestrictedFINXMax34Text {
    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 RestrictedFINXMax350Text (pub String);
crate::simple_type!(RestrictedFINXMax350Text);

impl Validate for RestrictedFINXMax350Text {
    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 RestrictedFINXMax35Text (pub String);
crate::simple_type!(RestrictedFINXMax35Text);

impl Validate for RestrictedFINXMax35Text {
    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 RestrictedFINXMax52Text (pub String);
crate::simple_type!(RestrictedFINXMax52Text);

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

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

impl Validate for RestrictedFINXMax70Text {
    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:semt.017.002.12")]
pub struct Restriction6Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<OwnershipLegalRestrictions1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for Restriction6Choice {}
#[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:semt.017.002.12")]
pub struct Role7Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<InvestmentFundRole2Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
    #[yaserde(rename = "Txt")]
    #[cfg_attr(feature = "serde", serde(rename = "Txt"))]
    pub txt: Option<RestrictedFINXMax350Text>,
}

impl Validate for Role7Choice {}




#[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:semt.017.002.12")]
pub struct SafeKeepingPlace4 {
    #[yaserde(rename = "SfkpgPlcFrmt")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgPlcFrmt"))]
    pub sfkpg_plc_frmt: SafekeepingPlaceFormat39Choice,

    #[yaserde(rename = "LEI")]
    #[cfg_attr(feature = "serde", serde(rename = "LEI"))]
    pub lei: Leiidentifier,
}

impl Validate for SafeKeepingPlace4 {}


#[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:semt.017.002.12")]

pub enum SafekeepingPlace1Code {
    #[yaserde(rename = "CUST")]
    #[cfg_attr(feature = "serde", serde(rename = "CUST"))]
    Cust,
    #[yaserde(rename = "ICSD")]
    #[cfg_attr(feature = "serde", serde(rename = "ICSD"))]
    Icsd,
    #[yaserde(rename = "NCSD")]
    #[cfg_attr(feature = "serde", serde(rename = "NCSD"))]
    Ncsd,
    #[yaserde(rename = "SHHE")]
    #[cfg_attr(feature = "serde", serde(rename = "SHHE"))]
    Shhe,
    __Unknown__(String),
}

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

impl Validate for SafekeepingPlace1Code {}



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

pub enum SafekeepingPlace3Code {
    #[yaserde(rename = "SHHE")]
    #[cfg_attr(feature = "serde", serde(rename = "SHHE"))]
    Shhe,
    __Unknown__(String),
}

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

impl Validate for SafekeepingPlace3Code {}
#[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:semt.017.002.12")]
pub struct SafekeepingPlaceFormat39Choice {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Option<SafekeepingPlaceTypeAndText15>,
    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: Option<CountryCode>,
    #[yaserde(rename = "TpAndId")]
    #[cfg_attr(feature = "serde", serde(rename = "TpAndId"))]
    pub tp_and_id: Option<SafekeepingPlaceTypeAndIdentification1>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification85>,
}

impl Validate for SafekeepingPlaceFormat39Choice {}




#[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:semt.017.002.12")]
pub struct SafekeepingPlaceTypeAndIdentification1 {
    #[yaserde(rename = "SfkpgPlcTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgPlcTp"))]
    pub sfkpg_plc_tp: SafekeepingPlace1Code,

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

impl Validate for SafekeepingPlaceTypeAndIdentification1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.017.002.12")]
pub struct SafekeepingPlaceTypeAndText15 {
    #[yaserde(rename = "SfkpgPlcTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgPlcTp"))]
    pub sfkpg_plc_tp: SafekeepingPlace3Code,

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

impl Validate for SafekeepingPlaceTypeAndText15 {}


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

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

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

impl Validate for SecuritiesAccount30 {}


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

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

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

impl Validate for SecuritiesAccount34 {}


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

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

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

    #[yaserde(rename = "Dsgnt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dsgnt"))]
    pub dsgnt: RestrictedFINXMax35Text,
}

impl Validate for SecuritiesAccount40 {}


#[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:semt.017.002.12")]

pub enum SecuritiesAccountPurposeType1Code {
    #[yaserde(rename = "MARG")]
    #[cfg_attr(feature = "serde", serde(rename = "MARG"))]
    Marg,
    #[yaserde(rename = "SHOR")]
    #[cfg_attr(feature = "serde", serde(rename = "SHOR"))]
    Shor,
    #[yaserde(rename = "ABRD")]
    #[cfg_attr(feature = "serde", serde(rename = "ABRD"))]
    Abrd,
    #[yaserde(rename = "CEND")]
    #[cfg_attr(feature = "serde", serde(rename = "CEND"))]
    Cend,
    #[yaserde(rename = "DVPA")]
    #[cfg_attr(feature = "serde", serde(rename = "DVPA"))]
    Dvpa,
    #[yaserde(rename = "PHYS")]
    #[cfg_attr(feature = "serde", serde(rename = "PHYS"))]
    Phys,
    __Unknown__(String),
}

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

impl Validate for SecuritiesAccountPurposeType1Code {}
#[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:semt.017.002.12")]
pub struct SecuritiesRTGS5Choice {
    #[yaserde(rename = "Ind")]
    #[cfg_attr(feature = "serde", serde(rename = "Ind"))]
    pub ind: Option<YesNoIndicator>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for SecuritiesRTGS5Choice {}




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

    #[yaserde(rename = "StmtGnlDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "StmtGnlDtls"))]
    pub stmt_gnl_dtls: Statement82,

    #[yaserde(rename = "AcctOwnr")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctOwnr"))]
    pub acct_ownr: PartyIdentification156,

    #[yaserde(rename = "SfkpgAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgAcct"))]
    pub sfkpg_acct: SecuritiesAccount40,

    #[yaserde(rename = "BlckChainAdrOrWllt")]
    #[cfg_attr(feature = "serde", serde(rename = "BlckChainAdrOrWllt"))]
    pub blck_chain_adr_or_wllt: BlockChainAddressWallet8,

    #[yaserde(rename = "IntrmyInf")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrmyInf"))]
    pub intrmy_inf: Vec<Intermediary45>,

    #[yaserde(rename = "FinInstrmDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrmDtls"))]
    pub fin_instrm_dtls: Vec<FinancialInstrumentDetails43>,

    #[yaserde(rename = "SubAcctDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "SubAcctDtls"))]
    pub sub_acct_dtls: Vec<SubAccountIdentification70>,
}

impl Validate for SecuritiesTransactionPostingReport002V12 {}


#[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:semt.017.002.12")]

pub enum SecuritiesTransactionType27Code {
    #[yaserde(rename = "BSBK")]
    #[cfg_attr(feature = "serde", serde(rename = "BSBK"))]
    Bsbk,
    #[yaserde(rename = "BYIY")]
    #[cfg_attr(feature = "serde", serde(rename = "BYIY"))]
    Byiy,
    #[yaserde(rename = "CNCB")]
    #[cfg_attr(feature = "serde", serde(rename = "CNCB"))]
    Cncb,
    #[yaserde(rename = "COLI")]
    #[cfg_attr(feature = "serde", serde(rename = "COLI"))]
    Coli,
    #[yaserde(rename = "COLO")]
    #[cfg_attr(feature = "serde", serde(rename = "COLO"))]
    Colo,
    #[yaserde(rename = "CONV")]
    #[cfg_attr(feature = "serde", serde(rename = "CONV"))]
    Conv,
    #[yaserde(rename = "FCTA")]
    #[cfg_attr(feature = "serde", serde(rename = "FCTA"))]
    Fcta,
    #[yaserde(rename = "INSP")]
    #[cfg_attr(feature = "serde", serde(rename = "INSP"))]
    Insp,
    #[yaserde(rename = "ISSU")]
    #[cfg_attr(feature = "serde", serde(rename = "ISSU"))]
    Issu,
    #[yaserde(rename = "MKDW")]
    #[cfg_attr(feature = "serde", serde(rename = "MKDW"))]
    Mkdw,
    #[yaserde(rename = "MKUP")]
    #[cfg_attr(feature = "serde", serde(rename = "MKUP"))]
    Mkup,
    #[yaserde(rename = "NETT")]
    #[cfg_attr(feature = "serde", serde(rename = "NETT"))]
    Nett,
    #[yaserde(rename = "NSYN")]
    #[cfg_attr(feature = "serde", serde(rename = "NSYN"))]
    Nsyn,
    #[yaserde(rename = "OWNE")]
    #[cfg_attr(feature = "serde", serde(rename = "OWNE"))]
    Owne,
    #[yaserde(rename = "OWNI")]
    #[cfg_attr(feature = "serde", serde(rename = "OWNI"))]
    Owni,
    #[yaserde(rename = "PAIR")]
    #[cfg_attr(feature = "serde", serde(rename = "PAIR"))]
    Pair,
    #[yaserde(rename = "PLAC")]
    #[cfg_attr(feature = "serde", serde(rename = "PLAC"))]
    Plac,
    #[yaserde(rename = "PORT")]
    #[cfg_attr(feature = "serde", serde(rename = "PORT"))]
    Port,
    #[yaserde(rename = "REAL")]
    #[cfg_attr(feature = "serde", serde(rename = "REAL"))]
    Real,
    #[yaserde(rename = "REDI")]
    #[cfg_attr(feature = "serde", serde(rename = "REDI"))]
    Redi,
    #[yaserde(rename = "REDM")]
    #[cfg_attr(feature = "serde", serde(rename = "REDM"))]
    Redm,
    #[yaserde(rename = "RELE")]
    #[cfg_attr(feature = "serde", serde(rename = "RELE"))]
    Rele,
    #[yaserde(rename = "REPU")]
    #[cfg_attr(feature = "serde", serde(rename = "REPU"))]
    Repu,
    #[yaserde(rename = "RODE")]
    #[cfg_attr(feature = "serde", serde(rename = "RODE"))]
    Rode,
    #[yaserde(rename = "RVPO")]
    #[cfg_attr(feature = "serde", serde(rename = "RVPO"))]
    Rvpo,
    #[yaserde(rename = "SBBK")]
    #[cfg_attr(feature = "serde", serde(rename = "SBBK"))]
    Sbbk,
    #[yaserde(rename = "SBRE")]
    #[cfg_attr(feature = "serde", serde(rename = "SBRE"))]
    Sbre,
    #[yaserde(rename = "SECB")]
    #[cfg_attr(feature = "serde", serde(rename = "SECB"))]
    Secb,
    #[yaserde(rename = "SECL")]
    #[cfg_attr(feature = "serde", serde(rename = "SECL"))]
    Secl,
    #[yaserde(rename = "SLRE")]
    #[cfg_attr(feature = "serde", serde(rename = "SLRE"))]
    Slre,
    #[yaserde(rename = "SUBS")]
    #[cfg_attr(feature = "serde", serde(rename = "SUBS"))]
    Subs,
    #[yaserde(rename = "SYND")]
    #[cfg_attr(feature = "serde", serde(rename = "SYND"))]
    Synd,
    #[yaserde(rename = "TBAC")]
    #[cfg_attr(feature = "serde", serde(rename = "TBAC"))]
    Tbac,
    #[yaserde(rename = "TRAD")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAD"))]
    Trad,
    #[yaserde(rename = "TRPO")]
    #[cfg_attr(feature = "serde", serde(rename = "TRPO"))]
    Trpo,
    #[yaserde(rename = "TRVO")]
    #[cfg_attr(feature = "serde", serde(rename = "TRVO"))]
    Trvo,
    #[yaserde(rename = "TURN")]
    #[cfg_attr(feature = "serde", serde(rename = "TURN"))]
    Turn,
    #[yaserde(rename = "CLAI")]
    #[cfg_attr(feature = "serde", serde(rename = "CLAI"))]
    Clai,
    #[yaserde(rename = "CORP")]
    #[cfg_attr(feature = "serde", serde(rename = "CORP"))]
    Corp,
    #[yaserde(rename = "AUTO")]
    #[cfg_attr(feature = "serde", serde(rename = "AUTO"))]
    Auto,
    #[yaserde(rename = "SWIF")]
    #[cfg_attr(feature = "serde", serde(rename = "SWIF"))]
    Swif,
    #[yaserde(rename = "SWIT")]
    #[cfg_attr(feature = "serde", serde(rename = "SWIT"))]
    Swit,
    #[yaserde(rename = "ETFT")]
    #[cfg_attr(feature = "serde", serde(rename = "ETFT"))]
    Etft,
    #[yaserde(rename = "REBL")]
    #[cfg_attr(feature = "serde", serde(rename = "REBL"))]
    Rebl,
    #[yaserde(rename = "TRIN")]
    #[cfg_attr(feature = "serde", serde(rename = "TRIN"))]
    Trin,
    #[yaserde(rename = "TOUT")]
    #[cfg_attr(feature = "serde", serde(rename = "TOUT"))]
    Tout,
    __Unknown__(String),
}

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

impl Validate for SecuritiesTransactionType27Code {}
#[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:semt.017.002.12")]
pub struct SecuritiesTransactionType58Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<SecuritiesTransactionType27Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for SecuritiesTransactionType58Choice {}
#[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:semt.017.002.12")]
pub struct SecurityClassificationType3Choice {
    #[yaserde(rename = "CFI")]
    #[cfg_attr(feature = "serde", serde(rename = "CFI"))]
    pub cfi: Option<Cfioct2015Identifier>,
    #[yaserde(rename = "AltrnClssfctn")]
    #[cfg_attr(feature = "serde", serde(rename = "AltrnClssfctn"))]
    pub altrn_clssfctn: Option<GenericIdentification39>,
}

impl Validate for SecurityClassificationType3Choice {}




#[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:semt.017.002.12")]
pub struct SecurityIdentification20 {
    #[yaserde(rename = "ISIN")]
    #[cfg_attr(feature = "serde", serde(rename = "ISIN"))]
    pub isin: Isinoct2015Identifier,

    #[yaserde(rename = "OthrId")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrId"))]
    pub othr_id: Vec<OtherIdentification2>,

    #[yaserde(rename = "Desc")]
    #[cfg_attr(feature = "serde", serde(rename = "Desc"))]
    pub desc: RestrictedFINXMax140Text,
}

impl Validate for SecurityIdentification20 {}
#[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:semt.017.002.12")]
pub struct SettlementDate20Choice {
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Option<DateAndDateTime2Choice>,
    #[yaserde(rename = "DtCd")]
    #[cfg_attr(feature = "serde", serde(rename = "DtCd"))]
    pub dt_cd: Option<SettlementDateCode9Choice>,
}

impl Validate for SettlementDate20Choice {}




#[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:semt.017.002.12")]

pub enum SettlementDate4Code {
    #[yaserde(rename = "WISS")]
    #[cfg_attr(feature = "serde", serde(rename = "WISS"))]
    Wiss,
    __Unknown__(String),
}

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

impl Validate for SettlementDate4Code {}
#[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:semt.017.002.12")]
pub struct SettlementDateCode9Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<SettlementDate4Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for SettlementDateCode9Choice {}




#[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:semt.017.002.12")]
pub struct SettlementDetails198 {
    #[yaserde(rename = "SttlmTxCond")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmTxCond"))]
    pub sttlm_tx_cond: Vec<SettlementTransactionCondition37Choice>,

    #[yaserde(rename = "SttlgCpcty")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlgCpcty"))]
    pub sttlg_cpcty: SettlingCapacity8Choice,

    #[yaserde(rename = "StmpDtyTaxBsis")]
    #[cfg_attr(feature = "serde", serde(rename = "StmpDtyTaxBsis"))]
    pub stmp_dty_tax_bsis: GenericIdentification47,

    #[yaserde(rename = "SctiesRTGS")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesRTGS"))]
    pub scties_rtgs: SecuritiesRTGS5Choice,

    #[yaserde(rename = "Regn")]
    #[cfg_attr(feature = "serde", serde(rename = "Regn"))]
    pub regn: Registration11Choice,

    #[yaserde(rename = "BnfclOwnrsh")]
    #[cfg_attr(feature = "serde", serde(rename = "BnfclOwnrsh"))]
    pub bnfcl_ownrsh: BeneficialOwnership5Choice,

    #[yaserde(rename = "CshClrSys")]
    #[cfg_attr(feature = "serde", serde(rename = "CshClrSys"))]
    pub csh_clr_sys: CashSettlementSystem5Choice,

    #[yaserde(rename = "TaxCpcty")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxCpcty"))]
    pub tax_cpcty: TaxCapacityParty5Choice,

    #[yaserde(rename = "RpTp")]
    #[cfg_attr(feature = "serde", serde(rename = "RpTp"))]
    pub rp_tp: RepurchaseType24Choice,

    #[yaserde(rename = "MktClntSd")]
    #[cfg_attr(feature = "serde", serde(rename = "MktClntSd"))]
    pub mkt_clnt_sd: MarketClientSide7Choice,

    #[yaserde(rename = "BlckTrad")]
    #[cfg_attr(feature = "serde", serde(rename = "BlckTrad"))]
    pub blck_trad: BlockTrade5Choice,

    #[yaserde(rename = "LglRstrctns")]
    #[cfg_attr(feature = "serde", serde(rename = "LglRstrctns"))]
    pub lgl_rstrctns: Restriction6Choice,

    #[yaserde(rename = "SttlmSysMtd")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmSysMtd"))]
    pub sttlm_sys_mtd: SettlementSystemMethod5Choice,

    #[yaserde(rename = "NetgElgblty")]
    #[cfg_attr(feature = "serde", serde(rename = "NetgElgblty"))]
    pub netg_elgblty: NettingEligibility5Choice,

    #[yaserde(rename = "CCPElgblty")]
    #[cfg_attr(feature = "serde", serde(rename = "CCPElgblty"))]
    pub ccp_elgblty: CentralCounterPartyEligibility5Choice,

    #[yaserde(rename = "LttrOfGrnt")]
    #[cfg_attr(feature = "serde", serde(rename = "LttrOfGrnt"))]
    pub lttr_of_grnt: LetterOfGuarantee5Choice,

    #[yaserde(rename = "PrtlSttlmInd")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtlSttlmInd"))]
    pub prtl_sttlm_ind: SettlementTransactionCondition5Code,
}

impl Validate for SettlementDetails198 {}
#[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:semt.017.002.12")]
pub struct SettlementOrCorporateActionEvent33Choice {
    #[yaserde(rename = "SctiesTxTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesTxTp"))]
    pub scties_tx_tp: Option<SecuritiesTransactionType58Choice>,
    #[yaserde(rename = "CorpActnEvtTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CorpActnEvtTp"))]
    pub corp_actn_evt_tp: Option<CorporateActionEventType101Choice>,
}

impl Validate for SettlementOrCorporateActionEvent33Choice {}




#[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:semt.017.002.12")]
pub struct SettlementParties109 {
    #[yaserde(rename = "Dpstry")]
    #[cfg_attr(feature = "serde", serde(rename = "Dpstry"))]
    pub dpstry: PartyIdentification191,

    #[yaserde(rename = "Pty1")]
    #[cfg_attr(feature = "serde", serde(rename = "Pty1"))]
    pub pty_1: PartyIdentificationAndAccount215,

    #[yaserde(rename = "Pty2")]
    #[cfg_attr(feature = "serde", serde(rename = "Pty2"))]
    pub pty_2: PartyIdentificationAndAccount215,

    #[yaserde(rename = "Pty3")]
    #[cfg_attr(feature = "serde", serde(rename = "Pty3"))]
    pub pty_3: PartyIdentificationAndAccount215,

    #[yaserde(rename = "Pty4")]
    #[cfg_attr(feature = "serde", serde(rename = "Pty4"))]
    pub pty_4: PartyIdentificationAndAccount215,

    #[yaserde(rename = "Pty5")]
    #[cfg_attr(feature = "serde", serde(rename = "Pty5"))]
    pub pty_5: PartyIdentificationAndAccount215,
}

impl Validate for SettlementParties109 {}


#[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:semt.017.002.12")]

pub enum SettlementSystemMethod1Code {
    #[yaserde(rename = "NSET")]
    #[cfg_attr(feature = "serde", serde(rename = "NSET"))]
    Nset,
    #[yaserde(rename = "YSET")]
    #[cfg_attr(feature = "serde", serde(rename = "YSET"))]
    Yset,
    __Unknown__(String),
}

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

impl Validate for SettlementSystemMethod1Code {}
#[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:semt.017.002.12")]
pub struct SettlementSystemMethod5Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<SettlementSystemMethod1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for SettlementSystemMethod5Choice {}




#[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:semt.017.002.12")]

pub enum SettlementTransactionCondition12Code {
    #[yaserde(rename = "ADEA")]
    #[cfg_attr(feature = "serde", serde(rename = "ADEA"))]
    Adea,
    #[yaserde(rename = "ASGN")]
    #[cfg_attr(feature = "serde", serde(rename = "ASGN"))]
    Asgn,
    #[yaserde(rename = "BUTC")]
    #[cfg_attr(feature = "serde", serde(rename = "BUTC"))]
    Butc,
    #[yaserde(rename = "CLEN")]
    #[cfg_attr(feature = "serde", serde(rename = "CLEN"))]
    Clen,
    #[yaserde(rename = "DLWM")]
    #[cfg_attr(feature = "serde", serde(rename = "DLWM"))]
    Dlwm,
    #[yaserde(rename = "DIRT")]
    #[cfg_attr(feature = "serde", serde(rename = "DIRT"))]
    Dirt,
    #[yaserde(rename = "DRAW")]
    #[cfg_attr(feature = "serde", serde(rename = "DRAW"))]
    Draw,
    #[yaserde(rename = "EXER")]
    #[cfg_attr(feature = "serde", serde(rename = "EXER"))]
    Exer,
    #[yaserde(rename = "EXPI")]
    #[cfg_attr(feature = "serde", serde(rename = "EXPI"))]
    Expi,
    #[yaserde(rename = "FRCL")]
    #[cfg_attr(feature = "serde", serde(rename = "FRCL"))]
    Frcl,
    #[yaserde(rename = "KNOC")]
    #[cfg_attr(feature = "serde", serde(rename = "KNOC"))]
    Knoc,
    #[yaserde(rename = "NOMC")]
    #[cfg_attr(feature = "serde", serde(rename = "NOMC"))]
    Nomc,
    #[yaserde(rename = "NACT")]
    #[cfg_attr(feature = "serde", serde(rename = "NACT"))]
    Nact,
    #[yaserde(rename = "PENS")]
    #[cfg_attr(feature = "serde", serde(rename = "PENS"))]
    Pens,
    #[yaserde(rename = "PHYS")]
    #[cfg_attr(feature = "serde", serde(rename = "PHYS"))]
    Phys,
    #[yaserde(rename = "RHYP")]
    #[cfg_attr(feature = "serde", serde(rename = "RHYP"))]
    Rhyp,
    #[yaserde(rename = "RPTO")]
    #[cfg_attr(feature = "serde", serde(rename = "RPTO"))]
    Rpto,
    #[yaserde(rename = "RESI")]
    #[cfg_attr(feature = "serde", serde(rename = "RESI"))]
    Resi,
    #[yaserde(rename = "SHOR")]
    #[cfg_attr(feature = "serde", serde(rename = "SHOR"))]
    Shor,
    #[yaserde(rename = "SPDL")]
    #[cfg_attr(feature = "serde", serde(rename = "SPDL"))]
    Spdl,
    #[yaserde(rename = "SPST")]
    #[cfg_attr(feature = "serde", serde(rename = "SPST"))]
    Spst,
    #[yaserde(rename = "TRAN")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAN"))]
    Tran,
    #[yaserde(rename = "TRIP")]
    #[cfg_attr(feature = "serde", serde(rename = "TRIP"))]
    Trip,
    #[yaserde(rename = "UNEX")]
    #[cfg_attr(feature = "serde", serde(rename = "UNEX"))]
    Unex,
    #[yaserde(rename = "INTS")]
    #[cfg_attr(feature = "serde", serde(rename = "INTS"))]
    Ints,
    #[yaserde(rename = "BPSS")]
    #[cfg_attr(feature = "serde", serde(rename = "BPSS"))]
    Bpss,
    __Unknown__(String),
}

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

impl Validate for SettlementTransactionCondition12Code {}
#[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:semt.017.002.12")]
pub struct SettlementTransactionCondition37Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<SettlementTransactionCondition12Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for SettlementTransactionCondition37Choice {}




#[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:semt.017.002.12")]

pub enum SettlementTransactionCondition5Code {
    #[yaserde(rename = "PART")]
    #[cfg_attr(feature = "serde", serde(rename = "PART"))]
    Part,
    #[yaserde(rename = "NPAR")]
    #[cfg_attr(feature = "serde", serde(rename = "NPAR"))]
    Npar,
    #[yaserde(rename = "PARC")]
    #[cfg_attr(feature = "serde", serde(rename = "PARC"))]
    Parc,
    #[yaserde(rename = "PARQ")]
    #[cfg_attr(feature = "serde", serde(rename = "PARQ"))]
    Parq,
    __Unknown__(String),
}

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

impl Validate for SettlementTransactionCondition5Code {}



#[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:semt.017.002.12")]

pub enum SettlingCapacity2Code {
    #[yaserde(rename = "SAGE")]
    #[cfg_attr(feature = "serde", serde(rename = "SAGE"))]
    Sage,
    #[yaserde(rename = "CUST")]
    #[cfg_attr(feature = "serde", serde(rename = "CUST"))]
    Cust,
    #[yaserde(rename = "SPRI")]
    #[cfg_attr(feature = "serde", serde(rename = "SPRI"))]
    Spri,
    #[yaserde(rename = "RISP")]
    #[cfg_attr(feature = "serde", serde(rename = "RISP"))]
    Risp,
    __Unknown__(String),
}

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

impl Validate for SettlingCapacity2Code {}
#[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:semt.017.002.12")]
pub struct SettlingCapacity8Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<SettlingCapacity2Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for SettlingCapacity8Choice {}




#[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:semt.017.002.12")]

pub enum ShortLong1Code {
    #[yaserde(rename = "SHOR")]
    #[cfg_attr(feature = "serde", serde(rename = "SHOR"))]
    Shor,
    #[yaserde(rename = "LONG")]
    #[cfg_attr(feature = "serde", serde(rename = "LONG"))]
    Long,
    __Unknown__(String),
}

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

impl Validate for ShortLong1Code {}



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

impl Validate for SimpleIdentificationInformation1 {}


#[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:semt.017.002.12")]
pub struct Statement82 {
    #[yaserde(rename = "RptNb")]
    #[cfg_attr(feature = "serde", serde(rename = "RptNb"))]
    pub rpt_nb: Number3Choice,

    #[yaserde(rename = "QryRef")]
    #[cfg_attr(feature = "serde", serde(rename = "QryRef"))]
    pub qry_ref: RestrictedFINXMax16Text,

    #[yaserde(rename = "StmtId")]
    #[cfg_attr(feature = "serde", serde(rename = "StmtId"))]
    pub stmt_id: RestrictedFINXMax16Text,

    #[yaserde(rename = "StmtPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "StmtPrd"))]
    pub stmt_prd: Period7Choice,

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

    #[yaserde(rename = "UpdTp")]
    #[cfg_attr(feature = "serde", serde(rename = "UpdTp"))]
    pub upd_tp: UpdateType16Choice,

    #[yaserde(rename = "StmtBsis")]
    #[cfg_attr(feature = "serde", serde(rename = "StmtBsis"))]
    pub stmt_bsis: StatementBasis12Choice,

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

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

impl Validate for Statement82 {}
#[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:semt.017.002.12")]
pub struct StatementBasis12Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<StatementBasis2Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for StatementBasis12Choice {}




#[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:semt.017.002.12")]

pub enum StatementBasis2Code {
    #[yaserde(rename = "SETT")]
    #[cfg_attr(feature = "serde", serde(rename = "SETT"))]
    Sett,
    #[yaserde(rename = "TRAD")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAD"))]
    Trad,
    __Unknown__(String),
}

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

impl Validate for StatementBasis2Code {}



#[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:semt.017.002.12")]

pub enum StatementUpdateType1Code {
    #[yaserde(rename = "COMP")]
    #[cfg_attr(feature = "serde", serde(rename = "COMP"))]
    Comp,
    #[yaserde(rename = "DELT")]
    #[cfg_attr(feature = "serde", serde(rename = "DELT"))]
    Delt,
    __Unknown__(String),
}

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

impl Validate for StatementUpdateType1Code {}



#[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:semt.017.002.12")]
pub struct SubAccountIdentification70 {
    #[yaserde(rename = "AcctOwnr")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctOwnr"))]
    pub acct_ownr: PartyIdentification156,

    #[yaserde(rename = "SfkpgAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgAcct"))]
    pub sfkpg_acct: SecuritiesAccount34,

    #[yaserde(rename = "BlckChainAdrOrWllt")]
    #[cfg_attr(feature = "serde", serde(rename = "BlckChainAdrOrWllt"))]
    pub blck_chain_adr_or_wllt: BlockChainAddressWallet9,

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

    #[yaserde(rename = "FinInstrmDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrmDtls"))]
    pub fin_instrm_dtls: Vec<FinancialInstrumentDetails43>,
}

impl Validate for SubAccountIdentification70 {}


#[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:semt.017.002.12")]
pub struct SupplementaryData1 {
    #[yaserde(rename = "PlcAndNm")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcAndNm"))]
    pub plc_and_nm: Max350Text,

    #[yaserde(rename = "Envlp")]
    #[cfg_attr(feature = "serde", serde(rename = "Envlp"))]
    pub envlp: SupplementaryDataEnvelope1,
}

impl Validate for SupplementaryData1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.017.002.12")]
pub struct SupplementaryDataEnvelope1 {}

impl Validate for SupplementaryDataEnvelope1 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:semt.017.002.12")]
pub struct TaxCapacityParty5Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<TaxLiability1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for TaxCapacityParty5Choice {}




#[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:semt.017.002.12")]

pub enum TaxLiability1Code {
    #[yaserde(rename = "PRIN")]
    #[cfg_attr(feature = "serde", serde(rename = "PRIN"))]
    Prin,
    #[yaserde(rename = "AGEN")]
    #[cfg_attr(feature = "serde", serde(rename = "AGEN"))]
    Agen,
    __Unknown__(String),
}

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

impl Validate for TaxLiability1Code {}
#[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:semt.017.002.12")]
pub struct TradeDate9Choice {
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Option<DateAndDateTime2Choice>,
    #[yaserde(rename = "DtCd")]
    #[cfg_attr(feature = "serde", serde(rename = "DtCd"))]
    pub dt_cd: Option<TradeDateCode4Choice>,
}

impl Validate for TradeDate9Choice {}
#[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:semt.017.002.12")]
pub struct TradeDateCode4Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<DateType3Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for TradeDateCode4Choice {}




#[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:semt.017.002.12")]
pub struct Transaction126 {
    #[yaserde(rename = "AcctOwnrTxId")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctOwnrTxId"))]
    pub acct_ownr_tx_id: RestrictedFINXMax16Text,

    #[yaserde(rename = "AcctSvcrTxId")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctSvcrTxId"))]
    pub acct_svcr_tx_id: RestrictedFINXMax16Text,

    #[yaserde(rename = "MktInfrstrctrTxId")]
    #[cfg_attr(feature = "serde", serde(rename = "MktInfrstrctrTxId"))]
    pub mkt_infrstrctr_tx_id: RestrictedFINXMax16Text,

    #[yaserde(rename = "CtrPtyMktInfrstrctrTxId")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrPtyMktInfrstrctrTxId"))]
    pub ctr_pty_mkt_infrstrctr_tx_id: RestrictedFINXMax16Text,

    #[yaserde(rename = "PrcrTxId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrcrTxId"))]
    pub prcr_tx_id: RestrictedFINXMax16Text,

    #[yaserde(rename = "TradId")]
    #[cfg_attr(feature = "serde", serde(rename = "TradId"))]
    pub trad_id: Vec<RestrictedFINXMax52Text>,

    #[yaserde(rename = "PoolId")]
    #[cfg_attr(feature = "serde", serde(rename = "PoolId"))]
    pub pool_id: RestrictedFINXMax16Text,

    #[yaserde(rename = "CmonId")]
    #[cfg_attr(feature = "serde", serde(rename = "CmonId"))]
    pub cmon_id: RestrictedFINXMax16Text,

    #[yaserde(rename = "CorpActnEvtId")]
    #[cfg_attr(feature = "serde", serde(rename = "CorpActnEvtId"))]
    pub corp_actn_evt_id: RestrictedFINXMax16Text,

    #[yaserde(rename = "TrptyAgtSvcPrvdrCollTxId")]
    #[cfg_attr(feature = "serde", serde(rename = "TrptyAgtSvcPrvdrCollTxId"))]
    pub trpty_agt_svc_prvdr_coll_tx_id: RestrictedFINXMax16Text,

    #[yaserde(rename = "ClntTrptyCollTxId")]
    #[cfg_attr(feature = "serde", serde(rename = "ClntTrptyCollTxId"))]
    pub clnt_trpty_coll_tx_id: RestrictedFINXMax16Text,

    #[yaserde(rename = "ClntCollInstrId")]
    #[cfg_attr(feature = "serde", serde(rename = "ClntCollInstrId"))]
    pub clnt_coll_instr_id: RestrictedFINXMax16Text,

    #[yaserde(rename = "TrptyAgtSvcPrvdrCollInstrId")]
    #[cfg_attr(feature = "serde", serde(rename = "TrptyAgtSvcPrvdrCollInstrId"))]
    pub trpty_agt_svc_prvdr_coll_instr_id: RestrictedFINXMax16Text,

    #[yaserde(rename = "MstrRef")]
    #[cfg_attr(feature = "serde", serde(rename = "MstrRef"))]
    pub mstr_ref: RestrictedFINXMax35Text,

    #[yaserde(rename = "ClntRef")]
    #[cfg_attr(feature = "serde", serde(rename = "ClntRef"))]
    pub clnt_ref: AdditionalReference12,

    #[yaserde(rename = "AcctOwnrLegId")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctOwnrLegId"))]
    pub acct_ownr_leg_id: RestrictedFINXMax35Text,

    #[yaserde(rename = "AcctSvcrLegId")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctSvcrLegId"))]
    pub acct_svcr_leg_id: RestrictedFINXMax35Text,

    #[yaserde(rename = "TxDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "TxDtls"))]
    pub tx_dtls: TransactionDetails165,

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

impl Validate for Transaction126 {}


#[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:semt.017.002.12")]

pub enum TransactionActivity1Code {
    #[yaserde(rename = "BOLE")]
    #[cfg_attr(feature = "serde", serde(rename = "BOLE"))]
    Bole,
    #[yaserde(rename = "CLAI")]
    #[cfg_attr(feature = "serde", serde(rename = "CLAI"))]
    Clai,
    #[yaserde(rename = "COLL")]
    #[cfg_attr(feature = "serde", serde(rename = "COLL"))]
    Coll,
    #[yaserde(rename = "CORP")]
    #[cfg_attr(feature = "serde", serde(rename = "CORP"))]
    Corp,
    #[yaserde(rename = "SETT")]
    #[cfg_attr(feature = "serde", serde(rename = "SETT"))]
    Sett,
    __Unknown__(String),
}

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

impl Validate for TransactionActivity1Code {}
#[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:semt.017.002.12")]
pub struct TransactionActivity4Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<TransactionActivity1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for TransactionActivity4Choice {}




#[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:semt.017.002.12")]
pub struct TransactionDetails165 {
    #[yaserde(rename = "TxActvty")]
    #[cfg_attr(feature = "serde", serde(rename = "TxActvty"))]
    pub tx_actvty: TransactionActivity4Choice,

    #[yaserde(rename = "SttlmTxOrCorpActnEvtTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmTxOrCorpActnEvtTp"))]
    pub sttlm_tx_or_corp_actn_evt_tp: SettlementOrCorporateActionEvent33Choice,

    #[yaserde(rename = "SctiesMvmntTp")]
    #[cfg_attr(feature = "serde", serde(rename = "SctiesMvmntTp"))]
    pub scties_mvmnt_tp: ReceiveDelivery1Code,

    #[yaserde(rename = "Pmt")]
    #[cfg_attr(feature = "serde", serde(rename = "Pmt"))]
    pub pmt: DeliveryReceiptType2Code,

    #[yaserde(rename = "SttlmParams")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmParams"))]
    pub sttlm_params: SettlementDetails198,

    #[yaserde(rename = "PlcOfTrad")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcOfTrad"))]
    pub plc_of_trad: PlaceOfTradeIdentification2,

    #[yaserde(rename = "SfkpgPlc")]
    #[cfg_attr(feature = "serde", serde(rename = "SfkpgPlc"))]
    pub sfkpg_plc: SafeKeepingPlace4,

    #[yaserde(rename = "PlcOfClr")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcOfClr"))]
    pub plc_of_clr: PlaceOfClearingIdentification2,

    #[yaserde(rename = "PstngQty")]
    #[cfg_attr(feature = "serde", serde(rename = "PstngQty"))]
    pub pstng_qty: Quantity54Choice,

    #[yaserde(rename = "NbOfDaysAcrd")]
    #[cfg_attr(feature = "serde", serde(rename = "NbOfDaysAcrd"))]
    pub nb_of_days_acrd: Max3Number,

    #[yaserde(rename = "PstngAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "PstngAmt"))]
    pub pstng_amt: AmountAndDirection18,

    #[yaserde(rename = "AcrdIntrstAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "AcrdIntrstAmt"))]
    pub acrd_intrst_amt: AmountAndDirection59,

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

    #[yaserde(rename = "FctvSttlmDt")]
    #[cfg_attr(feature = "serde", serde(rename = "FctvSttlmDt"))]
    pub fctv_sttlm_dt: DateAndDateTime2Choice,

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

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

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

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

    #[yaserde(rename = "DlvrgSttlmPties")]
    #[cfg_attr(feature = "serde", serde(rename = "DlvrgSttlmPties"))]
    pub dlvrg_sttlm_pties: SettlementParties109,

    #[yaserde(rename = "RcvgSttlmPties")]
    #[cfg_attr(feature = "serde", serde(rename = "RcvgSttlmPties"))]
    pub rcvg_sttlm_pties: SettlementParties109,

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

    #[yaserde(rename = "TxAddtlDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "TxAddtlDtls"))]
    pub tx_addtl_dtls: RestrictedFINXMax350Text,
}

impl Validate for TransactionDetails165 {}


#[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:semt.017.002.12")]

pub enum TypeOfPrice17Code {
    #[yaserde(rename = "BIDE")]
    #[cfg_attr(feature = "serde", serde(rename = "BIDE"))]
    Bide,
    #[yaserde(rename = "OFFR")]
    #[cfg_attr(feature = "serde", serde(rename = "OFFR"))]
    Offr,
    #[yaserde(rename = "NAVL")]
    #[cfg_attr(feature = "serde", serde(rename = "NAVL"))]
    Navl,
    #[yaserde(rename = "CREA")]
    #[cfg_attr(feature = "serde", serde(rename = "CREA"))]
    Crea,
    #[yaserde(rename = "CANC")]
    #[cfg_attr(feature = "serde", serde(rename = "CANC"))]
    Canc,
    #[yaserde(rename = "INTE")]
    #[cfg_attr(feature = "serde", serde(rename = "INTE"))]
    Inte,
    #[yaserde(rename = "SWNG")]
    #[cfg_attr(feature = "serde", serde(rename = "SWNG"))]
    Swng,
    #[yaserde(rename = "MIDD")]
    #[cfg_attr(feature = "serde", serde(rename = "MIDD"))]
    Midd,
    #[yaserde(rename = "RINV")]
    #[cfg_attr(feature = "serde", serde(rename = "RINV"))]
    Rinv,
    #[yaserde(rename = "SWIC")]
    #[cfg_attr(feature = "serde", serde(rename = "SWIC"))]
    Swic,
    #[yaserde(rename = "MRKT")]
    #[cfg_attr(feature = "serde", serde(rename = "MRKT"))]
    Mrkt,
    #[yaserde(rename = "INDC")]
    #[cfg_attr(feature = "serde", serde(rename = "INDC"))]
    Indc,
    #[yaserde(rename = "DDVR")]
    #[cfg_attr(feature = "serde", serde(rename = "DDVR"))]
    Ddvr,
    #[yaserde(rename = "ACTU")]
    #[cfg_attr(feature = "serde", serde(rename = "ACTU"))]
    Actu,
    __Unknown__(String),
}

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

impl Validate for TypeOfPrice17Code {}
#[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:semt.017.002.12")]
pub struct TypeOfPrice49Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<TypeOfPrice17Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for TypeOfPrice49Choice {}
#[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:semt.017.002.12")]
pub struct UpdateType16Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<StatementUpdateType1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for UpdateType16Choice {}




#[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 {}
#[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:semt.017.002.12")]
pub struct YieldedOrValueType1Choice {
    #[yaserde(rename = "Yldd")]
    #[cfg_attr(feature = "serde", serde(rename = "Yldd"))]
    pub yldd: Option<YesNoIndicator>,
    #[yaserde(rename = "ValTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ValTp"))]
    pub val_tp: Option<PriceValueType1Code>,
}

impl Validate for YieldedOrValueType1Choice {}

impl crate::MxMessage for Document {
    const BUSINESS_AREA: crate::BusinessArea = crate::BusinessArea::semt;
    const FUNCTIONALITY: &'static str = "017";
    const VARIANT: &'static str = "002";
    const VERSION: &'static str = "12";
    const MESSAGE_NAME: &'static str = "semt.017.002.12";
    const NAMESPACE: &'static str = "urn:iso:std:iso:20022:tech:xsd:semt.017.002.12";
}