rust_iso20022 0.1.1

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

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

impl Validate for AccountIdentification1 {}


#[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:camt.045.001.03")]
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 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 ActiveOrHistoricCurrencyAndAmountSimpleType (pub String);
crate::simple_type!(ActiveOrHistoricCurrencyAndAmountSimpleType);

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

impl Validate for ActiveOrHistoricCurrencyAndAmount {}


#[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:camt.045.001.03")]
pub struct AdditionalParameters1 {
    #[yaserde(rename = "Ctry")]
    #[cfg_attr(feature = "serde", serde(rename = "Ctry"))]
    pub ctry: CountryCode,

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

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

impl Validate for AdditionalParameters1 {}


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

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

impl Validate for AdditionalReference3 {}


#[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:camt.045.001.03")]

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

    #[yaserde(rename = "DmstIdSrc")]
    #[cfg_attr(feature = "serde", serde(rename = "DmstIdSrc"))]
    pub dmst_id_src: Option<CountryCode>,
    #[yaserde(rename = "PrtryIdSrc")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryIdSrc"))]
    pub prtry_id_src: Option<Max35Text>,
}

impl Validate for AlternateSecurityIdentification1 {}

pub mod alternate_security_identification_1 {
    use super::*;
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.045.001.03")]
pub struct AmountOrRate3Choice {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: Option<ActiveCurrencyAnd13DecimalAmount>,
    #[yaserde(rename = "Rate")]
    #[cfg_attr(feature = "serde", serde(rename = "Rate"))]
    pub rate: Option<PercentageRate>,
}

impl Validate for AmountOrRate3Choice {}

pub mod amount_or_rate_3_choice {
    use super::*;
}

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

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

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

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

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

    #[yaserde(rename = "CshInFcst")]
    #[cfg_attr(feature = "serde", serde(rename = "CshInFcst"))]
    pub csh_in_fcst: Vec<CashInForecast5>,

    #[yaserde(rename = "CshOutFcst")]
    #[cfg_attr(feature = "serde", serde(rename = "CshOutFcst"))]
    pub csh_out_fcst: Vec<CashOutForecast5>,

    #[yaserde(rename = "NetCshFcst")]
    #[cfg_attr(feature = "serde", serde(rename = "NetCshFcst"))]
    pub net_csh_fcst: Vec<NetCashForecast4>,
}

impl Validate for BreakdownByCountry2 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.045.001.03")]
pub struct BreakdownByCurrency2 {
    #[yaserde(rename = "Ccy")]
    #[cfg_attr(feature = "serde", serde(rename = "Ccy"))]
    pub ccy: ActiveOrHistoricCurrencyCode,

    #[yaserde(rename = "CshOutFcst")]
    #[cfg_attr(feature = "serde", serde(rename = "CshOutFcst"))]
    pub csh_out_fcst: Vec<CashOutForecast5>,

    #[yaserde(rename = "CshInFcst")]
    #[cfg_attr(feature = "serde", serde(rename = "CshInFcst"))]
    pub csh_in_fcst: Vec<CashInForecast5>,

    #[yaserde(rename = "NetCshFcst")]
    #[cfg_attr(feature = "serde", serde(rename = "NetCshFcst"))]
    pub net_csh_fcst: Vec<NetCashForecast4>,
}

impl Validate for BreakdownByCurrency2 {}


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

    #[yaserde(rename = "AddtlParams")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlParams"))]
    pub addtl_params: AdditionalParameters1,

    #[yaserde(rename = "CshInFcst")]
    #[cfg_attr(feature = "serde", serde(rename = "CshInFcst"))]
    pub csh_in_fcst: Vec<CashInForecast5>,

    #[yaserde(rename = "CshOutFcst")]
    #[cfg_attr(feature = "serde", serde(rename = "CshOutFcst"))]
    pub csh_out_fcst: Vec<CashOutForecast5>,

    #[yaserde(rename = "NetCshFcst")]
    #[cfg_attr(feature = "serde", serde(rename = "NetCshFcst"))]
    pub net_csh_fcst: Vec<NetCashForecast4>,
}

