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:acmt.001.001.08")]
pub struct Account23 {
    #[yaserde(rename = "AcctId")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctId"))]
    pub acct_id: Max35Text,

    #[yaserde(rename = "RltdAcctDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "RltdAcctDtls"))]
    pub rltd_acct_dtls: GenericIdentification1,
}

impl Validate for Account23 {}


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

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

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

impl Validate for AccountDesignation1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct AccountIdentification4Choice {
    #[yaserde(rename = "IBAN")]
    #[cfg_attr(feature = "serde", serde(rename = "IBAN"))]
    pub iban: Option<Iban2007Identifier>,
    #[yaserde(rename = "Othr")]
    #[cfg_attr(feature = "serde", serde(rename = "Othr"))]
    pub othr: Option<GenericAccountIdentification1>,
}

impl Validate for AccountIdentification4Choice {}




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

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

impl Validate for AccountIdentificationAndName5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct AccountOpeningInstructionV08 {
    #[yaserde(rename = "MsgId")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgId"))]
    pub msg_id: MessageIdentification1,

    #[yaserde(rename = "OrdrRef")]
    #[cfg_attr(feature = "serde", serde(rename = "OrdrRef"))]
    pub ordr_ref: InvestmentFundOrder4,

    #[yaserde(rename = "PrvsRef")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvsRef"))]
    pub prvs_ref: AdditionalReference13,

    #[yaserde(rename = "InstrDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "InstrDtls"))]
    pub instr_dtls: InvestmentAccountOpening4,

    #[yaserde(rename = "InvstmtAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "InvstmtAcct"))]
    pub invstmt_acct: InvestmentAccount73,

    #[yaserde(rename = "AcctPties")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctPties"))]
    pub acct_pties: AccountParties17,

    #[yaserde(rename = "Intrmies")]
    #[cfg_attr(feature = "serde", serde(rename = "Intrmies"))]
    pub intrmies: Vec<Intermediary46>,

    #[yaserde(rename = "Plcmnt")]
    #[cfg_attr(feature = "serde", serde(rename = "Plcmnt"))]
    pub plcmnt: ReferredAgent3,

    #[yaserde(rename = "NewIsseAllcn")]
    #[cfg_attr(feature = "serde", serde(rename = "NewIsseAllcn"))]
    pub new_isse_allcn: NewIssueAllocation2,

    #[yaserde(rename = "SvgsInvstmtPlan")]
    #[cfg_attr(feature = "serde", serde(rename = "SvgsInvstmtPlan"))]
    pub svgs_invstmt_plan: Vec<InvestmentPlan17>,

    #[yaserde(rename = "WdrwlInvstmtPlan")]
    #[cfg_attr(feature = "serde", serde(rename = "WdrwlInvstmtPlan"))]
    pub wdrwl_invstmt_plan: Vec<InvestmentPlan17>,

    #[yaserde(rename = "CshSttlm")]
    #[cfg_attr(feature = "serde", serde(rename = "CshSttlm"))]
    pub csh_sttlm: Vec<CashSettlement3>,

    #[yaserde(rename = "SvcLvlAgrmt")]
    #[cfg_attr(feature = "serde", serde(rename = "SvcLvlAgrmt"))]
    pub svc_lvl_agrmt: Vec<DocumentToSend4>,

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

    #[yaserde(rename = "MktPrctcVrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "MktPrctcVrsn"))]
    pub mkt_prctc_vrsn: MarketPracticeVersion1,

    #[yaserde(rename = "Xtnsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Xtnsn"))]
    pub xtnsn: Vec<Extension1>,
}

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

impl Validate for AccountOpeningType1Choice {}




#[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:acmt.001.001.08")]

pub enum AccountOpeningType1Code {
    #[yaserde(rename = "NEWA")]
    #[cfg_attr(feature = "serde", serde(rename = "NEWA"))]
    Newa,
    #[yaserde(rename = "SUPA")]
    #[cfg_attr(feature = "serde", serde(rename = "SUPA"))]
    Supa,
    __Unknown__(String),
}

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

impl Validate for AccountOpeningType1Code {}



#[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:acmt.001.001.08")]

pub enum AccountOwnershipType4Code {
    #[yaserde(rename = "UNCO")]
    #[cfg_attr(feature = "serde", serde(rename = "UNCO"))]
    Unco,
    #[yaserde(rename = "LIPA")]
    #[cfg_attr(feature = "serde", serde(rename = "LIPA"))]
    Lipa,
    #[yaserde(rename = "ENTR")]
    #[cfg_attr(feature = "serde", serde(rename = "ENTR"))]
    Entr,
    #[yaserde(rename = "CORP")]
    #[cfg_attr(feature = "serde", serde(rename = "CORP"))]
    Corp,
    #[yaserde(rename = "CUST")]
    #[cfg_attr(feature = "serde", serde(rename = "CUST"))]
    Cust,
    #[yaserde(rename = "EURE")]
    #[cfg_attr(feature = "serde", serde(rename = "EURE"))]
    Eure,
    #[yaserde(rename = "PART")]
    #[cfg_attr(feature = "serde", serde(rename = "PART"))]
    Part,
    #[yaserde(rename = "TRUS")]
    #[cfg_attr(feature = "serde", serde(rename = "TRUS"))]
    Trus,
    #[yaserde(rename = "GOVO")]
    #[cfg_attr(feature = "serde", serde(rename = "GOVO"))]
    Govo,
    #[yaserde(rename = "JOIT")]
    #[cfg_attr(feature = "serde", serde(rename = "JOIT"))]
    Joit,
    #[yaserde(rename = "COMO")]
    #[cfg_attr(feature = "serde", serde(rename = "COMO"))]
    Como,
    #[yaserde(rename = "JOIN")]
    #[cfg_attr(feature = "serde", serde(rename = "JOIN"))]
    Join,
    #[yaserde(rename = "LLCO")]
    #[cfg_attr(feature = "serde", serde(rename = "LLCO"))]
    Llco,
    #[yaserde(rename = "NOMI")]
    #[cfg_attr(feature = "serde", serde(rename = "NOMI"))]
    Nomi,
    #[yaserde(rename = "NFPO")]
    #[cfg_attr(feature = "serde", serde(rename = "NFPO"))]
    Nfpo,
    #[yaserde(rename = "ONIS")]
    #[cfg_attr(feature = "serde", serde(rename = "ONIS"))]
    Onis,
    #[yaserde(rename = "RGIC")]
    #[cfg_attr(feature = "serde", serde(rename = "RGIC"))]
    Rgic,
    #[yaserde(rename = "SIGL")]
    #[cfg_attr(feature = "serde", serde(rename = "SIGL"))]
    Sigl,
    __Unknown__(String),
}

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

impl Validate for AccountOwnershipType4Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct AccountParties12Choice {
    #[yaserde(rename = "PmryOwnr")]
    #[cfg_attr(feature = "serde", serde(rename = "PmryOwnr"))]
    pub pmry_ownr: Option<InvestmentAccountOwnershipInformation16>,
    #[yaserde(rename = "Trstee")]
    #[cfg_attr(feature = "serde", serde(rename = "Trstee"))]
    pub trstee: Vec<InvestmentAccountOwnershipInformation16>,
    #[yaserde(rename = "Nmnee")]
    #[cfg_attr(feature = "serde", serde(rename = "Nmnee"))]
    pub nmnee: Option<InvestmentAccountOwnershipInformation16>,
    #[yaserde(rename = "JntOwnr")]
    #[cfg_attr(feature = "serde", serde(rename = "JntOwnr"))]
    pub jnt_ownr: Vec<InvestmentAccountOwnershipInformation16>,
}

impl Validate for AccountParties12Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct AccountParties17 {
    #[yaserde(rename = "PrncplAcctPty")]
    #[cfg_attr(feature = "serde", serde(rename = "PrncplAcctPty"))]
    pub prncpl_acct_pty: AccountParties12Choice,

    #[yaserde(rename = "ScndryOwnr")]
    #[cfg_attr(feature = "serde", serde(rename = "ScndryOwnr"))]
    pub scndry_ownr: Vec<InvestmentAccountOwnershipInformation16>,

    #[yaserde(rename = "Bnfcry")]
    #[cfg_attr(feature = "serde", serde(rename = "Bnfcry"))]
    pub bnfcry: Vec<InvestmentAccountOwnershipInformation16>,

    #[yaserde(rename = "PwrOfAttny")]
    #[cfg_attr(feature = "serde", serde(rename = "PwrOfAttny"))]
    pub pwr_of_attny: Vec<InvestmentAccountOwnershipInformation16>,

    #[yaserde(rename = "LglGuardn")]
    #[cfg_attr(feature = "serde", serde(rename = "LglGuardn"))]
    pub lgl_guardn: Vec<InvestmentAccountOwnershipInformation16>,

    #[yaserde(rename = "CtdnForMnr")]
    #[cfg_attr(feature = "serde", serde(rename = "CtdnForMnr"))]
    pub ctdn_for_mnr: Vec<InvestmentAccountOwnershipInformation16>,

    #[yaserde(rename = "SucssrOnDth")]
    #[cfg_attr(feature = "serde", serde(rename = "SucssrOnDth"))]
    pub sucssr_on_dth: Vec<InvestmentAccountOwnershipInformation16>,

    #[yaserde(rename = "Admstr")]
    #[cfg_attr(feature = "serde", serde(rename = "Admstr"))]
    pub admstr: Vec<InvestmentAccountOwnershipInformation16>,

    #[yaserde(rename = "OthrPty")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrPty"))]
    pub othr_pty: Vec<ExtendedParty14>,

    #[yaserde(rename = "Grntr")]
    #[cfg_attr(feature = "serde", serde(rename = "Grntr"))]
    pub grntr: Vec<InvestmentAccountOwnershipInformation16>,

    #[yaserde(rename = "Sttlr")]
    #[cfg_attr(feature = "serde", serde(rename = "Sttlr"))]
    pub sttlr: Vec<InvestmentAccountOwnershipInformation16>,

    #[yaserde(rename = "SnrMggOffcl")]
    #[cfg_attr(feature = "serde", serde(rename = "SnrMggOffcl"))]
    pub snr_mgg_offcl: Vec<InvestmentAccountOwnershipInformation16>,

    #[yaserde(rename = "Prtctr")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtctr"))]
    pub prtctr: Vec<InvestmentAccountOwnershipInformation16>,

    #[yaserde(rename = "RegdShrhldrNm")]
    #[cfg_attr(feature = "serde", serde(rename = "RegdShrhldrNm"))]
    pub regd_shrhldr_nm: RegisteredShareholderName1Choice,
}

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

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

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

impl Validate for AccountUsageType2Choice {}




#[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:acmt.001.001.08")]

pub enum AccountUsageType2Code {
    #[yaserde(rename = "INVE")]
    #[cfg_attr(feature = "serde", serde(rename = "INVE"))]
    Inve,
    #[yaserde(rename = "ISSP")]
    #[cfg_attr(feature = "serde", serde(rename = "ISSP"))]
    Issp,
    #[yaserde(rename = "SETP")]
    #[cfg_attr(feature = "serde", serde(rename = "SETP"))]
    Setp,
    #[yaserde(rename = "TRDP")]
    #[cfg_attr(feature = "serde", serde(rename = "TRDP"))]
    Trdp,
    __Unknown__(String),
}

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

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

impl Validate for AccountingStatus1Choice {}




#[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:acmt.001.001.08")]

pub enum AccountingStatus1Code {
    #[yaserde(rename = "YDOM")]
    #[cfg_attr(feature = "serde", serde(rename = "YDOM"))]
    Ydom,
    #[yaserde(rename = "NDOM")]
    #[cfg_attr(feature = "serde", serde(rename = "NDOM"))]
    Ndom,
    __Unknown__(String),
}

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

impl Validate for AccountingStatus1Code {}



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