impl Validate for BreakdownByParty3 {}


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

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

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

    #[yaserde(rename = "UsrDfnd")]
    #[cfg_attr(feature = "serde", serde(rename = "UsrDfnd"))]
    pub usr_dfnd: DataFormat2Choice,

    #[yaserde(rename = "CshInFcst")]
    #[cfg_attr(feature = "serde", serde(rename = "CshInFcst"))]
    pub csh_in_fcst: Vec<CashInForecast5>,

    #[yaserde(rename = "CshOutFcst")]
    #[cfg_attr(feature = "serde", serde(rename = "CshOutFcst"))]
    pub csh_out_fcst: Vec<CashOutForecast5>,

    #[yaserde(rename = "NetCshFcst")]
    #[cfg_attr(feature = "serde", serde(rename = "NetCshFcst"))]
    pub net_csh_fcst: Vec<NetCashForecast4>,
}

impl Validate for BreakdownByUserDefinedParameter3 {}


#[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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.045.001.03")]
pub struct CashInForecast5 {
    #[yaserde(rename = "CshSttlmDt")]
    #[cfg_attr(feature = "serde", serde(rename = "CshSttlmDt"))]
    pub csh_sttlm_dt: Isodate,

    #[yaserde(rename = "SubTtlAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "SubTtlAmt"))]
    pub sub_ttl_amt: ActiveOrHistoricCurrencyAndAmount,

    #[yaserde(rename = "SubTtlUnitsNb")]
    #[cfg_attr(feature = "serde", serde(rename = "SubTtlUnitsNb"))]
    pub sub_ttl_units_nb: FinancialInstrumentQuantity1,

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

    #[yaserde(rename = "CshInBrkdwnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "CshInBrkdwnDtls"))]
    pub csh_in_brkdwn_dtls: Vec<FundCashInBreakdown3>,

    #[yaserde(rename = "AddtlBal")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlBal"))]
    pub addtl_bal: FundBalance1,
}

impl Validate for CashInForecast5 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.045.001.03")]
pub struct CashOutForecast5 {
    #[yaserde(rename = "CshSttlmDt")]
    #[cfg_attr(feature = "serde", serde(rename = "CshSttlmDt"))]
    pub csh_sttlm_dt: Isodate,

    #[yaserde(rename = "SubTtlAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "SubTtlAmt"))]
    pub sub_ttl_amt: ActiveOrHistoricCurrencyAndAmount,

    #[yaserde(rename = "SubTtlUnitsNb")]
    #[cfg_attr(feature = "serde", serde(rename = "SubTtlUnitsNb"))]
    pub sub_ttl_units_nb: FinancialInstrumentQuantity1,

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

    #[yaserde(rename = "CshOutBrkdwnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "CshOutBrkdwnDtls"))]
    pub csh_out_brkdwn_dtls: Vec<FundCashOutBreakdown3>,

    #[yaserde(rename = "AddtlBal")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlBal"))]
    pub addtl_bal: FundBalance1,
}

impl Validate for CashOutForecast5 {}


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

    #[yaserde(rename = "ChrgApld")]
    #[cfg_attr(feature = "serde", serde(rename = "ChrgApld"))]
    pub chrg_apld: AmountOrRate3Choice,
}

impl Validate for Charge26 {}


#[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:camt.045.001.03")]

pub enum ChargeType12Code {
    #[yaserde(rename = "BEND")]
    #[cfg_attr(feature = "serde", serde(rename = "BEND"))]
    Bend,
    #[yaserde(rename = "DISC")]
    #[cfg_attr(feature = "serde", serde(rename = "DISC"))]
    Disc,
    #[yaserde(rename = "FEND")]
    #[cfg_attr(feature = "serde", serde(rename = "FEND"))]
    Fend,
    #[yaserde(rename = "POST")]
    #[cfg_attr(feature = "serde", serde(rename = "POST"))]
    Post,
    #[yaserde(rename = "REGF")]
    #[cfg_attr(feature = "serde", serde(rename = "REGF"))]
    Regf,
    #[yaserde(rename = "SHIP")]
    #[cfg_attr(feature = "serde", serde(rename = "SHIP"))]
    Ship,
    #[yaserde(rename = "SPCN")]
    #[cfg_attr(feature = "serde", serde(rename = "SPCN"))]
    Spcn,
    #[yaserde(rename = "TRAN")]
    #[cfg_attr(feature = "serde", serde(rename = "TRAN"))]
    Tran,
    __Unknown__(String),
}

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

impl Validate for ChargeType12Code {}



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

impl Validate for ChargeType4Choice {}

pub mod charge_type_4_choice {
    use super::*;
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.045.001.03")]
pub struct Commission21 {
    #[yaserde(rename = "ComssnTp")]
    #[cfg_attr(feature = "serde", serde(rename = "ComssnTp"))]
    pub comssn_tp: CommissionType5Choice,

    #[yaserde(rename = "ComssnApld")]
    #[cfg_attr(feature = "serde", serde(rename = "ComssnApld"))]
    pub comssn_apld: AmountOrRate3Choice,
}

impl Validate for Commission21 {}


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

impl Validate for CommissionType5Choice {}

pub mod commission_type_5_choice {
    use super::*;
}

#[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:camt.045.001.03")]

pub enum CommissionType6Code {
    #[yaserde(rename = "FEND")]
    #[cfg_attr(feature = "serde", serde(rename = "FEND"))]
    Fend,
    #[yaserde(rename = "BEND")]
    #[cfg_attr(feature = "serde", serde(rename = "BEND"))]
    Bend,
    #[yaserde(rename = "CDPL")]
    #[cfg_attr(feature = "serde", serde(rename = "CDPL"))]
    Cdpl,
    __Unknown__(String),
}

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

impl Validate for CommissionType6Code {}



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

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

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

impl Validate for CountryCode {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.045.001.03")]
pub struct CurrencyDesignation1 {
    #[yaserde(rename = "CcyDsgnt")]
    #[cfg_attr(feature = "serde", serde(rename = "CcyDsgnt"))]
    pub ccy_dsgnt: CurrencyDesignation1Code,

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

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

impl Validate for CurrencyDesignation1 {}


#[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:camt.045.001.03")]

pub enum CurrencyDesignation1Code {
    #[yaserde(rename = "ONSH")]
    #[cfg_attr(feature = "serde", serde(rename = "ONSH"))]
    Onsh,
    #[yaserde(rename = "OFFS")]
    #[cfg_attr(feature = "serde", serde(rename = "OFFS"))]
    Offs,
    __Unknown__(String),
}

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

impl Validate for CurrencyDesignation1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.045.001.03")]
pub struct DataFormat2Choice {
    #[yaserde(rename = "Strd")]
    #[cfg_attr(feature = "serde", serde(rename = "Strd"))]
    pub strd: Option<GenericIdentification1>,
    #[yaserde(rename = "Ustrd")]
    #[cfg_attr(feature = "serde", serde(rename = "Ustrd"))]
    pub ustrd: Option<Max140Text>,
}

impl Validate for DataFormat2Choice {}

pub mod data_format_2_choice {
    use super::*;
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.045.001.03")]
pub struct DateAndDateTimeChoice {
    #[yaserde(rename = "Dt")]
    #[cfg_attr(feature = "serde", serde(rename = "Dt"))]
    pub dt: Option<Isodate>,
    #[yaserde(rename = "DtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "DtTm"))]
    pub dt_tm: Option<IsodateTime>,
}

impl Validate for DateAndDateTimeChoice {}

pub mod date_and_date_time_choice {
    use super::*;
}

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

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:camt.045.001.03")]
pub struct Document {
    #[yaserde(rename = "FndDtldConfdCshFcstRptCxl")]
    #[cfg_attr(feature = "serde", serde(rename = "FndDtldConfdCshFcstRptCxl"))]
    pub fnd_dtld_confd_csh_fcst_rpt_cxl: FundDetailedConfirmedCashForecastReportCancellationV03,
}

impl Validate for Document {}


#[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(Default, Clone, PartialEq, Debug)]
pub struct EuroclearClearstreamIdentifier (pub String);
crate::simple_type!(EuroclearClearstreamIdentifier);

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

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

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

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

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