impl Validate for ActiveCurrencyAnd13DecimalAmountSimpleType {
    fn validate(&self) -> Result<(), String> { 
        if self.0 < "0".parse::<String>().unwrap() {
            return Err(format!("MinInclusive validation error: invalid value of 0! \nExpected: 0 >= 0.\nActual: 0 == {}", self.0));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct ActiveCurrencyAnd13DecimalAmount {
    #[yaserde(text)]
    pub value: String,
    #[yaserde(attribute, rename = "Ccy")]
    #[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
    pub ccy: ActiveCurrencyCode,
}

impl Validate for ActiveCurrencyAnd13DecimalAmount {}


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

impl Validate for ActiveCurrencyAndAmountSimpleType {
    fn validate(&self) -> Result<(), String> { 
        if self.0 < "0".parse::<String>().unwrap() {
            return Err(format!("MinInclusive validation error: invalid value of 0! \nExpected: 0 >= 0.\nActual: 0 == {}", self.0));
        }
        Ok(())
    }
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct ActiveCurrencyAndAmount {
    #[yaserde(text)]
    pub value: String,
    #[yaserde(attribute, rename = "Ccy")]
    #[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
    pub ccy: ActiveCurrencyCode,
}

impl Validate for ActiveCurrencyAndAmount {}


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

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

impl Validate for ActiveOrHistoricCurrencyCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct AdditionalReference13 {
    #[yaserde(rename = "Ref")]
    #[cfg_attr(feature = "serde", serde(rename = "Ref"))]
    pub _ref: Max35Text,

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

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

impl Validate for AdditionalReference13 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct AdditiononalInformation13 {
    #[yaserde(rename = "Lmttn")]
    #[cfg_attr(feature = "serde", serde(rename = "Lmttn"))]
    pub lmttn: Max350Text,

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

    #[yaserde(rename = "AcctVldtn")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctVldtn"))]
    pub acct_vldtn: Max350Text,

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

    #[yaserde(rename = "Rgltr")]
    #[cfg_attr(feature = "serde", serde(rename = "Rgltr"))]
    pub rgltr: PartyIdentification125Choice,

    #[yaserde(rename = "Sts")]
    #[cfg_attr(feature = "serde", serde(rename = "Sts"))]
    pub sts: RestrictionStatus1Choice,

    #[yaserde(rename = "Prd")]
    #[cfg_attr(feature = "serde", serde(rename = "Prd"))]
    pub prd: DateTimePeriod2,
}

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

impl Validate for AddressType1Choice {}




#[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:acmt.001.001.08")]

pub enum AddressType1Code {
    #[yaserde(rename = "HOME")]
    #[cfg_attr(feature = "serde", serde(rename = "HOME"))]
    Home,
    #[yaserde(rename = "BIZZ")]
    #[cfg_attr(feature = "serde", serde(rename = "BIZZ"))]
    Bizz,
    __Unknown__(String),
}

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

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

impl Validate for AddressType2Choice {}




#[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:acmt.001.001.08")]

pub enum AddressType2Code {
    #[yaserde(rename = "ADDR")]
    #[cfg_attr(feature = "serde", serde(rename = "ADDR"))]
    Addr,
    #[yaserde(rename = "PBOX")]
    #[cfg_attr(feature = "serde", serde(rename = "PBOX"))]
    Pbox,
    #[yaserde(rename = "HOME")]
    #[cfg_attr(feature = "serde", serde(rename = "HOME"))]
    Home,
    #[yaserde(rename = "BIZZ")]
    #[cfg_attr(feature = "serde", serde(rename = "BIZZ"))]
    Bizz,
    #[yaserde(rename = "MLTO")]
    #[cfg_attr(feature = "serde", serde(rename = "MLTO"))]
    Mlto,
    #[yaserde(rename = "DLVY")]
    #[cfg_attr(feature = "serde", serde(rename = "DLVY"))]
    Dlvy,
    __Unknown__(String),
}

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

impl Validate for AddressType2Code {}



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

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

impl Validate for AlternateSecurityIdentification7 {}


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

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

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

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

impl Validate for BelgianIdentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct BlockedHoldingDetails2 {
    #[yaserde(rename = "BlckdHldg")]
    #[cfg_attr(feature = "serde", serde(rename = "BlckdHldg"))]
    pub blckd_hldg: Holding1Code,

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

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

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

impl Validate for BlockedReason2Choice {}




#[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:acmt.001.001.08")]

pub enum BlockedReason2Code {
    #[yaserde(rename = "BKRP")]
    #[cfg_attr(feature = "serde", serde(rename = "BKRP"))]
    Bkrp,
    #[yaserde(rename = "CMMT")]
    #[cfg_attr(feature = "serde", serde(rename = "CMMT"))]
    Cmmt,
    #[yaserde(rename = "CNFS")]
    #[cfg_attr(feature = "serde", serde(rename = "CNFS"))]
    Cnfs,
    #[yaserde(rename = "MORT")]
    #[cfg_attr(feature = "serde", serde(rename = "MORT"))]
    Mort,
    #[yaserde(rename = "PCOM")]
    #[cfg_attr(feature = "serde", serde(rename = "PCOM"))]
    Pcom,
    #[yaserde(rename = "PLDG")]
    #[cfg_attr(feature = "serde", serde(rename = "PLDG"))]
    Pldg,
    #[yaserde(rename = "TRPE")]
    #[cfg_attr(feature = "serde", serde(rename = "TRPE"))]
    Trpe,
    #[yaserde(rename = "SANC")]
    #[cfg_attr(feature = "serde", serde(rename = "SANC"))]
    Sanc,
    #[yaserde(rename = "TRAN")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAN"))]
    Tran,
    __Unknown__(String),
}

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

impl Validate for BlockedReason2Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct BlockedStatusReason2 {
    #[yaserde(rename = "TxTp")]
    #[cfg_attr(feature = "serde", serde(rename = "TxTp"))]
    pub tx_tp: TransactionType5Choice,

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

    #[yaserde(rename = "Rsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
    pub rsn: Vec<BlockedReason2Choice>,

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

impl Validate for BlockedStatusReason2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct BlockedStatusReason2Choice {
    #[yaserde(rename = "NoSpcfdRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "NoSpcfdRsn"))]
    pub no_spcfd_rsn: Option<NoReasonCode>,
    #[yaserde(rename = "Rsn")]
    #[cfg_attr(feature = "serde", serde(rename = "Rsn"))]
    pub rsn: Vec<BlockedStatusReason2>,
}

impl Validate for BlockedStatusReason2Choice {}




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

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

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

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

impl Validate for BranchData4 {}


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

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

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

impl Validate for Crsform1Choice {}




#[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:acmt.001.001.08")]

pub enum CrsformType1Code {
    #[yaserde(rename = "CER4")]
    #[cfg_attr(feature = "serde", serde(rename = "CER4"))]
    Cer4,
    #[yaserde(rename = "CER3")]
    #[cfg_attr(feature = "serde", serde(rename = "CER3"))]
    Cer3,
    #[yaserde(rename = "CER5")]
    #[cfg_attr(feature = "serde", serde(rename = "CER5"))]
    Cer5,
    #[yaserde(rename = "CER6")]
    #[cfg_attr(feature = "serde", serde(rename = "CER6"))]
    Cer6,
    #[yaserde(rename = "CER8")]
    #[cfg_attr(feature = "serde", serde(rename = "CER8"))]
    Cer8,
    #[yaserde(rename = "CER1")]
    #[cfg_attr(feature = "serde", serde(rename = "CER1"))]
    Cer1,
    #[yaserde(rename = "CER2")]
    #[cfg_attr(feature = "serde", serde(rename = "CER2"))]
    Cer2,
    #[yaserde(rename = "CER7")]
    #[cfg_attr(feature = "serde", serde(rename = "CER7"))]
    Cer7,
    __Unknown__(String),
}

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

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

impl Validate for Crssource1Choice {}




#[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:acmt.001.001.08")]

pub enum CrssourceStatus1Code {
    #[yaserde(rename = "CALC")]
    #[cfg_attr(feature = "serde", serde(rename = "CALC"))]
    Calc,
    #[yaserde(rename = "DECL")]
    #[cfg_attr(feature = "serde", serde(rename = "DECL"))]
    Decl,
    __Unknown__(String),
}

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

impl Validate for CrssourceStatus1Code {}



#[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:acmt.001.001.08")]

pub enum Crsstatus1Code {
    C101,
    C102,
    C103,
    C104,
    C105,
    C106,
    C107,
    C108,
    C109,
    C110,
    C111,
    C112,
    C113,
    C114,
    __Unknown__(String),
}

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

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

impl Validate for Crsstatus3Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct Crsstatus4 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: Crsstatus3Choice,

    #[yaserde(rename = "Src")]
    #[cfg_attr(feature = "serde", serde(rename = "Src"))]
    pub src: Crssource1Choice,

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

impl Validate for Crsstatus4 {}


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

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

impl Validate for CanadianPaymentsARNIdentifier {}
#[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:acmt.001.001.08")]

pub enum CardType1Code {
    #[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 CardType1Code {
    fn default() -> CardType1Code {
        Self::__Unknown__("No valid variants".into())
    }
}

impl Validate for CardType1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct CashAccount204 {
    #[yaserde(rename = "SttlmCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmCcy"))]
    pub sttlm_ccy: ActiveCurrencyCode,

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

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

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

    #[yaserde(rename = "AcctSvcrBrnch")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctSvcrBrnch"))]
    pub acct_svcr_brnch: BranchData4,

    #[yaserde(rename = "AcctOwnrOthrId")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctOwnrOthrId"))]
    pub acct_ownr_othr_id: Vec<GenericIdentification82>,

    #[yaserde(rename = "InvstmtAcctTp")]
    #[cfg_attr(feature = "serde", serde(rename = "InvstmtAcctTp"))]
    pub invstmt_acct_tp: AccountType2Choice,

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

    #[yaserde(rename = "SttlmInstrRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmInstrRsn"))]
    pub sttlm_instr_rsn: SettlementInstructionReason1Choice,

    #[yaserde(rename = "CshAcctPurp")]
    #[cfg_attr(feature = "serde", serde(rename = "CshAcctPurp"))]
    pub csh_acct_purp: CashAccountType3Choice,

    #[yaserde(rename = "CshAcctDsgnt")]
    #[cfg_attr(feature = "serde", serde(rename = "CshAcctDsgnt"))]
    pub csh_acct_dsgnt: AccountDesignation1Choice,

    #[yaserde(rename = "DvddPctg")]
    #[cfg_attr(feature = "serde", serde(rename = "DvddPctg"))]
    pub dvdd_pctg: PercentageBoundedRate,
}

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

impl Validate for CashAccountType3Choice {}




#[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:acmt.001.001.08")]

pub enum CashAccountType5Code {
    #[yaserde(rename = "LEND")]
    #[cfg_attr(feature = "serde", serde(rename = "LEND"))]
    Lend,
    #[yaserde(rename = "COLL")]
    #[cfg_attr(feature = "serde", serde(rename = "COLL"))]
    Coll,
    #[yaserde(rename = "SETT")]
    #[cfg_attr(feature = "serde", serde(rename = "SETT"))]
    Sett,
    #[yaserde(rename = "MARR")]
    #[cfg_attr(feature = "serde", serde(rename = "MARR"))]
    Marr,
    #[yaserde(rename = "SEGT")]
    #[cfg_attr(feature = "serde", serde(rename = "SEGT"))]
    Segt,
    __Unknown__(String),
}

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

impl Validate for CashAccountType5Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct CashSettlement3 {
    #[yaserde(rename = "CshAcctDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "CshAcctDtls"))]
    pub csh_acct_dtls: Vec<CashAccount204>,

    #[yaserde(rename = "OthrCshSttlmDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrCshSttlmDtls"))]
    pub othr_csh_sttlm_dtls: Vec<PaymentInstrument17>,
}

impl Validate for CashSettlement3 {}


#[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:acmt.001.001.08")]

pub enum CertificateType2Code {
    #[yaserde(rename = "AMLC")]
    #[cfg_attr(feature = "serde", serde(rename = "AMLC"))]
    Amlc,
    #[yaserde(rename = "DVLC")]
    #[cfg_attr(feature = "serde", serde(rename = "DVLC"))]
    Dvlc,
    #[yaserde(rename = "DFOR")]
    #[cfg_attr(feature = "serde", serde(rename = "DFOR"))]
    Dfor,
    #[yaserde(rename = "GOST")]
    #[cfg_attr(feature = "serde", serde(rename = "GOST"))]
    Gost,
    #[yaserde(rename = "IDEN")]
    #[cfg_attr(feature = "serde", serde(rename = "IDEN"))]
    Iden,
    #[yaserde(rename = "INCU")]
    #[cfg_attr(feature = "serde", serde(rename = "INCU"))]
    Incu,
    #[yaserde(rename = "LREF")]
    #[cfg_attr(feature = "serde", serde(rename = "LREF"))]
    Lref,
    #[yaserde(rename = "PASS")]
    #[cfg_attr(feature = "serde", serde(rename = "PASS"))]
    Pass,
    #[yaserde(rename = "PRAD")]
    #[cfg_attr(feature = "serde", serde(rename = "PRAD"))]
    Prad,
    #[yaserde(rename = "PKIC")]
    #[cfg_attr(feature = "serde", serde(rename = "PKIC"))]
    Pkic,
    __Unknown__(String),
}

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

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

impl Validate for CertificationType1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct Cheque4 {
    #[yaserde(rename = "PyeeId")]
    #[cfg_attr(feature = "serde", serde(rename = "PyeeId"))]
    pub pyee_id: NameAndAddress5,
}

impl Validate for Cheque4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct CitizenshipInformation2 {
    #[yaserde(rename = "Ntlty")]
    #[cfg_attr(feature = "serde", serde(rename = "Ntlty"))]
    pub ntlty: NationalityCode,

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

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

impl Validate for CivilStatus1Choice {}




#[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:acmt.001.001.08")]

pub enum CivilStatus1Code {
    #[yaserde(rename = "DIVO")]
    #[cfg_attr(feature = "serde", serde(rename = "DIVO"))]
    Divo,
    #[yaserde(rename = "LDIV")]
    #[cfg_attr(feature = "serde", serde(rename = "LDIV"))]
    Ldiv,
    #[yaserde(rename = "MARR")]
    #[cfg_attr(feature = "serde", serde(rename = "MARR"))]
    Marr,
    #[yaserde(rename = "SEPA")]
    #[cfg_attr(feature = "serde", serde(rename = "SEPA"))]
    Sepa,
    #[yaserde(rename = "SING")]
    #[cfg_attr(feature = "serde", serde(rename = "SING"))]
    Sing,
    #[yaserde(rename = "UNIO")]
    #[cfg_attr(feature = "serde", serde(rename = "UNIO"))]
    Unio,
    #[yaserde(rename = "WIDO")]
    #[cfg_attr(feature = "serde", serde(rename = "WIDO"))]
    Wido,
    __Unknown__(String),
}

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

impl Validate for CivilStatus1Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct ClearingSystemMemberIdentification4Choice {
    #[yaserde(rename = "USCHU")]
    #[cfg_attr(feature = "serde", serde(rename = "USCHU"))]
    pub uschu: Option<ChipsuniversalIdentifier>,
    #[yaserde(rename = "NZNCC")]
    #[cfg_attr(feature = "serde", serde(rename = "NZNCC"))]
    pub nzncc: Option<NewZealandNCCIdentifier>,
    #[yaserde(rename = "IENSC")]
    #[cfg_attr(feature = "serde", serde(rename = "IENSC"))]
    pub iensc: Option<IrishNSCIdentifier>,
    #[yaserde(rename = "GBSC")]
    #[cfg_attr(feature = "serde", serde(rename = "GBSC"))]
    pub gbsc: Option<UkdomesticSortCodeIdentifier>,
    #[yaserde(rename = "USCH")]
    #[cfg_attr(feature = "serde", serde(rename = "USCH"))]
    pub usch: Option<ChipsparticipantIdentifier>,
    #[yaserde(rename = "CHBC")]
    #[cfg_attr(feature = "serde", serde(rename = "CHBC"))]
    pub chbc: Option<SwissBCIdentifier>,
    #[yaserde(rename = "USFW")]
    #[cfg_attr(feature = "serde", serde(rename = "USFW"))]
    pub usfw: Option<FedwireRoutingNumberIdentifier>,
    #[yaserde(rename = "PTNCC")]
    #[cfg_attr(feature = "serde", serde(rename = "PTNCC"))]
    pub ptncc: Option<PortugueseNCCIdentifier>,
    #[yaserde(rename = "RUCB")]
    #[cfg_attr(feature = "serde", serde(rename = "RUCB"))]
    pub rucb: Option<RussianCentralBankIdentificationCodeIdentifier>,
    #[yaserde(rename = "ITNCC")]
    #[cfg_attr(feature = "serde", serde(rename = "ITNCC"))]
    pub itncc: Option<ItalianDomesticIdentifier>,
    #[yaserde(rename = "ATBLZ")]
    #[cfg_attr(feature = "serde", serde(rename = "ATBLZ"))]
    pub atblz: Option<AustrianBankleitzahlIdentifier>,
    #[yaserde(rename = "CACPA")]
    #[cfg_attr(feature = "serde", serde(rename = "CACPA"))]
    pub cacpa: Option<CanadianPaymentsARNIdentifier>,
    #[yaserde(rename = "CHSIC")]
    #[cfg_attr(feature = "serde", serde(rename = "CHSIC"))]
    pub chsic: Option<SwissSICIdentifier>,
    #[yaserde(rename = "DEBLZ")]
    #[cfg_attr(feature = "serde", serde(rename = "DEBLZ"))]
    pub deblz: Option<GermanBankleitzahlIdentifier>,
    #[yaserde(rename = "ESNCC")]
    #[cfg_attr(feature = "serde", serde(rename = "ESNCC"))]
    pub esncc: Option<SpanishDomesticInterbankingIdentifier>,
    #[yaserde(rename = "ZANCC")]
    #[cfg_attr(feature = "serde", serde(rename = "ZANCC"))]
    pub zancc: Option<SouthAfricanNCCIdentifier>,
    #[yaserde(rename = "HKNCC")]
    #[cfg_attr(feature = "serde", serde(rename = "HKNCC"))]
    pub hkncc: Option<HongKongBankIdentifier>,
    #[yaserde(rename = "AUBSBx")]
    #[cfg_attr(feature = "serde", serde(rename = "AUBSBx"))]
    pub aubsbx: Option<ExtensiveBranchNetworkIdentifier>,
    #[yaserde(rename = "AUBSBs")]
    #[cfg_attr(feature = "serde", serde(rename = "AUBSBs"))]
    pub aubsbs: Option<SmallNetworkIdentifier>,
}

impl Validate for ClearingSystemMemberIdentification4Choice {}




#[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:acmt.001.001.08")]

pub enum Collateral1Code {
    #[yaserde(rename = "COLL")]
    #[cfg_attr(feature = "serde", serde(rename = "COLL"))]
    Coll,
    #[yaserde(rename = "NCOL")]
    #[cfg_attr(feature = "serde", serde(rename = "NCOL"))]
    Ncol,
    __Unknown__(String),
}

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

impl Validate for Collateral1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct CommunicationAddress6 {
    #[yaserde(rename = "AdrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "AdrTp"))]
    pub adr_tp: AddressType1Choice,

    #[yaserde(rename = "Email")]
    #[cfg_attr(feature = "serde", serde(rename = "Email"))]
    pub email: Max256Text,

    #[yaserde(rename = "Phne")]
    #[cfg_attr(feature = "serde", serde(rename = "Phne"))]
    pub phne: PhoneNumber,

    #[yaserde(rename = "Mob")]
    #[cfg_attr(feature = "serde", serde(rename = "Mob"))]
    pub mob: PhoneNumber,

    #[yaserde(rename = "FaxNb")]
    #[cfg_attr(feature = "serde", serde(rename = "FaxNb"))]
    pub fax_nb: PhoneNumber,

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

    #[yaserde(rename = "URLAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "URLAdr"))]
    pub url_adr: Max256Text,
}

impl Validate for CommunicationAddress6 {}


#[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:acmt.001.001.08")]

pub enum CommunicationMethod1Code {
    #[yaserde(rename = "SWMT")]
    #[cfg_attr(feature = "serde", serde(rename = "SWMT"))]
    Swmt,
    #[yaserde(rename = "SWMX")]
    #[cfg_attr(feature = "serde", serde(rename = "SWMX"))]
    Swmx,
    #[yaserde(rename = "FAXI")]
    #[cfg_attr(feature = "serde", serde(rename = "FAXI"))]
    Faxi,
    #[yaserde(rename = "EMAL")]
    #[cfg_attr(feature = "serde", serde(rename = "EMAL"))]
    Emal,
    #[yaserde(rename = "PROP")]
    #[cfg_attr(feature = "serde", serde(rename = "PROP"))]
    Prop,
    __Unknown__(String),
}

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

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

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

impl Validate for CompanyLink1Choice {}




#[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:acmt.001.001.08")]

pub enum CompanyLink1Code {
    #[yaserde(rename = "AGEN")]
    #[cfg_attr(feature = "serde", serde(rename = "AGEN"))]
    Agen,
    #[yaserde(rename = "BROK")]
    #[cfg_attr(feature = "serde", serde(rename = "BROK"))]
    Brok,
    #[yaserde(rename = "PART")]
    #[cfg_attr(feature = "serde", serde(rename = "PART"))]
    Part,
    #[yaserde(rename = "MEMB")]
    #[cfg_attr(feature = "serde", serde(rename = "MEMB"))]
    Memb,
    #[yaserde(rename = "PCOM")]
    #[cfg_attr(feature = "serde", serde(rename = "PCOM"))]
    Pcom,
    #[yaserde(rename = "RELA")]
    #[cfg_attr(feature = "serde", serde(rename = "RELA"))]
    Rela,
    __Unknown__(String),
}

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

impl Validate for CompanyLink1Code {}



#[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:acmt.001.001.08")]

pub enum ConductClassification1Code {
    #[yaserde(rename = "NSTA")]
    #[cfg_attr(feature = "serde", serde(rename = "NSTA"))]
    Nsta,
    #[yaserde(rename = "RCLT")]
    #[cfg_attr(feature = "serde", serde(rename = "RCLT"))]
    Rclt,
    #[yaserde(rename = "STAN")]
    #[cfg_attr(feature = "serde", serde(rename = "STAN"))]
    Stan,
    __Unknown__(String),
}

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

impl Validate for ConductClassification1Code {}



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

impl Validate for ConsolidatedTapeAssociationIdentifier {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 35 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 35 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct ConsolidationType1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<ConsolidationType1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for ConsolidationType1Choice {}




#[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:acmt.001.001.08")]

pub enum ConsolidationType1Code {
    #[yaserde(rename = "GENL")]
    #[cfg_attr(feature = "serde", serde(rename = "GENL"))]
    Genl,
    #[yaserde(rename = "PART")]
    #[cfg_attr(feature = "serde", serde(rename = "PART"))]
    Part,
    __Unknown__(String),
}

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

impl Validate for ConsolidationType1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct CountryAndResidentialStatusType2 {
    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: CountryCode,

    #[yaserde(rename = "ResdtlSts")]
    #[cfg_attr(feature = "serde", serde(rename = "ResdtlSts"))]
    pub resdtl_sts: ResidentialStatus1Code,
}

impl Validate for CountryAndResidentialStatusType2 {}


#[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:acmt.001.001.08")]

pub enum CreditDebit3Code {
    #[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 CreditDebit3Code {
    fn default() -> CreditDebit3Code {
        Self::__Unknown__("No valid variants".into())
    }
}

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

impl Validate for CustomerConductClassification1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct DataBaseCheck1 {
    #[yaserde(rename = "DBChck")]
    #[cfg_attr(feature = "serde", serde(rename = "DBChck"))]
    pub db_chck: YesNoIndicator,

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

impl Validate for DataBaseCheck1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct DateAndAmount1 {
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Isodate,

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

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




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct DateTimePeriod2 {
    #[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 DateTimePeriod2 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct DeMinimus1Choice {
    #[yaserde(rename = "DeMnmsAplbl")]
    #[cfg_attr(feature = "serde", serde(rename = "DeMnmsAplbl"))]
    pub de_mnms_aplbl: Option<DeMinimusApplicable1>,
    #[yaserde(rename = "DeMnmsNotAplbl")]
    #[cfg_attr(feature = "serde", serde(rename = "DeMnmsNotAplbl"))]
    pub de_mnms_not_aplbl: Option<DeMinimusNotApplicable1>,
}

impl Validate for DeMinimus1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct DeMinimusApplicable1 {
    #[yaserde(rename = "NewIssePrmssn")]
    #[cfg_attr(feature = "serde", serde(rename = "NewIssePrmssn"))]
    pub new_isse_prmssn: YesNoIndicator,

    #[yaserde(rename = "Pctg")]
    #[cfg_attr(feature = "serde", serde(rename = "Pctg"))]
    pub pctg: PercentageRate,
}

impl Validate for DeMinimusApplicable1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct DeMinimusNotApplicable1 {
    #[yaserde(rename = "RstrctdPrsnRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "RstrctdPrsnRsn"))]
    pub rstrctd_prsn_rsn: Max350Text,
}

impl Validate for DeMinimusNotApplicable1 {}


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

impl Validate for DecimalNumber {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct DirectDebitMandate7 {
    #[yaserde(rename = "DbtrAcct")]
    #[cfg_attr(feature = "serde", serde(rename = "DbtrAcct"))]
    pub dbtr_acct: AccountIdentificationAndName5,

    #[yaserde(rename = "Dbtr")]
    #[cfg_attr(feature = "serde", serde(rename = "Dbtr"))]
    pub dbtr: PartyIdentification125Choice,

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

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

    #[yaserde(rename = "Cdtr")]
    #[cfg_attr(feature = "serde", serde(rename = "Cdtr"))]
    pub cdtr: PartyIdentification125Choice,

    #[yaserde(rename = "DbtrAgt")]
    #[cfg_attr(feature = "serde", serde(rename = "DbtrAgt"))]
    pub dbtr_agt: FinancialInstitutionIdentification11Choice,

    #[yaserde(rename = "DbtrAgtBrnch")]
    #[cfg_attr(feature = "serde", serde(rename = "DbtrAgtBrnch"))]
    pub dbtr_agt_brnch: BranchData4,

    #[yaserde(rename = "CdtrAgt")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtrAgt"))]
    pub cdtr_agt: FinancialInstitutionIdentification11Choice,

    #[yaserde(rename = "CdtrAgtBrnch")]
    #[cfg_attr(feature = "serde", serde(rename = "CdtrAgtBrnch"))]
    pub cdtr_agt_brnch: BranchData4,

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

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

impl Validate for DirectDebitMandate7 {}


#[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:acmt.001.001.08")]

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:acmt.001.001.08")]
pub struct Document {
    #[yaserde(rename = "AcctOpngInstr")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctOpngInstr"))]
    pub acct_opng_instr: AccountOpeningInstructionV08,
}

impl Validate for Document {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct DocumentToSend4 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: Max140Text,

    #[yaserde(rename = "Rcpt")]
    #[cfg_attr(feature = "serde", serde(rename = "Rcpt"))]
    pub rcpt: PartyIdentification125Choice,

    #[yaserde(rename = "MtdOfTrnsmssn")]
    #[cfg_attr(feature = "serde", serde(rename = "MtdOfTrnsmssn"))]
    pub mtd_of_trnsmssn: CommunicationMethod3Choice,
}

impl Validate for DocumentToSend4 {}


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

impl Validate for DutchIdentifier {}
#[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:acmt.001.001.08")]

pub enum Eligible1Code {
    #[yaserde(rename = "ELIG")]
    #[cfg_attr(feature = "serde", serde(rename = "ELIG"))]
    Elig,
    #[yaserde(rename = "NELI")]
    #[cfg_attr(feature = "serde", serde(rename = "NELI"))]
    Neli,
    __Unknown__(String),
}

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

impl Validate for Eligible1Code {}



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

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

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

pub enum EventFrequency10Code {
    #[yaserde(rename = "DAIL")]
    #[cfg_attr(feature = "serde", serde(rename = "DAIL"))]
    Dail,
    #[yaserde(rename = "ADHO")]
    #[cfg_attr(feature = "serde", serde(rename = "ADHO"))]
    Adho,
    __Unknown__(String),
}

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

impl Validate for EventFrequency10Code {}



#[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:acmt.001.001.08")]

pub enum EventFrequency1Code {
    #[yaserde(rename = "YEAR")]
    #[cfg_attr(feature = "serde", serde(rename = "YEAR"))]
    Year,
    #[yaserde(rename = "SEMI")]
    #[cfg_attr(feature = "serde", serde(rename = "SEMI"))]
    Semi,
    #[yaserde(rename = "QUTR")]
    #[cfg_attr(feature = "serde", serde(rename = "QUTR"))]
    Qutr,
    #[yaserde(rename = "TOMN")]
    #[cfg_attr(feature = "serde", serde(rename = "TOMN"))]
    Tomn,
    #[yaserde(rename = "MNTH")]
    #[cfg_attr(feature = "serde", serde(rename = "MNTH"))]
    Mnth,
    #[yaserde(rename = "TWMN")]
    #[cfg_attr(feature = "serde", serde(rename = "TWMN"))]
    Twmn,
    #[yaserde(rename = "TOWK")]
    #[cfg_attr(feature = "serde", serde(rename = "TOWK"))]
    Towk,
    #[yaserde(rename = "WEEK")]
    #[cfg_attr(feature = "serde", serde(rename = "WEEK"))]
    Week,
    #[yaserde(rename = "DAIL")]
    #[cfg_attr(feature = "serde", serde(rename = "DAIL"))]
    Dail,
    #[yaserde(rename = "ADHO")]
    #[cfg_attr(feature = "serde", serde(rename = "ADHO"))]
    Adho,
    #[yaserde(rename = "INDA")]
    #[cfg_attr(feature = "serde", serde(rename = "INDA"))]
    Inda,
    #[yaserde(rename = "OVNG")]
    #[cfg_attr(feature = "serde", serde(rename = "OVNG"))]
    Ovng,
    #[yaserde(rename = "ONDE")]
    #[cfg_attr(feature = "serde", serde(rename = "ONDE"))]
    Onde,
    __Unknown__(String),
}

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

impl Validate for EventFrequency1Code {}



#[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:acmt.001.001.08")]

pub enum EventFrequency8Code {
    #[yaserde(rename = "ADHO")]
    #[cfg_attr(feature = "serde", serde(rename = "ADHO"))]
    Adho,
    #[yaserde(rename = "YEAR")]
    #[cfg_attr(feature = "serde", serde(rename = "YEAR"))]
    Year,
    #[yaserde(rename = "DAIL")]
    #[cfg_attr(feature = "serde", serde(rename = "DAIL"))]
    Dail,
    #[yaserde(rename = "FOMN")]
    #[cfg_attr(feature = "serde", serde(rename = "FOMN"))]
    Fomn,
    #[yaserde(rename = "TOMN")]
    #[cfg_attr(feature = "serde", serde(rename = "TOMN"))]
    Tomn,
    #[yaserde(rename = "TOWK")]
    #[cfg_attr(feature = "serde", serde(rename = "TOWK"))]
    Towk,
    #[yaserde(rename = "TYEA")]
    #[cfg_attr(feature = "serde", serde(rename = "TYEA"))]
    Tyea,
    #[yaserde(rename = "INDA")]
    #[cfg_attr(feature = "serde", serde(rename = "INDA"))]
    Inda,
    #[yaserde(rename = "MNTH")]
    #[cfg_attr(feature = "serde", serde(rename = "MNTH"))]
    Mnth,
    #[yaserde(rename = "ONDE")]
    #[cfg_attr(feature = "serde", serde(rename = "ONDE"))]
    Onde,
    #[yaserde(rename = "OVNG")]
    #[cfg_attr(feature = "serde", serde(rename = "OVNG"))]
    Ovng,
    #[yaserde(rename = "QUTR")]
    #[cfg_attr(feature = "serde", serde(rename = "QUTR"))]
    Qutr,
    #[yaserde(rename = "SEMI")]
    #[cfg_attr(feature = "serde", serde(rename = "SEMI"))]
    Semi,
    #[yaserde(rename = "TWMN")]
    #[cfg_attr(feature = "serde", serde(rename = "TWMN"))]
    Twmn,
    #[yaserde(rename = "WEEK")]
    #[cfg_attr(feature = "serde", serde(rename = "WEEK"))]
    Week,
    __Unknown__(String),
}

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

impl Validate for EventFrequency8Code {}



#[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:acmt.001.001.08")]

pub enum EventFrequency9Code {
    #[yaserde(rename = "YEAR")]
    #[cfg_attr(feature = "serde", serde(rename = "YEAR"))]
    Year,
    #[yaserde(rename = "SEMI")]
    #[cfg_attr(feature = "serde", serde(rename = "SEMI"))]
    Semi,
    #[yaserde(rename = "QUTR")]
    #[cfg_attr(feature = "serde", serde(rename = "QUTR"))]
    Qutr,
    #[yaserde(rename = "TOMN")]
    #[cfg_attr(feature = "serde", serde(rename = "TOMN"))]
    Tomn,
    #[yaserde(rename = "MNTH")]
    #[cfg_attr(feature = "serde", serde(rename = "MNTH"))]
    Mnth,
    #[yaserde(rename = "TWMN")]
    #[cfg_attr(feature = "serde", serde(rename = "TWMN"))]
    Twmn,
    #[yaserde(rename = "TOWK")]
    #[cfg_attr(feature = "serde", serde(rename = "TOWK"))]
    Towk,
    #[yaserde(rename = "WEEK")]
    #[cfg_attr(feature = "serde", serde(rename = "WEEK"))]
    Week,
    #[yaserde(rename = "DAIL")]
    #[cfg_attr(feature = "serde", serde(rename = "DAIL"))]
    Dail,
    #[yaserde(rename = "ADHO")]
    #[cfg_attr(feature = "serde", serde(rename = "ADHO"))]
    Adho,
    #[yaserde(rename = "INDA")]
    #[cfg_attr(feature = "serde", serde(rename = "INDA"))]
    Inda,
    #[yaserde(rename = "OVNG")]
    #[cfg_attr(feature = "serde", serde(rename = "OVNG"))]
    Ovng,
    #[yaserde(rename = "ONDE")]
    #[cfg_attr(feature = "serde", serde(rename = "ONDE"))]
    Onde,
    #[yaserde(rename = "NONE")]
    #[cfg_attr(feature = "serde", serde(rename = "NONE"))]
    None,
    __Unknown__(String),
}

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

impl Validate for EventFrequency9Code {}



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

impl Validate for Extended350Code {
    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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct ExtendedParty14 {
    #[yaserde(rename = "XtndedPtyRole")]
    #[cfg_attr(feature = "serde", serde(rename = "XtndedPtyRole"))]
    pub xtnded_pty_role: Extended350Code,

    #[yaserde(rename = "OthrPtyDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrPtyDtls"))]
    pub othr_pty_dtls: InvestmentAccountOwnershipInformation16,
}

impl Validate for ExtendedParty14 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct Extension1 {
    #[yaserde(rename = "PlcAndNm")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcAndNm"))]
    pub plc_and_nm: Max350Text,

    #[yaserde(rename = "Txt")]
    #[cfg_attr(feature = "serde", serde(rename = "Txt"))]
    pub txt: Max350Text,
}

impl Validate for Extension1 {}


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

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

impl Validate for ExternalAccountIdentification1Code {
    fn validate(&self) -> Result<(), String> { 
        #[allow(clippy::len_zero)]
        if self.0.len() < 1 {
            return Err(format!("MinLength validation error. \nExpected: 0 length >= 1 \nActual: 0 length == {}", self.0.len()));
        }
        if self.0.len() > 4 {
            return Err(format!("MaxLength validation error. \nExpected: 0 length <= 4 \nActual: 0 length == {}", self.0.len()));
        }
        Ok(())
    }
}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct Fatcaform1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<FatcaformType1Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for Fatcaform1Choice {}




#[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:acmt.001.001.08")]

pub enum FatcaformType1Code {
    #[yaserde(rename = "CER5")]
    #[cfg_attr(feature = "serde", serde(rename = "CER5"))]
    Cer5,
    #[yaserde(rename = "CER7")]
    #[cfg_attr(feature = "serde", serde(rename = "CER7"))]
    Cer7,
    #[yaserde(rename = "CER1")]
    #[cfg_attr(feature = "serde", serde(rename = "CER1"))]
    Cer1,
    #[yaserde(rename = "CER2")]
    #[cfg_attr(feature = "serde", serde(rename = "CER2"))]
    Cer2,
    #[yaserde(rename = "CER3")]
    #[cfg_attr(feature = "serde", serde(rename = "CER3"))]
    Cer3,
    #[yaserde(rename = "CER4")]
    #[cfg_attr(feature = "serde", serde(rename = "CER4"))]
    Cer4,
    #[yaserde(rename = "CER6")]
    #[cfg_attr(feature = "serde", serde(rename = "CER6"))]
    Cer6,
    __Unknown__(String),
}

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

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

impl Validate for Fatcasource1Choice {}




#[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:acmt.001.001.08")]

pub enum FatcasourceStatus1Code {
    #[yaserde(rename = "CALC")]
    #[cfg_attr(feature = "serde", serde(rename = "CALC"))]
    Calc,
    #[yaserde(rename = "DECL")]
    #[cfg_attr(feature = "serde", serde(rename = "DECL"))]
    Decl,
    __Unknown__(String),
}

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

impl Validate for FatcasourceStatus1Code {}



#[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:acmt.001.001.08")]

pub enum Fatcastatus1Code {
    F101,
    F102,
    F103,
    F104,
    F105,
    F201,
    F202,
    F203,
    F204,
    F205,
    F206,
    __Unknown__(String),
}

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

impl Validate for Fatcastatus1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct Fatcastatus2 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: Fatcastatus2Choice,

    #[yaserde(rename = "Src")]
    #[cfg_attr(feature = "serde", serde(rename = "Src"))]
    pub src: Fatcasource1Choice,
}

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

impl Validate for Fatcastatus2Choice {}




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

impl Validate for FedwireRoutingNumberIdentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct FinancialInstitutionIdentification11Choice {
    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: Option<NameAndAddress5>,
    #[yaserde(rename = "BICFI")]
    #[cfg_attr(feature = "serde", serde(rename = "BICFI"))]
    pub bicfi: Option<Bicfidec2014Identifier>,
    #[yaserde(rename = "ClrSysMmbId")]
    #[cfg_attr(feature = "serde", serde(rename = "ClrSysMmbId"))]
    pub clr_sys_mmb_id: Option<ClearingSystemMemberIdentification4Choice>,
    #[yaserde(rename = "PrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryId"))]
    pub prtry_id: Option<SimpleIdentificationInformation4>,
}

impl Validate for FinancialInstitutionIdentification11Choice {}




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

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

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

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

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

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

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

    #[yaserde(rename = "PdctGrp")]
    #[cfg_attr(feature = "serde", serde(rename = "PdctGrp"))]
    pub pdct_grp: Max140Text,

    #[yaserde(rename = "BlckdHldgDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "BlckdHldgDtls"))]
    pub blckd_hldg_dtls: BlockedHoldingDetails2,

    #[yaserde(rename = "Pldgg")]
    #[cfg_attr(feature = "serde", serde(rename = "Pldgg"))]
    pub pldgg: Eligible1Code,

    #[yaserde(rename = "Coll")]
    #[cfg_attr(feature = "serde", serde(rename = "Coll"))]
    pub coll: Collateral1Code,

    #[yaserde(rename = "ThrdPtyRghts")]
    #[cfg_attr(feature = "serde", serde(rename = "ThrdPtyRghts"))]
    pub thrd_pty_rghts: ThirdPartyRights2,

    #[yaserde(rename = "FndOwnrsh")]
    #[cfg_attr(feature = "serde", serde(rename = "FndOwnrsh"))]
    pub fnd_ownrsh: FundOwnership1Code,

    #[yaserde(rename = "FndIntntn")]
    #[cfg_attr(feature = "serde", serde(rename = "FndIntntn"))]
    pub fnd_intntn: FundIntention1Code,

    #[yaserde(rename = "OprlSts")]
    #[cfg_attr(feature = "serde", serde(rename = "OprlSts"))]
    pub oprl_sts: OperationalStatus1Code,
}

impl Validate for FinancialInstrument87 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct FiscalYear1Choice {
    #[yaserde(rename = "StartDt")]
    #[cfg_attr(feature = "serde", serde(rename = "StartDt"))]
    pub start_dt: Option<Isodate>,
    #[yaserde(rename = "EndDt")]
    #[cfg_attr(feature = "serde", serde(rename = "EndDt"))]
    pub end_dt: Option<Isodate>,
}

impl Validate for FiscalYear1Choice {}




#[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:acmt.001.001.08")]

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:acmt.001.001.08")]
pub struct Frequency20Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<EventFrequency8Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for Frequency20Choice {}




#[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:acmt.001.001.08")]

pub enum FundCashAccount4Code {
    #[yaserde(rename = "HEDG")]
    #[cfg_attr(feature = "serde", serde(rename = "HEDG"))]
    Hedg,
    #[yaserde(rename = "CPFO")]
    #[cfg_attr(feature = "serde", serde(rename = "CPFO"))]
    Cpfo,
    #[yaserde(rename = "CPFS")]
    #[cfg_attr(feature = "serde", serde(rename = "CPFS"))]
    Cpfs,
    #[yaserde(rename = "SRSA")]
    #[cfg_attr(feature = "serde", serde(rename = "SRSA"))]
    Srsa,
    #[yaserde(rename = "CSDO")]
    #[cfg_attr(feature = "serde", serde(rename = "CSDO"))]
    Csdo,
    #[yaserde(rename = "TOFF")]
    #[cfg_attr(feature = "serde", serde(rename = "TOFF"))]
    Toff,
    #[yaserde(rename = "ICSA")]
    #[cfg_attr(feature = "serde", serde(rename = "ICSA"))]
    Icsa,
    #[yaserde(rename = "CSDM")]
    #[cfg_attr(feature = "serde", serde(rename = "CSDM"))]
    Csdm,
    #[yaserde(rename = "CSDP")]
    #[cfg_attr(feature = "serde", serde(rename = "CSDP"))]
    Csdp,
    #[yaserde(rename = "PPEN")]
    #[cfg_attr(feature = "serde", serde(rename = "PPEN"))]
    Ppen,
    #[yaserde(rename = "CPEN")]
    #[cfg_attr(feature = "serde", serde(rename = "CPEN"))]
    Cpen,
    __Unknown__(String),
}

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

impl Validate for FundCashAccount4Code {}



#[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:acmt.001.001.08")]

pub enum FundIntention1Code {
    #[yaserde(rename = "YQUA")]
    #[cfg_attr(feature = "serde", serde(rename = "YQUA"))]
    Yqua,
    #[yaserde(rename = "NQUA")]
    #[cfg_attr(feature = "serde", serde(rename = "NQUA"))]
    Nqua,
    __Unknown__(String),
}

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

impl Validate for FundIntention1Code {}



#[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:acmt.001.001.08")]

pub enum FundOwnership1Code {
    #[yaserde(rename = "YALL")]
    #[cfg_attr(feature = "serde", serde(rename = "YALL"))]
    Yall,
    #[yaserde(rename = "NALL")]
    #[cfg_attr(feature = "serde", serde(rename = "NALL"))]
    Nall,
    __Unknown__(String),
}

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

impl Validate for FundOwnership1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct Gdprdata1 {
    #[yaserde(rename = "CnsntTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CnsntTp"))]
    pub cnsnt_tp: GdprdataConsent1Choice,

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

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

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

impl Validate for GdprdataConsent1Choice {}




#[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:acmt.001.001.08")]

pub enum GdprdataConsent1Code {
    #[yaserde(rename = "DP00")]
    #[cfg_attr(feature = "serde", serde(rename = "DP00"))]
    Dp00,
    #[yaserde(rename = "DP03")]
    #[cfg_attr(feature = "serde", serde(rename = "DP03"))]
    Dp03,
    #[yaserde(rename = "DP01")]
    #[cfg_attr(feature = "serde", serde(rename = "DP01"))]
    Dp01,
    #[yaserde(rename = "DP02")]
    #[cfg_attr(feature = "serde", serde(rename = "DP02"))]
    Dp02,
    __Unknown__(String),
}

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

impl Validate for GdprdataConsent1Code {}



#[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:acmt.001.001.08")]

pub enum Gender1Code {
    #[yaserde(rename = "FEMA")]
    #[cfg_attr(feature = "serde", serde(rename = "FEMA"))]
    Fema,
    #[yaserde(rename = "MALE")]
    #[cfg_attr(feature = "serde", serde(rename = "MALE"))]
    Male,
    __Unknown__(String),
}

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

impl Validate for Gender1Code {}



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

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

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

impl Validate for GenericAccountIdentification1 {}


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

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

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

impl Validate for GenericIdentification1 {}


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

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

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

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

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

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

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

impl Validate for GenericIdentification82 {}


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

impl Validate for GermanBankleitzahlIdentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct HighFrequencyTradingProfile1 {
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Isodate,

    #[yaserde(rename = "SttlmFrqcy")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmFrqcy"))]
    pub sttlm_frqcy: SettlementFrequency1Choice,

    #[yaserde(rename = "CnsldtnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CnsldtnTp"))]
    pub cnsldtn_tp: ConsolidationType1Choice,
}

impl Validate for HighFrequencyTradingProfile1 {}


#[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:acmt.001.001.08")]

pub enum Holding1Code {
    #[yaserde(rename = "CERT")]
    #[cfg_attr(feature = "serde", serde(rename = "CERT"))]
    Cert,
    #[yaserde(rename = "NPRH")]
    #[cfg_attr(feature = "serde", serde(rename = "NPRH"))]
    Nprh,
    #[yaserde(rename = "PRTH")]
    #[cfg_attr(feature = "serde", serde(rename = "PRTH"))]
    Prth,
    __Unknown__(String),
}

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

impl Validate for Holding1Code {}



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

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

impl Validate for Iban2007Identifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct 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)]
pub struct IsoyearMonth (pub String);
crate::simple_type!(IsoyearMonth);

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

impl Validate for IdentificationSource1Choice {}




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

pub enum IncomePreference2Code {
    #[yaserde(rename = "CASH")]
    #[cfg_attr(feature = "serde", serde(rename = "CASH"))]
    Cash,
    #[yaserde(rename = "SECU")]
    #[cfg_attr(feature = "serde", serde(rename = "SECU"))]
    Secu,
    __Unknown__(String),
}

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

impl Validate for IncomePreference2Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct IndividualPerson29 {
    #[yaserde(rename = "NmPrfx")]
    #[cfg_attr(feature = "serde", serde(rename = "NmPrfx"))]
    pub nm_prfx: NamePrefix1Choice,

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

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

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

    #[yaserde(rename = "PstlAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "PstlAdr"))]
    pub pstl_adr: Vec<PostalAddress21>,
}

impl Validate for IndividualPerson29 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct IndividualPerson37 {
    #[yaserde(rename = "NmPrfx")]
    #[cfg_attr(feature = "serde", serde(rename = "NmPrfx"))]
    pub nm_prfx: NamePrefix1Choice,

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

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

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

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

    #[yaserde(rename = "Gndr")]
    #[cfg_attr(feature = "serde", serde(rename = "Gndr"))]
    pub gndr: Gender1Code,

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

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

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

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

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

    #[yaserde(rename = "PstlAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "PstlAdr"))]
    pub pstl_adr: Vec<PostalAddress21>,

    #[yaserde(rename = "Ctznsh")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctznsh"))]
    pub ctznsh: Vec<CitizenshipInformation2>,

    #[yaserde(rename = "EmplngCpny")]
    #[cfg_attr(feature = "serde", serde(rename = "EmplngCpny"))]
    pub emplng_cpny: Max140Text,

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

    #[yaserde(rename = "PltclyXpsdPrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "PltclyXpsdPrsn"))]
    pub pltcly_xpsd_prsn: PoliticallyExposedPerson1,

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

    #[yaserde(rename = "CvlSts")]
    #[cfg_attr(feature = "serde", serde(rename = "CvlSts"))]
    pub cvl_sts: CivilStatus1Choice,

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

    #[yaserde(rename = "FmlyInf")]
    #[cfg_attr(feature = "serde", serde(rename = "FmlyInf"))]
    pub fmly_inf: PersonalInformation1,

    #[yaserde(rename = "GDPRData")]
    #[cfg_attr(feature = "serde", serde(rename = "GDPRData"))]
    pub gdpr_data: Vec<Gdprdata1>,
}

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

impl Validate for InformationDistribution1Choice {}




#[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:acmt.001.001.08")]

pub enum InformationDistribution2Code {
    #[yaserde(rename = "ELEC")]
    #[cfg_attr(feature = "serde", serde(rename = "ELEC"))]
    Elec,
    #[yaserde(rename = "NONE")]
    #[cfg_attr(feature = "serde", serde(rename = "NONE"))]
    None,
    #[yaserde(rename = "PAPR")]
    #[cfg_attr(feature = "serde", serde(rename = "PAPR"))]
    Papr,
    __Unknown__(String),
}

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

impl Validate for InformationDistribution2Code {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct InitialAmount1Choice {
    #[yaserde(rename = "InitlNbOfInstlmts")]
    #[cfg_attr(feature = "serde", serde(rename = "InitlNbOfInstlmts"))]
    pub initl_nb_of_instlmts: Option<Number>,
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<ActiveCurrencyAndAmount>,
}

impl Validate for InitialAmount1Choice {}




#[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:acmt.001.001.08")]

pub enum Insurance1Code {
    #[yaserde(rename = "LIFE")]
    #[cfg_attr(feature = "serde", serde(rename = "LIFE"))]
    Life,
    #[yaserde(rename = "PDIS")]
    #[cfg_attr(feature = "serde", serde(rename = "PDIS"))]
    Pdis,
    __Unknown__(String),
}

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

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

impl Validate for InsuranceType2Choice {}




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

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

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

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

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

    #[yaserde(rename = "PmryComAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "PmryComAdr"))]
    pub pmry_com_adr: Vec<CommunicationAddress6>,

    #[yaserde(rename = "ScndryComAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "ScndryComAdr"))]
    pub scndry_com_adr: Vec<CommunicationAddress6>,

    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: NameAndAddress4,
}

impl Validate for Intermediary46 {}


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

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

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

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

    #[yaserde(rename = "OwnrshTp")]
    #[cfg_attr(feature = "serde", serde(rename = "OwnrshTp"))]
    pub ownrsh_tp: OwnershipType2Choice,

    #[yaserde(rename = "TaxXmptn")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxXmptn"))]
    pub tax_xmptn: TaxExemptionReason2Choice,

    #[yaserde(rename = "StmtFrqcy")]
    #[cfg_attr(feature = "serde", serde(rename = "StmtFrqcy"))]
    pub stmt_frqcy: StatementFrequencyReason2Choice,

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

    #[yaserde(rename = "Lang")]
    #[cfg_attr(feature = "serde", serde(rename = "Lang"))]
    pub lang: LanguageCode,

    #[yaserde(rename = "IncmPref")]
    #[cfg_attr(feature = "serde", serde(rename = "IncmPref"))]
    pub incm_pref: IncomePreference2Code,

    #[yaserde(rename = "RinvstmtDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "RinvstmtDtls"))]
    pub rinvstmt_dtls: Vec<Reinvestment4>,

    #[yaserde(rename = "TaxWhldgMtd")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxWhldgMtd"))]
    pub tax_whldg_mtd: TaxWithholdingMethod3Code,

    #[yaserde(rename = "TaxRptg")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxRptg"))]
    pub tax_rptg: Vec<TaxReporting3>,

    #[yaserde(rename = "LttrInttDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "LttrInttDtls"))]
    pub lttr_intt_dtls: LetterIntent1,

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

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

    #[yaserde(rename = "FndFmlyNm")]
    #[cfg_attr(feature = "serde", serde(rename = "FndFmlyNm"))]
    pub fnd_fmly_nm: Max350Text,

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

    #[yaserde(rename = "RndgDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "RndgDtls"))]
    pub rndg_dtls: RoundingParameters1,

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

    #[yaserde(rename = "BlckdSts")]
    #[cfg_attr(feature = "serde", serde(rename = "BlckdSts"))]
    pub blckd_sts: BlockedStatusReason2Choice,

    #[yaserde(rename = "AcctUsgTp")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctUsgTp"))]
    pub acct_usg_tp: AccountUsageType2Choice,

    #[yaserde(rename = "FrgnStsCertfctn")]
    #[cfg_attr(feature = "serde", serde(rename = "FrgnStsCertfctn"))]
    pub frgn_sts_certfctn: Provided1Code,

    #[yaserde(rename = "AcctSgntrDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctSgntrDtTm"))]
    pub acct_sgntr_dt_tm: DateAndDateTime1Choice,

    #[yaserde(rename = "TxChanlTp")]
    #[cfg_attr(feature = "serde", serde(rename = "TxChanlTp"))]
    pub tx_chanl_tp: TransactionChannelType1Choice,

    #[yaserde(rename = "InvstmtAcctCtgy")]
    #[cfg_attr(feature = "serde", serde(rename = "InvstmtAcctCtgy"))]
    pub invstmt_acct_ctgy: InvestmentAccountCategory1Choice,

    #[yaserde(rename = "Pldgg")]
    #[cfg_attr(feature = "serde", serde(rename = "Pldgg"))]
    pub pldgg: Eligible1Code,

    #[yaserde(rename = "Coll")]
    #[cfg_attr(feature = "serde", serde(rename = "Coll"))]
    pub coll: Collateral1Code,

    #[yaserde(rename = "ThrdPtyRghts")]
    #[cfg_attr(feature = "serde", serde(rename = "ThrdPtyRghts"))]
    pub thrd_pty_rghts: ThirdPartyRights2,

    #[yaserde(rename = "PwrOfAttnyLvlOfCtrl")]
    #[cfg_attr(feature = "serde", serde(rename = "PwrOfAttnyLvlOfCtrl"))]
    pub pwr_of_attny_lvl_of_ctrl: LevelOfControl1Choice,

    #[yaserde(rename = "AcctgSts")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctgSts"))]
    pub acctg_sts: AccountingStatus1Choice,

    #[yaserde(rename = "OpngDt")]
    #[cfg_attr(feature = "serde", serde(rename = "OpngDt"))]
    pub opng_dt: DateAndDateTime1Choice,

    #[yaserde(rename = "ClsgDt")]
    #[cfg_attr(feature = "serde", serde(rename = "ClsgDt"))]
    pub clsg_dt: DateAndDateTime1Choice,

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

    #[yaserde(rename = "PrcgOrdr")]
    #[cfg_attr(feature = "serde", serde(rename = "PrcgOrdr"))]
    pub prcg_ordr: PositionEffect3Code,

    #[yaserde(rename = "Lblty")]
    #[cfg_attr(feature = "serde", serde(rename = "Lblty"))]
    pub lblty: Liability1Choice,

    #[yaserde(rename = "InvstrPrfl")]
    #[cfg_attr(feature = "serde", serde(rename = "InvstrPrfl"))]
    pub invstr_prfl: Vec<InvestorProfile2>,

    #[yaserde(rename = "FsclYr")]
    #[cfg_attr(feature = "serde", serde(rename = "FsclYr"))]
    pub fscl_yr: FiscalYear1Choice,
}

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

impl Validate for InvestmentAccountCategory1Choice {}




#[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:acmt.001.001.08")]

pub enum InvestmentAccountCategory1Code {
    #[yaserde(rename = "MAND")]
    #[cfg_attr(feature = "serde", serde(rename = "MAND"))]
    Mand,
    #[yaserde(rename = "RETA")]
    #[cfg_attr(feature = "serde", serde(rename = "RETA"))]
    Reta,
    __Unknown__(String),
}

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

impl Validate for InvestmentAccountCategory1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct InvestmentAccountOpening4 {
    #[yaserde(rename = "OpngTp")]
    #[cfg_attr(feature = "serde", serde(rename = "OpngTp"))]
    pub opng_tp: AccountOpeningType1Choice,

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

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

    #[yaserde(rename = "CtrPtyRef")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrPtyRef"))]
    pub ctr_pty_ref: AdditionalReference13,

    #[yaserde(rename = "ExstgAcctId")]
    #[cfg_attr(feature = "serde", serde(rename = "ExstgAcctId"))]
    pub exstg_acct_id: Vec<Account23>,
}

impl Validate for InvestmentAccountOpening4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct InvestmentAccountOwnershipInformation16 {
    #[yaserde(rename = "Pty")]
    #[cfg_attr(feature = "serde", serde(rename = "Pty"))]
    pub pty: Party47Choice,

    #[yaserde(rename = "MnyLndrgChck")]
    #[cfg_attr(feature = "serde", serde(rename = "MnyLndrgChck"))]
    pub mny_lndrg_chck: MoneyLaunderingCheck1Choice,

    #[yaserde(rename = "InvstrPrflVldtn")]
    #[cfg_attr(feature = "serde", serde(rename = "InvstrPrflVldtn"))]
    pub invstr_prfl_vldtn: Vec<PartyProfileInformation5>,

    #[yaserde(rename = "OwnrshBnfcryRate")]
    #[cfg_attr(feature = "serde", serde(rename = "OwnrshBnfcryRate"))]
    pub ownrsh_bnfcry_rate: OwnershipBeneficiaryRate1,

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

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

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

    #[yaserde(rename = "MiFIDClssfctn")]
    #[cfg_attr(feature = "serde", serde(rename = "MiFIDClssfctn"))]
    pub mi_fid_clssfctn: MiFIDClassification1,

    #[yaserde(rename = "Ntfctn")]
    #[cfg_attr(feature = "serde", serde(rename = "Ntfctn"))]
    pub ntfctn: Vec<Notification2>,

    #[yaserde(rename = "FATCAFormTp")]
    #[cfg_attr(feature = "serde", serde(rename = "FATCAFormTp"))]
    pub fatca_form_tp: Vec<Fatcaform1Choice>,

    #[yaserde(rename = "FATCASts")]
    #[cfg_attr(feature = "serde", serde(rename = "FATCASts"))]
    pub fatca_sts: Vec<Fatcastatus2>,

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

    #[yaserde(rename = "CRSFormTp")]
    #[cfg_attr(feature = "serde", serde(rename = "CRSFormTp"))]
    pub crs_form_tp: Vec<Crsform1Choice>,

    #[yaserde(rename = "CRSSts")]
    #[cfg_attr(feature = "serde", serde(rename = "CRSSts"))]
    pub crs_sts: Vec<Crsstatus4>,

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

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

    #[yaserde(rename = "TaxXmptn")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxXmptn"))]
    pub tax_xmptn: TaxExemptionReason2Choice,

    #[yaserde(rename = "TaxRptg")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxRptg"))]
    pub tax_rptg: Vec<TaxReporting3>,

    #[yaserde(rename = "Lang")]
    #[cfg_attr(feature = "serde", serde(rename = "Lang"))]
    pub lang: LanguageCode,

    #[yaserde(rename = "MailTp")]
    #[cfg_attr(feature = "serde", serde(rename = "MailTp"))]
    pub mail_tp: MailType1Choice,

    #[yaserde(rename = "CtryAndResdtlSts")]
    #[cfg_attr(feature = "serde", serde(rename = "CtryAndResdtlSts"))]
    pub ctry_and_resdtl_sts: CountryAndResidentialStatusType2,

    #[yaserde(rename = "MntryWlth")]
    #[cfg_attr(feature = "serde", serde(rename = "MntryWlth"))]
    pub mntry_wlth: DateAndAmount1,

    #[yaserde(rename = "EqtyVal")]
    #[cfg_attr(feature = "serde", serde(rename = "EqtyVal"))]
    pub eqty_val: DateAndAmount1,

    #[yaserde(rename = "WorkgCptl")]
    #[cfg_attr(feature = "serde", serde(rename = "WorkgCptl"))]
    pub workg_cptl: DateAndAmount1,

    #[yaserde(rename = "CpnyLk")]
    #[cfg_attr(feature = "serde", serde(rename = "CpnyLk"))]
    pub cpny_lk: CompanyLink1Choice,

    #[yaserde(rename = "ElctrncMlngSvcRef")]
    #[cfg_attr(feature = "serde", serde(rename = "ElctrncMlngSvcRef"))]
    pub elctrnc_mlng_svc_ref: Max350Text,

    #[yaserde(rename = "PmryComAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "PmryComAdr"))]
    pub pmry_com_adr: Vec<CommunicationAddress6>,

    #[yaserde(rename = "ScndryComAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "ScndryComAdr"))]
    pub scndry_com_adr: Vec<CommunicationAddress6>,

    #[yaserde(rename = "AddtlRgltryInf")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlRgltryInf"))]
    pub addtl_rgltry_inf: RegulatoryInformation1,

    #[yaserde(rename = "AcctgSts")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctgSts"))]
    pub acctg_sts: AccountingStatus1Choice,

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

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

impl Validate for InvestmentAccountOwnershipInformation16 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct InvestmentFundOrder4 {
    #[yaserde(rename = "OrdrRef")]
    #[cfg_attr(feature = "serde", serde(rename = "OrdrRef"))]
    pub ordr_ref: Max35Text,

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

impl Validate for InvestmentFundOrder4 {}


#[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:acmt.001.001.08")]

pub enum InvestmentFundRole6Code {
    #[yaserde(rename = "CACO")]
    #[cfg_attr(feature = "serde", serde(rename = "CACO"))]
    Caco,
    #[yaserde(rename = "CONC")]
    #[cfg_attr(feature = "serde", serde(rename = "CONC"))]
    Conc,
    #[yaserde(rename = "CUST")]
    #[cfg_attr(feature = "serde", serde(rename = "CUST"))]
    Cust,
    #[yaserde(rename = "DATP")]
    #[cfg_attr(feature = "serde", serde(rename = "DATP"))]
    Datp,
    #[yaserde(rename = "DIST")]
    #[cfg_attr(feature = "serde", serde(rename = "DIST"))]
    Dist,
    #[yaserde(rename = "FACT")]
    #[cfg_attr(feature = "serde", serde(rename = "FACT"))]
    Fact,
    #[yaserde(rename = "FIAD")]
    #[cfg_attr(feature = "serde", serde(rename = "FIAD"))]
    Fiad,
    #[yaserde(rename = "FIAG")]
    #[cfg_attr(feature = "serde", serde(rename = "FIAG"))]
    Fiag,
    #[yaserde(rename = "FMCO")]
    #[cfg_attr(feature = "serde", serde(rename = "FMCO"))]
    Fmco,
    #[yaserde(rename = "FNBR")]
    #[cfg_attr(feature = "serde", serde(rename = "FNBR"))]
    Fnbr,
    #[yaserde(rename = "FTAG")]
    #[cfg_attr(feature = "serde", serde(rename = "FTAG"))]
    Ftag,
    #[yaserde(rename = "INTR")]
    #[cfg_attr(feature = "serde", serde(rename = "INTR"))]
    Intr,
    #[yaserde(rename = "INVE")]
    #[cfg_attr(feature = "serde", serde(rename = "INVE"))]
    Inve,
    #[yaserde(rename = "INVS")]
    #[cfg_attr(feature = "serde", serde(rename = "INVS"))]
    Invs,
    #[yaserde(rename = "PAYI")]
    #[cfg_attr(feature = "serde", serde(rename = "PAYI"))]
    Payi,
    #[yaserde(rename = "REGI")]
    #[cfg_attr(feature = "serde", serde(rename = "REGI"))]
    Regi,
    #[yaserde(rename = "TRAG")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAG"))]
    Trag,
    #[yaserde(rename = "TRAN")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAN"))]
    Tran,
    __Unknown__(String),
}

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

impl Validate for InvestmentFundRole6Code {}



#[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:acmt.001.001.08")]

pub enum InvestmentFundRole7Code {
    #[yaserde(rename = "CONC")]
    #[cfg_attr(feature = "serde", serde(rename = "CONC"))]
    Conc,
    #[yaserde(rename = "DIST")]
    #[cfg_attr(feature = "serde", serde(rename = "DIST"))]
    Dist,
    #[yaserde(rename = "FMCO")]
    #[cfg_attr(feature = "serde", serde(rename = "FMCO"))]
    Fmco,
    #[yaserde(rename = "INTR")]
    #[cfg_attr(feature = "serde", serde(rename = "INTR"))]
    Intr,
    #[yaserde(rename = "PAYI")]
    #[cfg_attr(feature = "serde", serde(rename = "PAYI"))]
    Payi,
    #[yaserde(rename = "TRAG")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAG"))]
    Trag,
    #[yaserde(rename = "CUST")]
    #[cfg_attr(feature = "serde", serde(rename = "CUST"))]
    Cust,
    #[yaserde(rename = "CACO")]
    #[cfg_attr(feature = "serde", serde(rename = "CACO"))]
    Caco,
    #[yaserde(rename = "FACT")]
    #[cfg_attr(feature = "serde", serde(rename = "FACT"))]
    Fact,
    #[yaserde(rename = "INVE")]
    #[cfg_attr(feature = "serde", serde(rename = "INVE"))]
    Inve,
    #[yaserde(rename = "INVS")]
    #[cfg_attr(feature = "serde", serde(rename = "INVS"))]
    Invs,
    __Unknown__(String),
}

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

impl Validate for InvestmentFundRole7Code {}



#[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:acmt.001.001.08")]

pub enum InvestmentFundTransactionType1Code {
    #[yaserde(rename = "ALLL")]
    #[cfg_attr(feature = "serde", serde(rename = "ALLL"))]
    Alll,
    #[yaserde(rename = "SELL")]
    #[cfg_attr(feature = "serde", serde(rename = "SELL"))]
    Sell,
    #[yaserde(rename = "BUYI")]
    #[cfg_attr(feature = "serde", serde(rename = "BUYI"))]
    Buyi,
    #[yaserde(rename = "SWIO")]
    #[cfg_attr(feature = "serde", serde(rename = "SWIO"))]
    Swio,
    #[yaserde(rename = "TRIN")]
    #[cfg_attr(feature = "serde", serde(rename = "TRIN"))]
    Trin,
    #[yaserde(rename = "TOUT")]
    #[cfg_attr(feature = "serde", serde(rename = "TOUT"))]
    Tout,
    #[yaserde(rename = "SUBS")]
    #[cfg_attr(feature = "serde", serde(rename = "SUBS"))]
    Subs,
    #[yaserde(rename = "REDM")]
    #[cfg_attr(feature = "serde", serde(rename = "REDM"))]
    Redm,
    #[yaserde(rename = "CDEP")]
    #[cfg_attr(feature = "serde", serde(rename = "CDEP"))]
    Cdep,
    #[yaserde(rename = "CWIT")]
    #[cfg_attr(feature = "serde", serde(rename = "CWIT"))]
    Cwit,
    #[yaserde(rename = "DIVP")]
    #[cfg_attr(feature = "serde", serde(rename = "DIVP"))]
    Divp,
    #[yaserde(rename = "CAEV")]
    #[cfg_attr(feature = "serde", serde(rename = "CAEV"))]
    Caev,
    #[yaserde(rename = "CROI")]
    #[cfg_attr(feature = "serde", serde(rename = "CROI"))]
    Croi,
    #[yaserde(rename = "CROO")]
    #[cfg_attr(feature = "serde", serde(rename = "CROO"))]
    Croo,
    #[yaserde(rename = "DIVI")]
    #[cfg_attr(feature = "serde", serde(rename = "DIVI"))]
    Divi,
    #[yaserde(rename = "INSP")]
    #[cfg_attr(feature = "serde", serde(rename = "INSP"))]
    Insp,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "REAA")]
    #[cfg_attr(feature = "serde", serde(rename = "REAA"))]
    Reaa,
    #[yaserde(rename = "RWPL")]
    #[cfg_attr(feature = "serde", serde(rename = "RWPL"))]
    Rwpl,
    #[yaserde(rename = "RDIV")]
    #[cfg_attr(feature = "serde", serde(rename = "RDIV"))]
    Rdiv,
    #[yaserde(rename = "SSPL")]
    #[cfg_attr(feature = "serde", serde(rename = "SSPL"))]
    Sspl,
    #[yaserde(rename = "SUAA")]
    #[cfg_attr(feature = "serde", serde(rename = "SUAA"))]
    Suaa,
    __Unknown__(String),
}

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

impl Validate for InvestmentFundTransactionType1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct InvestmentPlan17 {
    #[yaserde(rename = "Frqcy")]
    #[cfg_attr(feature = "serde", serde(rename = "Frqcy"))]
    pub frqcy: Frequency20Choice,

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

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

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

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

    #[yaserde(rename = "IncmPref")]
    #[cfg_attr(feature = "serde", serde(rename = "IncmPref"))]
    pub incm_pref: IncomePreference2Code,

    #[yaserde(rename = "InitlAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "InitlAmt"))]
    pub initl_amt: InitialAmount1Choice,

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

    #[yaserde(rename = "RndgDrctn")]
    #[cfg_attr(feature = "serde", serde(rename = "RndgDrctn"))]
    pub rndg_drctn: RoundingDirection1Code,

    #[yaserde(rename = "SctyDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "SctyDtls"))]
    pub scty_dtls: Vec<Repartition6>,

    #[yaserde(rename = "CshSttlm")]
    #[cfg_attr(feature = "serde", serde(rename = "CshSttlm"))]
    pub csh_sttlm: Vec<CashSettlement3>,

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

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

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

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

    #[yaserde(rename = "InsrncCover")]
    #[cfg_attr(feature = "serde", serde(rename = "InsrncCover"))]
    pub insrnc_cover: InsuranceType2Choice,

    #[yaserde(rename = "PlanSts")]
    #[cfg_attr(feature = "serde", serde(rename = "PlanSts"))]
    pub plan_sts: PlanStatus2Choice,

    #[yaserde(rename = "InstlmtMgrRole")]
    #[cfg_attr(feature = "serde", serde(rename = "InstlmtMgrRole"))]
    pub instlmt_mgr_role: PartyRole4Choice,
}

impl Validate for InvestmentPlan17 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct InvestorProfile2 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: ProfileType1Choice,

    #[yaserde(rename = "Sts")]
    #[cfg_attr(feature = "serde", serde(rename = "Sts"))]
    pub sts: InvestorProfileStatus1Choice,

    #[yaserde(rename = "Trsr")]
    #[cfg_attr(feature = "serde", serde(rename = "Trsr"))]
    pub trsr: TreasuryProfile1,

    #[yaserde(rename = "HghFrqcyTradg")]
    #[cfg_attr(feature = "serde", serde(rename = "HghFrqcyTradg"))]
    pub hgh_frqcy_tradg: HighFrequencyTradingProfile1,

    #[yaserde(rename = "MktMakr")]
    #[cfg_attr(feature = "serde", serde(rename = "MktMakr"))]
    pub mkt_makr: MarketMakerProfile2,
}

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

impl Validate for InvestorProfileStatus1Choice {}




#[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:acmt.001.001.08")]

pub enum InvestorProfileStatus1Code {
    #[yaserde(rename = "DISA")]
    #[cfg_attr(feature = "serde", serde(rename = "DISA"))]
    Disa,
    #[yaserde(rename = "DISG")]
    #[cfg_attr(feature = "serde", serde(rename = "DISG"))]
    Disg,
    #[yaserde(rename = "ENAB")]
    #[cfg_attr(feature = "serde", serde(rename = "ENAB"))]
    Enab,
    #[yaserde(rename = "ENBG")]
    #[cfg_attr(feature = "serde", serde(rename = "ENBG"))]
    Enbg,
    #[yaserde(rename = "ADMI")]
    #[cfg_attr(feature = "serde", serde(rename = "ADMI"))]
    Admi,
    #[yaserde(rename = "ANLY")]
    #[cfg_attr(feature = "serde", serde(rename = "ANLY"))]
    Anly,
    #[yaserde(rename = "NAPP")]
    #[cfg_attr(feature = "serde", serde(rename = "NAPP"))]
    Napp,
    #[yaserde(rename = "PSUS")]
    #[cfg_attr(feature = "serde", serde(rename = "PSUS"))]
    Psus,
    #[yaserde(rename = "PEND")]
    #[cfg_attr(feature = "serde", serde(rename = "PEND"))]
    Pend,
    #[yaserde(rename = "SUPS")]
    #[cfg_attr(feature = "serde", serde(rename = "SUPS"))]
    Sups,
    __Unknown__(String),
}

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

impl Validate for InvestorProfileStatus1Code {}



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

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

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

impl Validate for KyccheckType1Choice {}




#[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:acmt.001.001.08")]

pub enum KnowYourCustomerCheckType1Code {
    #[yaserde(rename = "ENHA")]
    #[cfg_attr(feature = "serde", serde(rename = "ENHA"))]
    Enha,
    #[yaserde(rename = "ORDN")]
    #[cfg_attr(feature = "serde", serde(rename = "ORDN"))]
    Ordn,
    #[yaserde(rename = "SIMP")]
    #[cfg_attr(feature = "serde", serde(rename = "SIMP"))]
    Simp,
    __Unknown__(String),
}

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

impl Validate for KnowYourCustomerCheckType1Code {}



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

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

impl Validate for LanguageCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct LetterIntent1 {
    #[yaserde(rename = "LttrInttRef")]
    #[cfg_attr(feature = "serde", serde(rename = "LttrInttRef"))]
    pub lttr_intt_ref: Max35Text,

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

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

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

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

impl Validate for LevelOfControl1Choice {}




#[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:acmt.001.001.08")]

pub enum LevelOfControl1Code {
    #[yaserde(rename = "TRAN")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAN"))]
    Tran,
    #[yaserde(rename = "VIEW")]
    #[cfg_attr(feature = "serde", serde(rename = "VIEW"))]
    View,
    __Unknown__(String),
}

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

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

impl Validate for Liability1Choice {}




#[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:acmt.001.001.08")]

pub enum Liability1Code {
    #[yaserde(rename = "INVE")]
    #[cfg_attr(feature = "serde", serde(rename = "INVE"))]
    Inve,
    #[yaserde(rename = "BROK")]
    #[cfg_attr(feature = "serde", serde(rename = "BROK"))]
    Brok,
    __Unknown__(String),
}

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

impl Validate for Liability1Code {}



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

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

impl Validate for MailType1Choice {}




#[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:acmt.001.001.08")]

pub enum MailType1Code {
    #[yaserde(rename = "AIRM")]
    #[cfg_attr(feature = "serde", serde(rename = "AIRM"))]
    Airm,
    #[yaserde(rename = "ORDM")]
    #[cfg_attr(feature = "serde", serde(rename = "ORDM"))]
    Ordm,
    #[yaserde(rename = "REGM")]
    #[cfg_attr(feature = "serde", serde(rename = "REGM"))]
    Regm,
    __Unknown__(String),
}

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

impl Validate for MailType1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct MarketMakerProfile2 {
    #[yaserde(rename = "CtrctPrd")]
    #[cfg_attr(feature = "serde", serde(rename = "CtrctPrd"))]
    pub ctrct_prd: DateTimePeriod2,

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

    #[yaserde(rename = "MaxSprd")]
    #[cfg_attr(feature = "serde", serde(rename = "MaxSprd"))]
    pub max_sprd: PercentageRate,

    #[yaserde(rename = "Dscnt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dscnt"))]
    pub dscnt: PercentageRate,
}

impl Validate for MarketMakerProfile2 {}


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

    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: IsoyearMonth,

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

impl Validate for MarketPracticeVersion1 {}


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

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

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

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

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct 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 Max256Text (pub String);
crate::simple_type!(Max256Text);

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

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

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

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

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

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

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

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

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

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

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

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
pub struct 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:acmt.001.001.08")]
pub struct MessageIdentification1 {
    #[yaserde(rename = "Id")]
    #[cfg_attr(feature = "serde", serde(rename = "Id"))]
    pub id: Max35Text,

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

impl Validate for MessageIdentification1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct MiFIDClassification1 {
    #[yaserde(rename = "Clssfctn")]
    #[cfg_attr(feature = "serde", serde(rename = "Clssfctn"))]
    pub clssfctn: OrderOriginatorEligibility1Code,

    #[yaserde(rename = "Nrrtv")]
    #[cfg_attr(feature = "serde", serde(rename = "Nrrtv"))]
    pub nrrtv: Max350Text,
}

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

impl Validate for MoneyLaunderingCheck1Choice {}




#[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:acmt.001.001.08")]

pub enum MoneyLaunderingCheck1Code {
    #[yaserde(rename = "PASS")]
    #[cfg_attr(feature = "serde", serde(rename = "PASS"))]
    Pass,
    #[yaserde(rename = "NOTC")]
    #[cfg_attr(feature = "serde", serde(rename = "NOTC"))]
    Notc,
    #[yaserde(rename = "EXEM")]
    #[cfg_attr(feature = "serde", serde(rename = "EXEM"))]
    Exem,
    #[yaserde(rename = "CLMO")]
    #[cfg_attr(feature = "serde", serde(rename = "CLMO"))]
    Clmo,
    #[yaserde(rename = "AUTH")]
    #[cfg_attr(feature = "serde", serde(rename = "AUTH"))]
    Auth,
    #[yaserde(rename = "POEP")]
    #[cfg_attr(feature = "serde", serde(rename = "POEP"))]
    Poep,
    __Unknown__(String),
}

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

impl Validate for MoneyLaunderingCheck1Code {}



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

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

impl Validate for NameAndAddress4 {}


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

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

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

impl Validate for NamePrefix1Choice {}




#[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:acmt.001.001.08")]

pub enum NamePrefix1Code {
    #[yaserde(rename = "DOCT")]
    #[cfg_attr(feature = "serde", serde(rename = "DOCT"))]
    Doct,
    #[yaserde(rename = "MIST")]
    #[cfg_attr(feature = "serde", serde(rename = "MIST"))]
    Mist,
    #[yaserde(rename = "MISS")]
    #[cfg_attr(feature = "serde", serde(rename = "MISS"))]
    Miss,
    #[yaserde(rename = "MADM")]
    #[cfg_attr(feature = "serde", serde(rename = "MADM"))]
    Madm,
    __Unknown__(String),
}

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

impl Validate for NamePrefix1Code {}



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

impl Validate for NationalityCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct NewIssueAllocation2 {
    #[yaserde(rename = "Rstrctd")]
    #[cfg_attr(feature = "serde", serde(rename = "Rstrctd"))]
    pub rstrctd: YesNoIndicator,

    #[yaserde(rename = "XmptPrsnRsn")]
    #[cfg_attr(feature = "serde", serde(rename = "XmptPrsnRsn"))]
    pub xmpt_prsn_rsn: Max350Text,

    #[yaserde(rename = "DeMnms")]
    #[cfg_attr(feature = "serde", serde(rename = "DeMnms"))]
    pub de_mnms: DeMinimus1Choice,
}

impl Validate for NewIssueAllocation2 {}


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

impl Validate for NewZealandNCCIdentifier {}
#[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:acmt.001.001.08")]

pub enum NoReasonCode {
    #[yaserde(rename = "NORE")]
    #[cfg_attr(feature = "serde", serde(rename = "NORE"))]
    Nore,
    __Unknown__(String),
}

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

impl Validate for NoReasonCode {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct Notification2 {
    #[yaserde(rename = "NtfctnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "NtfctnTp"))]
    pub ntfctn_tp: Max35Text,

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

    #[yaserde(rename = "DstrbtnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "DstrbtnTp"))]
    pub dstrbtn_tp: InformationDistribution1Choice,
}

impl Validate for Notification2 {}


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

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

pub enum OperationalStatus1Code {
    #[yaserde(rename = "ENAB")]
    #[cfg_attr(feature = "serde", serde(rename = "ENAB"))]
    Enab,
    #[yaserde(rename = "SPEC")]
    #[cfg_attr(feature = "serde", serde(rename = "SPEC"))]
    Spec,
    __Unknown__(String),
}

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

impl Validate for OperationalStatus1Code {}



#[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:acmt.001.001.08")]

pub enum OrderOriginatorEligibility1Code {
    #[yaserde(rename = "ELIG")]
    #[cfg_attr(feature = "serde", serde(rename = "ELIG"))]
    Elig,
    #[yaserde(rename = "RETL")]
    #[cfg_attr(feature = "serde", serde(rename = "RETL"))]
    Retl,
    #[yaserde(rename = "PROF")]
    #[cfg_attr(feature = "serde", serde(rename = "PROF"))]
    Prof,
    __Unknown__(String),
}

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

impl Validate for OrderOriginatorEligibility1Code {}



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

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

    #[yaserde(rename = "PstlAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "PstlAdr"))]
    pub pstl_adr: Vec<PostalAddress21>,
}

impl Validate for Organisation23 {}


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

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

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

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

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

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

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

    #[yaserde(rename = "PstlAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "PstlAdr"))]
    pub pstl_adr: Vec<PostalAddress21>,

    #[yaserde(rename = "TpOfOrg")]
    #[cfg_attr(feature = "serde", serde(rename = "TpOfOrg"))]
    pub tp_of_org: OrganisationType1Choice,

    #[yaserde(rename = "PlcOfListg")]
    #[cfg_attr(feature = "serde", serde(rename = "PlcOfListg"))]
    pub plc_of_listg: Vec<Micidentifier>,
}

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

impl Validate for OrganisationType1Choice {}




#[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:acmt.001.001.08")]

pub enum OrganisationType1Code {
    #[yaserde(rename = "IFUN")]
    #[cfg_attr(feature = "serde", serde(rename = "IFUN"))]
    Ifun,
    #[yaserde(rename = "PRIV")]
    #[cfg_attr(feature = "serde", serde(rename = "PRIV"))]
    Priv,
    #[yaserde(rename = "PUBL")]
    #[cfg_attr(feature = "serde", serde(rename = "PUBL"))]
    Publ,
    #[yaserde(rename = "PFUN")]
    #[cfg_attr(feature = "serde", serde(rename = "PFUN"))]
    Pfun,
    __Unknown__(String),
}

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

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

impl Validate for OtherIdentification3Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct OwnershipBeneficiaryRate1 {
    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: PercentageRate,

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

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

impl Validate for OwnershipType2Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct Party47Choice {
    #[yaserde(rename = "Org")]
    #[cfg_attr(feature = "serde", serde(rename = "Org"))]
    pub org: Option<Organisation39>,
    #[yaserde(rename = "IndvPrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "IndvPrsn"))]
    pub indv_prsn: Option<IndividualPerson37>,
}

impl Validate for Party47Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct PartyIdentification125Choice {
    #[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<GenericIdentification1>,
    #[yaserde(rename = "NmAndAdr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmAndAdr"))]
    pub nm_and_adr: Option<NameAndAddress5>,
}

impl Validate for PartyIdentification125Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct PartyIdentification177Choice {
    #[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<GenericIdentification1>,
}

impl Validate for PartyIdentification177Choice {}




#[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:acmt.001.001.08")]

pub enum PartyIdentificationType7Code {
    #[yaserde(rename = "ATIN")]
    #[cfg_attr(feature = "serde", serde(rename = "ATIN"))]
    Atin,
    #[yaserde(rename = "IDCD")]
    #[cfg_attr(feature = "serde", serde(rename = "IDCD"))]
    Idcd,
    #[yaserde(rename = "NRIN")]
    #[cfg_attr(feature = "serde", serde(rename = "NRIN"))]
    Nrin,
    #[yaserde(rename = "OTHR")]
    #[cfg_attr(feature = "serde", serde(rename = "OTHR"))]
    Othr,
    #[yaserde(rename = "PASS")]
    #[cfg_attr(feature = "serde", serde(rename = "PASS"))]
    Pass,
    #[yaserde(rename = "POCD")]
    #[cfg_attr(feature = "serde", serde(rename = "POCD"))]
    Pocd,
    #[yaserde(rename = "SOCS")]
    #[cfg_attr(feature = "serde", serde(rename = "SOCS"))]
    Socs,
    #[yaserde(rename = "SRSA")]
    #[cfg_attr(feature = "serde", serde(rename = "SRSA"))]
    Srsa,
    #[yaserde(rename = "GUNL")]
    #[cfg_attr(feature = "serde", serde(rename = "GUNL"))]
    Gunl,
    #[yaserde(rename = "GTIN")]
    #[cfg_attr(feature = "serde", serde(rename = "GTIN"))]
    Gtin,
    #[yaserde(rename = "ITIN")]
    #[cfg_attr(feature = "serde", serde(rename = "ITIN"))]
    Itin,
    #[yaserde(rename = "CPFA")]
    #[cfg_attr(feature = "serde", serde(rename = "CPFA"))]
    Cpfa,
    #[yaserde(rename = "AREG")]
    #[cfg_attr(feature = "serde", serde(rename = "AREG"))]
    Areg,
    #[yaserde(rename = "DRLC")]
    #[cfg_attr(feature = "serde", serde(rename = "DRLC"))]
    Drlc,
    #[yaserde(rename = "EMID")]
    #[cfg_attr(feature = "serde", serde(rename = "EMID"))]
    Emid,
    #[yaserde(rename = "NINV")]
    #[cfg_attr(feature = "serde", serde(rename = "NINV"))]
    Ninv,
    #[yaserde(rename = "INCL")]
    #[cfg_attr(feature = "serde", serde(rename = "INCL"))]
    Incl,
    #[yaserde(rename = "GIIN")]
    #[cfg_attr(feature = "serde", serde(rename = "GIIN"))]
    Giin,
    __Unknown__(String),
}

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

impl Validate for PartyIdentificationType7Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct PartyProfileInformation5 {
    #[yaserde(rename = "CertfctnInd")]
    #[cfg_attr(feature = "serde", serde(rename = "CertfctnInd"))]
    pub certfctn_ind: YesNoIndicator,

    #[yaserde(rename = "VldtngPty")]
    #[cfg_attr(feature = "serde", serde(rename = "VldtngPty"))]
    pub vldtng_pty: Max140Text,

    #[yaserde(rename = "ChckngPty")]
    #[cfg_attr(feature = "serde", serde(rename = "ChckngPty"))]
    pub chckng_pty: Max140Text,

    #[yaserde(rename = "RspnsblPty")]
    #[cfg_attr(feature = "serde", serde(rename = "RspnsblPty"))]
    pub rspnsbl_pty: Max140Text,

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

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

    #[yaserde(rename = "ChckngFrqcy")]
    #[cfg_attr(feature = "serde", serde(rename = "ChckngFrqcy"))]
    pub chckng_frqcy: EventFrequency1Code,

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

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

    #[yaserde(rename = "SrcOfWlth")]
    #[cfg_attr(feature = "serde", serde(rename = "SrcOfWlth"))]
    pub src_of_wlth: Max140Text,

    #[yaserde(rename = "CstmrCndctClssfctn")]
    #[cfg_attr(feature = "serde", serde(rename = "CstmrCndctClssfctn"))]
    pub cstmr_cndct_clssfctn: CustomerConductClassification1Choice,

    #[yaserde(rename = "RskLvl")]
    #[cfg_attr(feature = "serde", serde(rename = "RskLvl"))]
    pub rsk_lvl: RiskLevel2Choice,

    #[yaserde(rename = "KnowYourCstmrChckTp")]
    #[cfg_attr(feature = "serde", serde(rename = "KnowYourCstmrChckTp"))]
    pub know_your_cstmr_chck_tp: KyccheckType1Choice,

    #[yaserde(rename = "KnowYourCstmrDBChck")]
    #[cfg_attr(feature = "serde", serde(rename = "KnowYourCstmrDBChck"))]
    pub know_your_cstmr_db_chck: DataBaseCheck1,
}

impl Validate for PartyProfileInformation5 {}


#[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:acmt.001.001.08")]

pub enum PartyRole1Code {
    #[yaserde(rename = "CUST")]
    #[cfg_attr(feature = "serde", serde(rename = "CUST"))]
    Cust,
    #[yaserde(rename = "INVS")]
    #[cfg_attr(feature = "serde", serde(rename = "INVS"))]
    Invs,
    __Unknown__(String),
}

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

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

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

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

impl Validate for PartyRole5Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct PaymentCard29 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: CardType1Code,

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

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

    #[yaserde(rename = "StartDt")]
    #[cfg_attr(feature = "serde", serde(rename = "StartDt"))]
    pub start_dt: IsoyearMonth,

    #[yaserde(rename = "XpryDt")]
    #[cfg_attr(feature = "serde", serde(rename = "XpryDt"))]
    pub xpry_dt: IsoyearMonth,

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

    #[yaserde(rename = "CardIssrId")]
    #[cfg_attr(feature = "serde", serde(rename = "CardIssrId"))]
    pub card_issr_id: PartyIdentification125Choice,

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

    #[yaserde(rename = "SeqNb")]
    #[cfg_attr(feature = "serde", serde(rename = "SeqNb"))]
    pub seq_nb: Max3Text,
}

impl Validate for PaymentCard29 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct PaymentInstrument17 {
    #[yaserde(rename = "SttlmCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "SttlmCcy"))]
    pub sttlm_ccy: ActiveCurrencyCode,

    #[yaserde(rename = "DvddPctg")]
    #[cfg_attr(feature = "serde", serde(rename = "DvddPctg"))]
    pub dvdd_pctg: PercentageBoundedRate,

    #[yaserde(rename = "SbcptPmtInstrm")]
    #[cfg_attr(feature = "serde", serde(rename = "SbcptPmtInstrm"))]
    pub sbcpt_pmt_instrm: PaymentInstrument24Choice,

    #[yaserde(rename = "RedPmtInstrm")]
    #[cfg_attr(feature = "serde", serde(rename = "RedPmtInstrm"))]
    pub red_pmt_instrm: PaymentInstrument19Choice,

    #[yaserde(rename = "DvddPmtInstrm")]
    #[cfg_attr(feature = "serde", serde(rename = "DvddPmtInstrm"))]
    pub dvdd_pmt_instrm: PaymentInstrument19Choice,

    #[yaserde(rename = "SvgsPlanPmtInstrm")]
    #[cfg_attr(feature = "serde", serde(rename = "SvgsPlanPmtInstrm"))]
    pub svgs_plan_pmt_instrm: PaymentInstrument24Choice,

    #[yaserde(rename = "IntrstPmtInstrm")]
    #[cfg_attr(feature = "serde", serde(rename = "IntrstPmtInstrm"))]
    pub intrst_pmt_instrm: PaymentInstrument19Choice,
}

impl Validate for PaymentInstrument17 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct PaymentInstrument19Choice {
    #[yaserde(rename = "ChqDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "ChqDtls"))]
    pub chq_dtls: Option<Cheque4>,
    #[yaserde(rename = "BkrsDrftDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "BkrsDrftDtls"))]
    pub bkrs_drft_dtls: Option<Cheque4>,
}

impl Validate for PaymentInstrument19Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct PaymentInstrument24Choice {
    #[yaserde(rename = "PmtCardDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "PmtCardDtls"))]
    pub pmt_card_dtls: Option<PaymentCard29>,
    #[yaserde(rename = "DrctDbtDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "DrctDbtDtls"))]
    pub drct_dbt_dtls: Option<DirectDebitMandate7>,
    #[yaserde(rename = "Chq")]
    #[cfg_attr(feature = "serde", serde(rename = "Chq"))]
    pub chq: Option<YesNoIndicator>,
    #[yaserde(rename = "BkrsDrft")]
    #[cfg_attr(feature = "serde", serde(rename = "BkrsDrft"))]
    pub bkrs_drft: Option<YesNoIndicator>,
}

impl Validate for PaymentInstrument24Choice {}




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

impl Validate for PercentageBoundedRate {
    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));
        }
        if self.0 > "100".parse::<String>().unwrap() {
            return Err(format!("MaxInclusive validation error: invalid value of 0! \nExpected: 0 <= 100.\nActual: 0 == {}", self.0));
        }
        Ok(())
    }
}

#[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:acmt.001.001.08")]
pub struct PersonalInformation1 {
    #[yaserde(rename = "NmOfFthr")]
    #[cfg_attr(feature = "serde", serde(rename = "NmOfFthr"))]
    pub nm_of_fthr: Max35Text,

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

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

impl Validate for PersonalInformation1 {}


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

impl Validate for PhoneNumber {}
#[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:acmt.001.001.08")]

pub enum PlanStatus1Code {
    #[yaserde(rename = "ACTV")]
    #[cfg_attr(feature = "serde", serde(rename = "ACTV"))]
    Actv,
    #[yaserde(rename = "CLOS")]
    #[cfg_attr(feature = "serde", serde(rename = "CLOS"))]
    Clos,
    #[yaserde(rename = "SUSP")]
    #[cfg_attr(feature = "serde", serde(rename = "SUSP"))]
    Susp,
    __Unknown__(String),
}

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

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

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

impl Validate for PoliticalExposureType2Choice {}




#[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:acmt.001.001.08")]

pub enum PoliticalExposureType2Code {
    #[yaserde(rename = "NPEX")]
    #[cfg_attr(feature = "serde", serde(rename = "NPEX"))]
    Npex,
    #[yaserde(rename = "YPEX")]
    #[cfg_attr(feature = "serde", serde(rename = "YPEX"))]
    Ypex,
    #[yaserde(rename = "PEXD")]
    #[cfg_attr(feature = "serde", serde(rename = "PEXD"))]
    Pexd,
    #[yaserde(rename = "PEXF")]
    #[cfg_attr(feature = "serde", serde(rename = "PEXF"))]
    Pexf,
    __Unknown__(String),
}

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

impl Validate for PoliticalExposureType2Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct PoliticallyExposedPerson1 {
    #[yaserde(rename = "PltclyXpsdPrsnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "PltclyXpsdPrsnTp"))]
    pub pltcly_xpsd_prsn_tp: PoliticalExposureType2Choice,

    #[yaserde(rename = "PltclyXpsdPrsnSts")]
    #[cfg_attr(feature = "serde", serde(rename = "PltclyXpsdPrsnSts"))]
    pub pltcly_xpsd_prsn_sts: PoliticallyExposedPersonStatus1Choice,
}

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

impl Validate for PoliticallyExposedPersonStatus1Choice {}




#[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:acmt.001.001.08")]

pub enum PoliticallyExposedPersonStatus1Code {
    #[yaserde(rename = "PE03")]
    #[cfg_attr(feature = "serde", serde(rename = "PE03"))]
    Pe03,
    #[yaserde(rename = "PE01")]
    #[cfg_attr(feature = "serde", serde(rename = "PE01"))]
    Pe01,
    #[yaserde(rename = "PE02")]
    #[cfg_attr(feature = "serde", serde(rename = "PE02"))]
    Pe02,
    __Unknown__(String),
}

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

impl Validate for PoliticallyExposedPersonStatus1Code {}



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

impl Validate for PortugueseNCCIdentifier {}
#[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:acmt.001.001.08")]

pub enum PositionEffect3Code {
    #[yaserde(rename = "FIFO")]
    #[cfg_attr(feature = "serde", serde(rename = "FIFO"))]
    Fifo,
    #[yaserde(rename = "LIFO")]
    #[cfg_attr(feature = "serde", serde(rename = "LIFO"))]
    Lifo,
    __Unknown__(String),
}

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

impl Validate for PositionEffect3Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct PostalAddress1 {
    #[yaserde(rename = "AdrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "AdrTp"))]
    pub adr_tp: AddressType2Code,

    #[yaserde(rename = "AdrLine")]
    #[cfg_attr(feature = "serde", serde(rename = "AdrLine"))]
    pub adr_line: Vec<Max70Text>,

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

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

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

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

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

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

impl Validate for PostalAddress1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct PostalAddress21 {
    #[yaserde(rename = "AdrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "AdrTp"))]
    pub adr_tp: AddressType2Choice,

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

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

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

    #[yaserde(rename = "AdrLine")]
    #[cfg_attr(feature = "serde", serde(rename = "AdrLine"))]
    pub adr_line: Vec<Max70Text>,

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

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

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

    #[yaserde(rename = "PstBx")]
    #[cfg_attr(feature = "serde", serde(rename = "PstBx"))]
    pub pst_bx: Max10Text,

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

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

    #[yaserde(rename = "SuiteId")]
    #[cfg_attr(feature = "serde", serde(rename = "SuiteId"))]
    pub suite_id: Max10Text,

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

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

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

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

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

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

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

impl Validate for ProfileType1Choice {}




#[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:acmt.001.001.08")]

pub enum ProfileType1Code {
    #[yaserde(rename = "HEDG")]
    #[cfg_attr(feature = "serde", serde(rename = "HEDG"))]
    Hedg,
    #[yaserde(rename = "HFTR")]
    #[cfg_attr(feature = "serde", serde(rename = "HFTR"))]
    Hftr,
    #[yaserde(rename = "MAKE")]
    #[cfg_attr(feature = "serde", serde(rename = "MAKE"))]
    Make,
    #[yaserde(rename = "TREA")]
    #[cfg_attr(feature = "serde", serde(rename = "TREA"))]
    Trea,
    __Unknown__(String),
}

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

impl Validate for ProfileType1Code {}



#[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:acmt.001.001.08")]

pub enum Provided1Code {
    #[yaserde(rename = "NPRO")]
    #[cfg_attr(feature = "serde", serde(rename = "NPRO"))]
    Npro,
    #[yaserde(rename = "PROV")]
    #[cfg_attr(feature = "serde", serde(rename = "PROV"))]
    Prov,
    __Unknown__(String),
}

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

impl Validate for Provided1Code {}



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

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

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

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

pub enum Rank1Code {
    #[yaserde(rename = "PRIM")]
    #[cfg_attr(feature = "serde", serde(rename = "PRIM"))]
    Prim,
    #[yaserde(rename = "SECO")]
    #[cfg_attr(feature = "serde", serde(rename = "SECO"))]
    Seco,
    __Unknown__(String),
}

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

impl Validate for Rank1Code {}



#[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:acmt.001.001.08")]

pub enum Referred1Code {
    #[yaserde(rename = "REFR")]
    #[cfg_attr(feature = "serde", serde(rename = "REFR"))]
    Refr,
    #[yaserde(rename = "NRFR")]
    #[cfg_attr(feature = "serde", serde(rename = "NRFR"))]
    Nrfr,
    #[yaserde(rename = "UKNW")]
    #[cfg_attr(feature = "serde", serde(rename = "UKNW"))]
    Uknw,
    __Unknown__(String),
}

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

impl Validate for Referred1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct ReferredAgent3 {
    #[yaserde(rename = "Rfrd")]
    #[cfg_attr(feature = "serde", serde(rename = "Rfrd"))]
    pub rfrd: Referred1Code,

    #[yaserde(rename = "RfrdPlcmntAgt")]
    #[cfg_attr(feature = "serde", serde(rename = "RfrdPlcmntAgt"))]
    pub rfrd_plcmnt_agt: PartyIdentification125Choice,
}

impl Validate for ReferredAgent3 {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct RegisteredShareholderName1Choice {
    #[yaserde(rename = "IndvPrsn")]
    #[cfg_attr(feature = "serde", serde(rename = "IndvPrsn"))]
    pub indv_prsn: Option<IndividualPerson29>,
    #[yaserde(rename = "Org")]
    #[cfg_attr(feature = "serde", serde(rename = "Org"))]
    pub org: Option<Organisation23>,
}

impl Validate for RegisteredShareholderName1Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct RegulatoryInformation1 {
    #[yaserde(rename = "Sctr")]
    #[cfg_attr(feature = "serde", serde(rename = "Sctr"))]
    pub sctr: Max35Text,

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

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

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

impl Validate for RegulatoryInformation1 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct Reinvestment4 {
    #[yaserde(rename = "FinInstrmDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrmDtls"))]
    pub fin_instrm_dtls: FinancialInstrument87,

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

    #[yaserde(rename = "RinvstmtPctg")]
    #[cfg_attr(feature = "serde", serde(rename = "RinvstmtPctg"))]
    pub rinvstmt_pctg: PercentageRate,
}

impl Validate for Reinvestment4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct Repartition6 {
    #[yaserde(rename = "Qty")]
    #[cfg_attr(feature = "serde", serde(rename = "Qty"))]
    pub qty: UnitsOrAmountOrPercentage1Choice,

    #[yaserde(rename = "FinInstrm")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrm"))]
    pub fin_instrm: FinancialInstrument87,

    #[yaserde(rename = "CcyOfPlan")]
    #[cfg_attr(feature = "serde", serde(rename = "CcyOfPlan"))]
    pub ccy_of_plan: ActiveOrHistoricCurrencyCode,
}

impl Validate for Repartition6 {}


#[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:acmt.001.001.08")]

pub enum ResidentialStatus1Code {
    #[yaserde(rename = "RESI")]
    #[cfg_attr(feature = "serde", serde(rename = "RESI"))]
    Resi,
    #[yaserde(rename = "PRES")]
    #[cfg_attr(feature = "serde", serde(rename = "PRES"))]
    Pres,
    #[yaserde(rename = "NRES")]
    #[cfg_attr(feature = "serde", serde(rename = "NRES"))]
    Nres,
    __Unknown__(String),
}

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

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

impl Validate for RestrictionStatus1Choice {}




#[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:acmt.001.001.08")]

pub enum RestrictionStatus1Code {
    #[yaserde(rename = "ACTV")]
    #[cfg_attr(feature = "serde", serde(rename = "ACTV"))]
    Actv,
    #[yaserde(rename = "INAC")]
    #[cfg_attr(feature = "serde", serde(rename = "INAC"))]
    Inac,
    __Unknown__(String),
}

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

impl Validate for RestrictionStatus1Code {}



#[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:acmt.001.001.08")]

pub enum RiskLevel1Code {
    #[yaserde(rename = "HIGH")]
    #[cfg_attr(feature = "serde", serde(rename = "HIGH"))]
    High,
    #[yaserde(rename = "LOWW")]
    #[cfg_attr(feature = "serde", serde(rename = "LOWW"))]
    Loww,
    #[yaserde(rename = "MEDM")]
    #[cfg_attr(feature = "serde", serde(rename = "MEDM"))]
    Medm,
    __Unknown__(String),
}

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

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

impl Validate for RiskLevel2Choice {}




#[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:acmt.001.001.08")]

pub enum RoundingDirection1Code {
    #[yaserde(rename = "RDUP")]
    #[cfg_attr(feature = "serde", serde(rename = "RDUP"))]
    Rdup,
    #[yaserde(rename = "RDWN")]
    #[cfg_attr(feature = "serde", serde(rename = "RDWN"))]
    Rdwn,
    #[yaserde(rename = "STAN")]
    #[cfg_attr(feature = "serde", serde(rename = "STAN"))]
    Stan,
    #[yaserde(rename = "DIST")]
    #[cfg_attr(feature = "serde", serde(rename = "DIST"))]
    Dist,
    __Unknown__(String),
}

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

impl Validate for RoundingDirection1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct RoundingParameters1 {
    #[yaserde(rename = "RndgMdlus")]
    #[cfg_attr(feature = "serde", serde(rename = "RndgMdlus"))]
    pub rndg_mdlus: DecimalNumber,

    #[yaserde(rename = "RndgDrctn")]
    #[cfg_attr(feature = "serde", serde(rename = "RndgDrctn"))]
    pub rndg_drctn: RoundingDirection1Code,
}

impl Validate for RoundingParameters1 {}


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

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

impl Validate for Sedolidentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct SecurityIdentification25Choice {
    #[yaserde(rename = "ISIN")]
    #[cfg_attr(feature = "serde", serde(rename = "ISIN"))]
    pub isin: Option<Isinoct2015Identifier>,
    #[yaserde(rename = "SEDOL")]
    #[cfg_attr(feature = "serde", serde(rename = "SEDOL"))]
    pub sedol: Option<Sedolidentifier>,
    #[yaserde(rename = "CUSIP")]
    #[cfg_attr(feature = "serde", serde(rename = "CUSIP"))]
    pub cusip: Option<Cusipidentifier>,
    #[yaserde(rename = "RIC")]
    #[cfg_attr(feature = "serde", serde(rename = "RIC"))]
    pub ric: Option<Ricidentifier>,
    #[yaserde(rename = "TckrSymb")]
    #[cfg_attr(feature = "serde", serde(rename = "TckrSymb"))]
    pub tckr_symb: Option<TickerIdentifier>,
    #[yaserde(rename = "Blmbrg")]
    #[cfg_attr(feature = "serde", serde(rename = "Blmbrg"))]
    pub blmbrg: Option<Bloomberg2Identifier>,
    #[yaserde(rename = "CTA")]
    #[cfg_attr(feature = "serde", serde(rename = "CTA"))]
    pub cta: Option<ConsolidatedTapeAssociationIdentifier>,
    #[yaserde(rename = "QUICK")]
    #[cfg_attr(feature = "serde", serde(rename = "QUICK"))]
    pub quick: Option<Quickidentifier>,
    #[yaserde(rename = "Wrtppr")]
    #[cfg_attr(feature = "serde", serde(rename = "Wrtppr"))]
    pub wrtppr: Option<WertpapierIdentifier>,
    #[yaserde(rename = "Dtch")]
    #[cfg_attr(feature = "serde", serde(rename = "Dtch"))]
    pub dtch: Option<DutchIdentifier>,
    #[yaserde(rename = "Vlrn")]
    #[cfg_attr(feature = "serde", serde(rename = "Vlrn"))]
    pub vlrn: Option<ValorenIdentifier>,
    #[yaserde(rename = "SCVM")]
    #[cfg_attr(feature = "serde", serde(rename = "SCVM"))]
    pub scvm: Option<SicovamIdentifier>,
    #[yaserde(rename = "Belgn")]
    #[cfg_attr(feature = "serde", serde(rename = "Belgn"))]
    pub belgn: Option<BelgianIdentifier>,
    #[yaserde(rename = "Cmon")]
    #[cfg_attr(feature = "serde", serde(rename = "Cmon"))]
    pub cmon: Option<EuroclearClearstreamIdentifier>,
    #[yaserde(rename = "OthrPrtryId")]
    #[cfg_attr(feature = "serde", serde(rename = "OthrPrtryId"))]
    pub othr_prtry_id: Option<AlternateSecurityIdentification7>,
}

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

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

impl Validate for SettlementInstructionReason1Choice {}




#[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:acmt.001.001.08")]

pub enum SettlementInstructionReason1Code {
    #[yaserde(rename = "CSHI")]
    #[cfg_attr(feature = "serde", serde(rename = "CSHI"))]
    Cshi,
    #[yaserde(rename = "ALLL")]
    #[cfg_attr(feature = "serde", serde(rename = "ALLL"))]
    Alll,
    #[yaserde(rename = "CSHO")]
    #[cfg_attr(feature = "serde", serde(rename = "CSHO"))]
    Csho,
    #[yaserde(rename = "CHAR")]
    #[cfg_attr(feature = "serde", serde(rename = "CHAR"))]
    Char,
    #[yaserde(rename = "DIVI")]
    #[cfg_attr(feature = "serde", serde(rename = "DIVI"))]
    Divi,
    #[yaserde(rename = "INTE")]
    #[cfg_attr(feature = "serde", serde(rename = "INTE"))]
    Inte,
    #[yaserde(rename = "SAVP")]
    #[cfg_attr(feature = "serde", serde(rename = "SAVP"))]
    Savp,
    #[yaserde(rename = "REDM")]
    #[cfg_attr(feature = "serde", serde(rename = "REDM"))]
    Redm,
    #[yaserde(rename = "SAVE")]
    #[cfg_attr(feature = "serde", serde(rename = "SAVE"))]
    Save,
    #[yaserde(rename = "BUYI")]
    #[cfg_attr(feature = "serde", serde(rename = "BUYI"))]
    Buyi,
    #[yaserde(rename = "SELL")]
    #[cfg_attr(feature = "serde", serde(rename = "SELL"))]
    Sell,
    #[yaserde(rename = "SUBS")]
    #[cfg_attr(feature = "serde", serde(rename = "SUBS"))]
    Subs,
    #[yaserde(rename = "WTHP")]
    #[cfg_attr(feature = "serde", serde(rename = "WTHP"))]
    Wthp,
    #[yaserde(rename = "CORP")]
    #[cfg_attr(feature = "serde", serde(rename = "CORP"))]
    Corp,
    __Unknown__(String),
}

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

impl Validate for SettlementInstructionReason1Code {}



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

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

impl Validate for SimpleIdentificationInformation4 {}


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

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

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

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

impl Validate for StatementFrequencyReason2Choice {}




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

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

impl Validate for SwissSICIdentifier {}
#[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:acmt.001.001.08")]

pub enum TaxExemptReason3Code {
    #[yaserde(rename = "NONE")]
    #[cfg_attr(feature = "serde", serde(rename = "NONE"))]
    None,
    #[yaserde(rename = "MASA")]
    #[cfg_attr(feature = "serde", serde(rename = "MASA"))]
    Masa,
    #[yaserde(rename = "MISA")]
    #[cfg_attr(feature = "serde", serde(rename = "MISA"))]
    Misa,
    #[yaserde(rename = "SISA")]
    #[cfg_attr(feature = "serde", serde(rename = "SISA"))]
    Sisa,
    #[yaserde(rename = "IISA")]
    #[cfg_attr(feature = "serde", serde(rename = "IISA"))]
    Iisa,
    #[yaserde(rename = "CUYP")]
    #[cfg_attr(feature = "serde", serde(rename = "CUYP"))]
    Cuyp,
    #[yaserde(rename = "PRYP")]
    #[cfg_attr(feature = "serde", serde(rename = "PRYP"))]
    Pryp,
    #[yaserde(rename = "ASTR")]
    #[cfg_attr(feature = "serde", serde(rename = "ASTR"))]
    Astr,
    #[yaserde(rename = "EMPY")]
    #[cfg_attr(feature = "serde", serde(rename = "EMPY"))]
    Empy,
    #[yaserde(rename = "EMCY")]
    #[cfg_attr(feature = "serde", serde(rename = "EMCY"))]
    Emcy,
    #[yaserde(rename = "EPRY")]
    #[cfg_attr(feature = "serde", serde(rename = "EPRY"))]
    Epry,
    #[yaserde(rename = "ECYE")]
    #[cfg_attr(feature = "serde", serde(rename = "ECYE"))]
    Ecye,
    #[yaserde(rename = "NFPI")]
    #[cfg_attr(feature = "serde", serde(rename = "NFPI"))]
    Nfpi,
    #[yaserde(rename = "NFQP")]
    #[cfg_attr(feature = "serde", serde(rename = "NFQP"))]
    Nfqp,
    #[yaserde(rename = "DECP")]
    #[cfg_attr(feature = "serde", serde(rename = "DECP"))]
    Decp,
    #[yaserde(rename = "IRAC")]
    #[cfg_attr(feature = "serde", serde(rename = "IRAC"))]
    Irac,
    #[yaserde(rename = "IRAR")]
    #[cfg_attr(feature = "serde", serde(rename = "IRAR"))]
    Irar,
    #[yaserde(rename = "KEOG")]
    #[cfg_attr(feature = "serde", serde(rename = "KEOG"))]
    Keog,
    #[yaserde(rename = "PFSP")]
    #[cfg_attr(feature = "serde", serde(rename = "PFSP"))]
    Pfsp,
    #[yaserde(rename = "401K")]
    #[cfg_attr(feature = "serde", serde(rename = "401K"))]
    _401K,
    #[yaserde(rename = "SIRA")]
    #[cfg_attr(feature = "serde", serde(rename = "SIRA"))]
    Sira,
    #[yaserde(rename = "403B")]
    #[cfg_attr(feature = "serde", serde(rename = "403B"))]
    _403B,
    #[yaserde(rename = "457X")]
    #[cfg_attr(feature = "serde", serde(rename = "457X"))]
    _457X,
    #[yaserde(rename = "RIRA")]
    #[cfg_attr(feature = "serde", serde(rename = "RIRA"))]
    Rira,
    #[yaserde(rename = "RIAN")]
    #[cfg_attr(feature = "serde", serde(rename = "RIAN"))]
    Rian,
    #[yaserde(rename = "RCRF")]
    #[cfg_attr(feature = "serde", serde(rename = "RCRF"))]
    Rcrf,
    #[yaserde(rename = "RCIP")]
    #[cfg_attr(feature = "serde", serde(rename = "RCIP"))]
    Rcip,
    #[yaserde(rename = "EIFP")]
    #[cfg_attr(feature = "serde", serde(rename = "EIFP"))]
    Eifp,
    #[yaserde(rename = "EIOP")]
    #[cfg_attr(feature = "serde", serde(rename = "EIOP"))]
    Eiop,
    #[yaserde(rename = "FORE")]
    #[cfg_attr(feature = "serde", serde(rename = "FORE"))]
    Fore,
    #[yaserde(rename = "INCA")]
    #[cfg_attr(feature = "serde", serde(rename = "INCA"))]
    Inca,
    #[yaserde(rename = "MINO")]
    #[cfg_attr(feature = "serde", serde(rename = "MINO"))]
    Mino,
    #[yaserde(rename = "ASSO")]
    #[cfg_attr(feature = "serde", serde(rename = "ASSO"))]
    Asso,
    #[yaserde(rename = "DIPL")]
    #[cfg_attr(feature = "serde", serde(rename = "DIPL"))]
    Dipl,
    #[yaserde(rename = "DOME")]
    #[cfg_attr(feature = "serde", serde(rename = "DOME"))]
    Dome,
    #[yaserde(rename = "FORP")]
    #[cfg_attr(feature = "serde", serde(rename = "FORP"))]
    Forp,
    #[yaserde(rename = "ORDR")]
    #[cfg_attr(feature = "serde", serde(rename = "ORDR"))]
    Ordr,
    #[yaserde(rename = "PENF")]
    #[cfg_attr(feature = "serde", serde(rename = "PENF"))]
    Penf,
    #[yaserde(rename = "REFU")]
    #[cfg_attr(feature = "serde", serde(rename = "REFU"))]
    Refu,
    #[yaserde(rename = "RIHO")]
    #[cfg_attr(feature = "serde", serde(rename = "RIHO"))]
    Riho,
    #[yaserde(rename = "ADMI")]
    #[cfg_attr(feature = "serde", serde(rename = "ADMI"))]
    Admi,
    #[yaserde(rename = "TANR")]
    #[cfg_attr(feature = "serde", serde(rename = "TANR"))]
    Tanr,
    #[yaserde(rename = "OANR")]
    #[cfg_attr(feature = "serde", serde(rename = "OANR"))]
    Oanr,
    __Unknown__(String),
}

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

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

impl Validate for TaxExemptionReason2Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct TaxReporting3 {
    #[yaserde(rename = "TaxtnCtry")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxtnCtry"))]
    pub taxtn_ctry: CountryCode,

    #[yaserde(rename = "TaxRate")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxRate"))]
    pub tax_rate: PercentageRate,

    #[yaserde(rename = "TaxPyer")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxPyer"))]
    pub tax_pyer: PartyIdentification125Choice,

    #[yaserde(rename = "TaxRcpt")]
    #[cfg_attr(feature = "serde", serde(rename = "TaxRcpt"))]
    pub tax_rcpt: PartyIdentification125Choice,

    #[yaserde(rename = "CshAcctDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "CshAcctDtls"))]
    pub csh_acct_dtls: CashAccount204,

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

impl Validate for TaxReporting3 {}


#[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:acmt.001.001.08")]

pub enum TaxWithholdingMethod3Code {
    #[yaserde(rename = "MITX")]
    #[cfg_attr(feature = "serde", serde(rename = "MITX"))]
    Mitx,
    #[yaserde(rename = "INVE")]
    #[cfg_attr(feature = "serde", serde(rename = "INVE"))]
    Inve,
    #[yaserde(rename = "ACCT")]
    #[cfg_attr(feature = "serde", serde(rename = "ACCT"))]
    Acct,
    #[yaserde(rename = "EXMT")]
    #[cfg_attr(feature = "serde", serde(rename = "EXMT"))]
    Exmt,
    #[yaserde(rename = "REPT")]
    #[cfg_attr(feature = "serde", serde(rename = "REPT"))]
    Rept,
    #[yaserde(rename = "CRTF")]
    #[cfg_attr(feature = "serde", serde(rename = "CRTF"))]
    Crtf,
    #[yaserde(rename = "WHCO")]
    #[cfg_attr(feature = "serde", serde(rename = "WHCO"))]
    Whco,
    #[yaserde(rename = "WTHD")]
    #[cfg_attr(feature = "serde", serde(rename = "WTHD"))]
    Wthd,
    #[yaserde(rename = "WTRE")]
    #[cfg_attr(feature = "serde", serde(rename = "WTRE"))]
    Wtre,
    __Unknown__(String),
}

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

impl Validate for TaxWithholdingMethod3Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct ThirdPartyRights2 {
    #[yaserde(rename = "Tp")]
    #[cfg_attr(feature = "serde", serde(rename = "Tp"))]
    pub tp: Max35Text,

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

    #[yaserde(rename = "Hldr")]
    #[cfg_attr(feature = "serde", serde(rename = "Hldr"))]
    pub hldr: PartyIdentification125Choice,

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

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

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

impl Validate for ThirdPartyRights2 {}


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

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

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

pub enum TransactionChannel2Code {
    #[yaserde(rename = "FIAD")]
    #[cfg_attr(feature = "serde", serde(rename = "FIAD"))]
    Fiad,
    #[yaserde(rename = "HOBA")]
    #[cfg_attr(feature = "serde", serde(rename = "HOBA"))]
    Hoba,
    #[yaserde(rename = "BRAN")]
    #[cfg_attr(feature = "serde", serde(rename = "BRAN"))]
    Bran,
    __Unknown__(String),
}

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

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

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

impl Validate for TransactionType5Choice {}




#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct TreasuryProfile1 {
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Isodate,

    #[yaserde(rename = "TradrTp")]
    #[cfg_attr(feature = "serde", serde(rename = "TradrTp"))]
    pub tradr_tp: PartyRole5Choice,

    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: PercentageRate,
}

impl Validate for TreasuryProfile1 {}


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

impl Validate for UkdomesticSortCodeIdentifier {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct UnitsOrAmount1Choice {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<ActiveCurrencyAndAmount>,
    #[yaserde(rename = "Unit")]
    #[cfg_attr(feature = "serde", serde(rename = "Unit"))]
    pub unit: Option<DecimalNumber>,
}

impl Validate for UnitsOrAmount1Choice {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:acmt.001.001.08")]
pub struct UnitsOrAmountOrPercentage1Choice {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<ActiveCurrencyAndAmount>,
    #[yaserde(rename = "Unit")]
    #[cfg_attr(feature = "serde", serde(rename = "Unit"))]
    pub unit: Option<DecimalNumber>,
    #[yaserde(rename = "Pctg")]
    #[cfg_attr(feature = "serde", serde(rename = "Pctg"))]
    pub pctg: Option<PercentageRate>,
}

impl Validate for UnitsOrAmountOrPercentage1Choice {}




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

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

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

impl Validate for YesNoIndicator {}

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