    #[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 = "DualFndInd")]
    #[cfg_attr(feature = "serde", serde(rename = "DualFndInd"))]
    pub dual_fnd_ind: YesNoIndicator,
}

impl Validate for FinancialInstrument9 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.045.001.03")]
pub struct FinancialInstrumentQuantity1 {
    #[yaserde(rename = "Unit")]
    #[cfg_attr(feature = "serde", serde(rename = "Unit"))]
    pub unit: DecimalNumber,
}

impl Validate for FinancialInstrumentQuantity1 {}


#[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:camt.045.001.03")]

pub enum FlowDirectionType1Code {
    #[yaserde(rename = "INCG")]
    #[cfg_attr(feature = "serde", serde(rename = "INCG"))]
    Incg,
    #[yaserde(rename = "OUTG")]
    #[cfg_attr(feature = "serde", serde(rename = "OUTG"))]
    Outg,
    __Unknown__(String),
}

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

impl Validate for FlowDirectionType1Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.045.001.03")]
pub struct ForeignExchangeTerms19 {
    #[yaserde(rename = "UnitCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitCcy"))]
    pub unit_ccy: ActiveCurrencyCode,

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

    #[yaserde(rename = "XchgRate")]
    #[cfg_attr(feature = "serde", serde(rename = "XchgRate"))]
    pub xchg_rate: BaseOneRate,
}

impl Validate for ForeignExchangeTerms19 {}


#[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:camt.045.001.03")]

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:camt.045.001.03")]
pub struct Fund4 {
    #[yaserde(rename = "Nm")]
    #[cfg_attr(feature = "serde", serde(rename = "Nm"))]
    pub nm: Max350Text,

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

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

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

    #[yaserde(rename = "TtlNAV")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlNAV"))]
    pub ttl_nav: ActiveOrHistoricCurrencyAndAmount,

    #[yaserde(rename = "PrvsTtlNAV")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvsTtlNAV"))]
    pub prvs_ttl_nav: ActiveOrHistoricCurrencyAndAmount,

    #[yaserde(rename = "TtlUnitsNb")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlUnitsNb"))]
    pub ttl_units_nb: FinancialInstrumentQuantity1,

    #[yaserde(rename = "PrvsTtlUnitsNb")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvsTtlUnitsNb"))]
    pub prvs_ttl_units_nb: FinancialInstrumentQuantity1,

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

impl Validate for Fund4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.045.001.03")]
pub struct FundBalance1 {
    #[yaserde(rename = "TtlUnitsFrUnitOrdrs")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlUnitsFrUnitOrdrs"))]
    pub ttl_units_fr_unit_ordrs: FinancialInstrumentQuantity1,

    #[yaserde(rename = "TtlUnitsFrCshOrdrs")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlUnitsFrCshOrdrs"))]
    pub ttl_units_fr_csh_ordrs: FinancialInstrumentQuantity1,

    #[yaserde(rename = "TtlCshFrUnitOrdrs")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlCshFrUnitOrdrs"))]
    pub ttl_csh_fr_unit_ordrs: ActiveOrHistoricCurrencyAndAmount,

    #[yaserde(rename = "TtlCshFrCshOrdrs")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlCshFrCshOrdrs"))]
    pub ttl_csh_fr_csh_ordrs: ActiveOrHistoricCurrencyAndAmount,
}

impl Validate for FundBalance1 {}


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

    #[yaserde(rename = "TradDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "TradDtTm"))]
    pub trad_dt_tm: DateAndDateTimeChoice,

    #[yaserde(rename = "PrvsTradDtTm")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvsTradDtTm"))]
    pub prvs_trad_dt_tm: DateAndDateTimeChoice,

    #[yaserde(rename = "FinInstrmDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "FinInstrmDtls"))]
    pub fin_instrm_dtls: FinancialInstrument9,

    #[yaserde(rename = "TtlNAV")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlNAV"))]
    pub ttl_nav: Vec<ActiveOrHistoricCurrencyAndAmount>,

    #[yaserde(rename = "PrvsTtlNAV")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvsTtlNAV"))]
    pub prvs_ttl_nav: Vec<ActiveOrHistoricCurrencyAndAmount>,

    #[yaserde(rename = "TtlUnitsNb")]
    #[cfg_attr(feature = "serde", serde(rename = "TtlUnitsNb"))]
    pub ttl_units_nb: FinancialInstrumentQuantity1,

    #[yaserde(rename = "PrvsTtlUnitsNb")]
    #[cfg_attr(feature = "serde", serde(rename = "PrvsTtlUnitsNb"))]
    pub prvs_ttl_units_nb: FinancialInstrumentQuantity1,

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

    #[yaserde(rename = "InvstmtCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "InvstmtCcy"))]
    pub invstmt_ccy: Vec<ActiveOrHistoricCurrencyCode>,

    #[yaserde(rename = "CcySts")]
    #[cfg_attr(feature = "serde", serde(rename = "CcySts"))]
    pub ccy_sts: CurrencyDesignation1,

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

    #[yaserde(rename = "Pric")]
    #[cfg_attr(feature = "serde", serde(rename = "Pric"))]
    pub pric: UnitPrice19,

    #[yaserde(rename = "FXRate")]
    #[cfg_attr(feature = "serde", serde(rename = "FXRate"))]
    pub fx_rate: ForeignExchangeTerms19,

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

    #[yaserde(rename = "BrkdwnByPty")]
    #[cfg_attr(feature = "serde", serde(rename = "BrkdwnByPty"))]
    pub brkdwn_by_pty: Vec<BreakdownByParty3>,

    #[yaserde(rename = "BrkdwnByCtry")]
    #[cfg_attr(feature = "serde", serde(rename = "BrkdwnByCtry"))]
    pub brkdwn_by_ctry: Vec<BreakdownByCountry2>,

    #[yaserde(rename = "BrkdwnByCcy")]
    #[cfg_attr(feature = "serde", serde(rename = "BrkdwnByCcy"))]
    pub brkdwn_by_ccy: Vec<BreakdownByCurrency2>,

    #[yaserde(rename = "BrkdwnByUsrDfndParam")]
    #[cfg_attr(feature = "serde", serde(rename = "BrkdwnByUsrDfndParam"))]
    pub brkdwn_by_usr_dfnd_param: Vec<BreakdownByUserDefinedParameter3>,

    #[yaserde(rename = "NetCshFcstDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "NetCshFcstDtls"))]
    pub net_csh_fcst_dtls: Vec<NetCashForecast4>,
}

impl Validate for FundCashForecast6 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.045.001.03")]
pub struct FundCashInBreakdown3 {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: ActiveOrHistoricCurrencyAndAmount,

    #[yaserde(rename = "UnitsNb")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitsNb"))]
    pub units_nb: FinancialInstrumentQuantity1,

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

    #[yaserde(rename = "InvstmtFndTxInTp")]
    #[cfg_attr(feature = "serde", serde(rename = "InvstmtFndTxInTp"))]
    pub invstmt_fnd_tx_in_tp: InvestmentFundTransactionInType1Choice,

    #[yaserde(rename = "OrgnlOrdrQtyTp")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlOrdrQtyTp"))]
    pub orgnl_ordr_qty_tp: QuantityType1Choice,

    #[yaserde(rename = "ChrgDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "ChrgDtls"))]
    pub chrg_dtls: Vec<Charge26>,

    #[yaserde(rename = "ComssnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "ComssnDtls"))]
    pub comssn_dtls: Vec<Commission21>,

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

impl Validate for FundCashInBreakdown3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.045.001.03")]
pub struct FundCashOutBreakdown3 {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: ActiveOrHistoricCurrencyAndAmount,

    #[yaserde(rename = "UnitsNb")]
    #[cfg_attr(feature = "serde", serde(rename = "UnitsNb"))]
    pub units_nb: FinancialInstrumentQuantity1,

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

    #[yaserde(rename = "InvstmtFndTxOutTp")]
    #[cfg_attr(feature = "serde", serde(rename = "InvstmtFndTxOutTp"))]
    pub invstmt_fnd_tx_out_tp: InvestmentFundTransactionOutType1Choice,

    #[yaserde(rename = "OrgnlOrdrQtyTp")]
    #[cfg_attr(feature = "serde", serde(rename = "OrgnlOrdrQtyTp"))]
    pub orgnl_ordr_qty_tp: QuantityType1Choice,

    #[yaserde(rename = "ChrgDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "ChrgDtls"))]
    pub chrg_dtls: Vec<Charge26>,

    #[yaserde(rename = "ComssnDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "ComssnDtls"))]
    pub comssn_dtls: Vec<Commission21>,

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

impl Validate for FundCashOutBreakdown3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.045.001.03")]
pub struct FundDetailedConfirmedCashForecastReport3 {
    #[yaserde(rename = "FndOrSubFndDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "FndOrSubFndDtls"))]
    pub fnd_or_sub_fnd_dtls: Fund4,

    #[yaserde(rename = "FndCshFcstDtls")]
    #[cfg_attr(feature = "serde", serde(rename = "FndCshFcstDtls"))]
    pub fnd_csh_fcst_dtls: Vec<FundCashForecast6>,

    #[yaserde(rename = "CnsltdNetCshFcst")]
    #[cfg_attr(feature = "serde", serde(rename = "CnsltdNetCshFcst"))]
    pub cnsltd_net_csh_fcst: NetCashForecast3,

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

impl Validate for FundDetailedConfirmedCashForecastReport3 {}


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

    #[yaserde(rename = "PoolRef")]
    #[cfg_attr(feature = "serde", serde(rename = "PoolRef"))]
    pub pool_ref: AdditionalReference3,

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

    #[yaserde(rename = "RltdRef")]
    #[cfg_attr(feature = "serde", serde(rename = "RltdRef"))]
    pub rltd_ref: Vec<AdditionalReference3>,

    #[yaserde(rename = "MsgPgntn")]
    #[cfg_attr(feature = "serde", serde(rename = "MsgPgntn"))]
    pub msg_pgntn: Pagination,

    #[yaserde(rename = "CshFcstRptToBeCanc")]
    #[cfg_attr(feature = "serde", serde(rename = "CshFcstRptToBeCanc"))]
    pub csh_fcst_rpt_to_be_canc: FundDetailedConfirmedCashForecastReport3,
}

impl Validate for FundDetailedConfirmedCashForecastReportCancellationV03 {}


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

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

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

impl Validate for IsodateTime {}
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.045.001.03")]
pub struct IdentificationSource5Choice {
    #[yaserde(rename = "DmstIdSrc")]
    #[cfg_attr(feature = "serde", serde(rename = "DmstIdSrc"))]
    pub dmst_id_src: Option<CountryCode>,
    #[yaserde(rename = "PrtryIdSrc")]
    #[cfg_attr(feature = "serde", serde(rename = "PrtryIdSrc"))]
    pub prtry_id_src: Option<Max35Text>,
}

impl Validate for IdentificationSource5Choice {}

pub mod identification_source_5_choice {
    use super::*;
}

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.045.001.03")]
pub struct InvestmentAccount42 {
    #[yaserde(rename = "AcctId")]
    #[cfg_attr(feature = "serde", serde(rename = "AcctId"))]
    pub acct_id: AccountIdentification1,

    #[yaserde(rename = "OwnrId")]
    #[cfg_attr(feature = "serde", serde(rename = "OwnrId"))]
    pub ownr_id: PartyIdentification2Choice,

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

impl Validate for InvestmentAccount42 {}


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

impl Validate for InvestmentFundTransactionInType1Choice {}

pub mod investment_fund_transaction_in_type_1_choice {
    use super::*;
}

#[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:camt.045.001.03")]

pub enum InvestmentFundTransactionInType1Code {
    #[yaserde(rename = "SUBS")]
    #[cfg_attr(feature = "serde", serde(rename = "SUBS"))]
    Subs,
    #[yaserde(rename = "SWII")]
    #[cfg_attr(feature = "serde", serde(rename = "SWII"))]
    Swii,
    #[yaserde(rename = "INSP")]
    #[cfg_attr(feature = "serde", serde(rename = "INSP"))]
    Insp,
    #[yaserde(rename = "CROI")]
    #[cfg_attr(feature = "serde", serde(rename = "CROI"))]
    Croi,
    #[yaserde(rename = "RDIV")]
    #[cfg_attr(feature = "serde", serde(rename = "RDIV"))]
    Rdiv,
    __Unknown__(String),
}

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

impl Validate for InvestmentFundTransactionInType1Code {}



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

impl Validate for InvestmentFundTransactionOutType1Choice {}

pub mod investment_fund_transaction_out_type_1_choice {
    use super::*;
}

#[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:camt.045.001.03")]

pub enum InvestmentFundTransactionOutType1Code {
    #[yaserde(rename = "REDM")]
    #[cfg_attr(feature = "serde", serde(rename = "REDM"))]
    Redm,
    #[yaserde(rename = "SWIO")]
    #[cfg_attr(feature = "serde", serde(rename = "SWIO"))]
    Swio,
    #[yaserde(rename = "INSP")]
    #[cfg_attr(feature = "serde", serde(rename = "INSP"))]
    Insp,
    #[yaserde(rename = "CROO")]
    #[cfg_attr(feature = "serde", serde(rename = "CROO"))]
    Croo,
    __Unknown__(String),
}

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

impl Validate for InvestmentFundTransactionOutType1Code {}



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

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

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

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

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

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

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

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

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

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

    #[yaserde(rename = "NetUnitsNb")]
    #[cfg_attr(feature = "serde", serde(rename = "NetUnitsNb"))]
    pub net_units_nb: FinancialInstrumentQuantity1,

    #[yaserde(rename = "FlowDrctn")]
    #[cfg_attr(feature = "serde", serde(rename = "FlowDrctn"))]
    pub flow_drctn: FlowDirectionType1Code,
}

impl Validate for NetCashForecast3 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.045.001.03")]
pub struct NetCashForecast4 {
    #[yaserde(rename = "CshSttlmDt")]
    #[cfg_attr(feature = "serde", serde(rename = "CshSttlmDt"))]
    pub csh_sttlm_dt: Isodate,

    #[yaserde(rename = "NetAmt")]
    #[cfg_attr(feature = "serde", serde(rename = "NetAmt"))]
    pub net_amt: ActiveOrHistoricCurrencyAndAmount,

    #[yaserde(rename = "NetUnitsNb")]
    #[cfg_attr(feature = "serde", serde(rename = "NetUnitsNb"))]
    pub net_units_nb: FinancialInstrumentQuantity1,

    #[yaserde(rename = "FlowDrctn")]
    #[cfg_attr(feature = "serde", serde(rename = "FlowDrctn"))]
    pub flow_drctn: FlowDirectionType1Code,

    #[yaserde(rename = "AddtlBal")]
    #[cfg_attr(feature = "serde", serde(rename = "AddtlBal"))]
    pub addtl_bal: FundBalance1,
}

impl Validate for NetCashForecast4 {}


#[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:camt.045.001.03")]

pub enum OrderQuantityType2Code {
    #[yaserde(rename = "UNIT")]
    #[cfg_attr(feature = "serde", serde(rename = "UNIT"))]
    Unit,
    #[yaserde(rename = "CASH")]
    #[cfg_attr(feature = "serde", serde(rename = "CASH"))]
    Cash,
    __Unknown__(String),
}

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

impl Validate for OrderQuantityType2Code {}



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

impl Validate for OtherIdentification4 {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.045.001.03")]
pub struct Pagination {
    #[yaserde(rename = "PgNb")]
    #[cfg_attr(feature = "serde", serde(rename = "PgNb"))]
    pub pg_nb: Max5NumericText,

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

impl Validate for Pagination {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.045.001.03")]
pub struct PartyIdentification2Choice {
    #[yaserde(rename = "BICOrBEI")]
    #[cfg_attr(feature = "serde", serde(rename = "BICOrBEI"))]
    pub bicor_b_e_i: Option<AnyBICIdentifier>,
    #[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 PartyIdentification2Choice {}

pub mod party_identification_2_choice {
    use super::*;
}

#[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:camt.045.001.03")]
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:camt.045.001.03")]
pub struct PriceValue1 {
    #[yaserde(rename = "Amt")]
    #[cfg_attr(feature = "serde", serde(rename = "Amt"))]
    pub amt: ActiveCurrencyAnd13DecimalAmount,
}

impl Validate for PriceValue1 {}


#[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, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.045.001.03")]
pub struct QuantityType1Choice {
    #[yaserde(rename = "Cd")]
    #[cfg_attr(feature = "serde", serde(rename = "Cd"))]
    pub cd: Option<OrderQuantityType2Code>,
    #[yaserde(rename = "Prtry")]
    #[cfg_attr(feature = "serde", serde(rename = "Prtry"))]
    pub prtry: Option<GenericIdentification47>,
}

impl Validate for QuantityType1Choice {}

pub mod quantity_type_1_choice {
    use super::*;
}

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

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

#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
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:camt.045.001.03")]
pub struct SecurityIdentification3Choice {
    #[yaserde(rename = "ISIN")]
    #[cfg_attr(feature = "serde", serde(rename = "ISIN"))]
    pub isin: Option<Isinidentifier>,
    #[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<BloombergIdentifier>,
    #[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<AlternateSecurityIdentification1>,
}

impl Validate for SecurityIdentification3Choice {}

pub mod security_identification_3_choice {
    use super::*;
}

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

impl Validate for SimpleIdentificationInformation {}


#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug)]
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:camt.045.001.03")]

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

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

impl Validate for TypeOfPrice10Code {}



#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
#[derive(Default, Clone, PartialEq, Debug, YaSerialize, YaDeserialize)]
#[yaserde(prefix = "n", default_namespace = "n", namespace = "n: urn:iso:std:iso:20022:tech:xsd:camt.045.001.03")]
pub struct UnitPrice19 {
    #[yaserde(rename = "PricTp")]
    #[cfg_attr(feature = "serde", serde(rename = "PricTp"))]
    pub pric_tp: UnitPriceType2Choice,

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

impl Validate for UnitPrice19 {}


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

impl Validate for UnitPriceType2Choice {}

pub mod unit_price_type_2_choice {
    use super::*;
}

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